dorkbox/MessageBus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

small code improvements

Browse Source
This commit is contained in:
Benjamin Diedrichsen 2014-06-26 08:59:52 +02:00
parent 7c0c0b6f82
commit ed901a8501
6 changed files with 177 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/main/java/net/engio/mbassy/common/AbstractConcurrentSet.java
View File

@ -28,18 +28,16 @@ public abstract class AbstractConcurrentSet<T> implements IConcurrentSet<T> {
protected abstract Entry<T> createEntry(T value, Entry<T> next); protected abstract Entry<T> createEntry(T value, Entry<T> next);
@Override @Override
public IConcurrentSet<T> add(T element) { public void add(T element) {
if (element == null) return this; if (element == null) return;
Lock writeLock = lock.writeLock(); Lock writeLock = lock.writeLock();
writeLock.lock(); writeLock.lock();
if (element == null || entries.containsKey(element)) { if (element == null || entries.containsKey(element)) {
writeLock.unlock(); writeLock.unlock();
return this;
} else { } else {
insert(element); insert(element);
writeLock.unlock(); writeLock.unlock();
} }
return this;
} }
@Override @Override
@ -69,7 +67,7 @@ public abstract class AbstractConcurrentSet<T> implements IConcurrentSet<T> {
} }
@Override @Override
public IConcurrentSet<T> addAll(Iterable<T> elements) { public void addAll(Iterable<T> elements) {
Lock writeLock = lock.writeLock(); Lock writeLock = lock.writeLock();
try { try {
writeLock.lock(); writeLock.lock();
@ -81,7 +79,6 @@ public abstract class AbstractConcurrentSet<T> implements IConcurrentSet<T> {
} finally { } finally {
writeLock.unlock(); writeLock.unlock();
} }
return this;
} }
@Override @Override

4
src/main/java/net/engio/mbassy/common/IConcurrentSet.java
View File

@ -8,13 +8,13 @@ package net.engio.mbassy.common;
*/ */
public interface IConcurrentSet<T> extends Iterable<T> { public interface IConcurrentSet<T> extends Iterable<T> {
IConcurrentSet<T> add(T element); void add(T element);
boolean contains(T element); boolean contains(T element);
int size(); int size();
IConcurrentSet<T> addAll(Iterable<T> elements); void addAll(Iterable<T> elements);
boolean remove(T element); boolean remove(T element);
} }

2
src/main/java/net/engio/mbassy/listener/MessageHandler.java
View File

@ -56,7 +56,7 @@ public class MessageHandler {
Map<String, Object> properties = new HashMap<String, Object>(); Map<String, Object> properties = new HashMap<String, Object>();
properties.put(HandlerMethod, handler); properties.put(HandlerMethod, handler);
// add EL filter if a condition is present // add EL filter if a condition is present
if(handlerConfig.condition() != null){ if(handlerConfig.condition().length() > 0){
if (!ElFilter.isELAvailable()) { if (!ElFilter.isELAvailable()) {
throw new IllegalStateException("A handler uses an EL filter but no EL implementation is available."); throw new IllegalStateException("A handler uses an EL filter but no EL implementation is available.");
} }

3
src/test/java/net/engio/mbassy/AllTests.java
View File

@ -22,7 +22,8 @@ import org.junit.runners.Suite;
DeadMessageTest.class, DeadMessageTest.class,
SynchronizedHandlerTest.class, SynchronizedHandlerTest.class,
SubscriptionManagerTest.class, SubscriptionManagerTest.class,
AsyncFIFOBusTest.class AsyncFIFOBusTest.class,
ConditionalHandlers.class
}) })
public class AllTests { public class AllTests {
} }

336
src/test/java/net/engio/mbassy/ConditionTest.java → src/test/java/net/engio/mbassy/ConditionalHandlers.java
View File

@ -1,168 +1,168 @@
package net.engio.mbassy; package net.engio.mbassy;
import net.engio.mbassy.bus.MBassador; import net.engio.mbassy.bus.MBassador;
import net.engio.mbassy.bus.config.BusConfiguration; import net.engio.mbassy.bus.config.BusConfiguration;
import net.engio.mbassy.common.MessageBusTest; import net.engio.mbassy.common.MessageBusTest;
import net.engio.mbassy.listener.Enveloped; import net.engio.mbassy.listener.Enveloped;
import net.engio.mbassy.listener.Handler; import net.engio.mbassy.listener.Handler;
import net.engio.mbassy.listener.Listener; import net.engio.mbassy.listener.Listener;
import net.engio.mbassy.listener.References; import net.engio.mbassy.listener.References;
import net.engio.mbassy.subscription.MessageEnvelope; import net.engio.mbassy.subscription.MessageEnvelope;
import org.junit.Test; import org.junit.Test;
import java.util.HashSet; import java.util.HashSet;
import java.util.Set; import java.util.Set;
/***************************************************************************** /*****************************************************************************
* Some unit tests for the "condition" filter. * Some unit tests for the "condition" filter.
****************************************************************************/ ****************************************************************************/
public class ConditionTest extends MessageBusTest { public class ConditionalHandlers extends MessageBusTest {
public static class TestEvent { public static class TestEvent {
private Set<String> handledBy = new HashSet<String>(); private Set<String> handledBy = new HashSet<String>();
private String type; private String type;
private int size; private int size;
public TestEvent(String type, int size) { public TestEvent(String type, int size) {
super(); super();
this.type = type; this.type = type;
this.size = size; this.size = size;
} }
public String getType() { public String getType() {
return type; return type;
} }
public int getSize() { public int getSize() {
return size; return size;
} }
public boolean wasHandledBy(String ...handlers){ public boolean wasHandledBy(String ...handlers){
for(String handler : handlers){ for(String handler : handlers){
if (!handledBy.contains(handler)) return false; if (!handledBy.contains(handler)) return false;
} }
return true; return true;
} }
public void handledBy(String handler){ public void handledBy(String handler){
handledBy.add(handler); handledBy.add(handler);
} }
} }
@Listener(references = References.Strong) @Listener(references = References.Strong)
public static class ConditionalMessageListener { public static class ConditionalMessageListener {
@Handler(condition = "msg.type == 'TEST'") @Handler(condition = "msg.type == 'TEST'")
public void handleTypeMessage(TestEvent message) { public void handleTypeMessage(TestEvent message) {
message.handledBy("handleTypeMessage"); message.handledBy("handleTypeMessage");
} }
@Handler(condition = "msg.size > 4") @Handler(condition = "msg.size > 4")
public void handleSizeMessage(TestEvent message) { public void handleSizeMessage(TestEvent message) {
message.handledBy("handleSizeMessage"); message.handledBy("handleSizeMessage");
} }
@Handler(condition = "msg.foo > 4") @Handler(condition = "msg.foo > 4")
public void handleInvalidEL(TestEvent message) { public void handleInvalidEL(TestEvent message) {
message.handledBy("handleInvalidEL"); message.handledBy("handleInvalidEL");
} }
@Handler(condition = "msg.size > 2 && msg.size < 4") @Handler(condition = "msg.size > 2 && msg.size < 4")
public void handleCombinedEL(TestEvent message) { public void handleCombinedEL(TestEvent message) {
message.handledBy( "handleCombinedEL"); message.handledBy( "handleCombinedEL");
} }
@Handler(condition = "msg.getType().equals('XYZ') && msg.getSize() == 1") @Handler(condition = "msg.getType().equals('XYZ') && msg.getSize() == 1")
public void handleMethodAccessEL(TestEvent message) { public void handleMethodAccessEL(TestEvent message) {
message.handledBy("handleMethodAccessEL"); message.handledBy("handleMethodAccessEL");
} }
@Handler(condition = "msg.type == 'TEST'") @Handler(condition = "msg.type == 'TEST'")
@Enveloped(messages = {TestEvent.class, Object.class}) @Enveloped(messages = {TestEvent.class, Object.class})
public void handleEnvelopedMessage(MessageEnvelope envelope) { public void handleEnvelopedMessage(MessageEnvelope envelope) {
envelope.<TestEvent>getMessage().handledBy("handleEnvelopedMessage"); envelope.<TestEvent>getMessage().handledBy("handleEnvelopedMessage");
} }
} }
/************************************************************************* /*************************************************************************
* @throws Exception * @throws Exception
************************************************************************/ ************************************************************************/
@Test @Test
public void testSimpleStringCondition() throws Exception { public void testSimpleStringCondition() throws Exception {
MBassador bus = getBus(BusConfiguration.Default()); MBassador bus = getBus(BusConfiguration.Default());
bus.subscribe(new ConditionalMessageListener()); bus.subscribe(new ConditionalMessageListener());
TestEvent message = new TestEvent("TEST", 0); TestEvent message = new TestEvent("TEST", 0);
bus.publish(message); bus.publish(message);
assertTrue(message.wasHandledBy("handleTypeMessage", "handleEnvelopedMessage")); assertTrue(message.wasHandledBy("handleTypeMessage", "handleEnvelopedMessage"));
assertFalse(message.wasHandledBy("handleInvalidEL")); assertFalse(message.wasHandledBy("handleInvalidEL"));
} }
/************************************************************************* /*************************************************************************
* @throws Exception * @throws Exception
************************************************************************/ ************************************************************************/
@Test @Test
public void testSimpleNumberCondition() throws Exception { public void testSimpleNumberCondition() throws Exception {
MBassador bus = getBus(BusConfiguration.Default()); MBassador bus = getBus(BusConfiguration.Default());
bus.subscribe(new ConditionalMessageListener()); bus.subscribe(new ConditionalMessageListener());
TestEvent message = new TestEvent("", 5); TestEvent message = new TestEvent("", 5);
bus.publish(message); bus.publish(message);
assertTrue(message.wasHandledBy("handleSizeMessage")); assertTrue(message.wasHandledBy("handleSizeMessage"));
assertFalse(message.wasHandledBy("handleInvalidEL")); assertFalse(message.wasHandledBy("handleInvalidEL"));
} }
/************************************************************************* /*************************************************************************
* @throws Exception * @throws Exception
************************************************************************/ ************************************************************************/
@Test @Test
public void testHandleCombinedEL() throws Exception { public void testHandleCombinedEL() throws Exception {
MBassador bus = getBus(BusConfiguration.Default()); MBassador bus = getBus(BusConfiguration.Default());
bus.subscribe(new ConditionalMessageListener()); bus.subscribe(new ConditionalMessageListener());
TestEvent message = new TestEvent("", 3); TestEvent message = new TestEvent("", 3);
bus.publish(message); bus.publish(message);
assertTrue(message.wasHandledBy("handleCombinedEL")); assertTrue(message.wasHandledBy("handleCombinedEL"));
assertFalse(message.wasHandledBy("handleInvalidEL")); assertFalse(message.wasHandledBy("handleInvalidEL"));
} }
/************************************************************************* /*************************************************************************
* @throws Exception * @throws Exception
************************************************************************/ ************************************************************************/
@Test @Test
public void testNotMatchingAnyCondition() throws Exception { public void testNotMatchingAnyCondition() throws Exception {
MBassador bus = getBus(BusConfiguration.Default()); MBassador bus = getBus(BusConfiguration.Default());
bus.subscribe(new ConditionalMessageListener()); bus.subscribe(new ConditionalMessageListener());
TestEvent message = new TestEvent("", 0); TestEvent message = new TestEvent("", 0);
bus.publish(message); bus.publish(message);
assertTrue(message.handledBy.isEmpty()); assertTrue(message.handledBy.isEmpty());
} }
/************************************************************************* /*************************************************************************
* @throws Exception * @throws Exception
************************************************************************/ ************************************************************************/
@Test @Test
public void testHandleMethodAccessEL() throws Exception { public void testHandleMethodAccessEL() throws Exception {
MBassador bus = getBus(BusConfiguration.Default()); MBassador bus = getBus(BusConfiguration.Default());
bus.subscribe(new ConditionalMessageListener()); bus.subscribe(new ConditionalMessageListener());
TestEvent message = new TestEvent("XYZ", 1); TestEvent message = new TestEvent("XYZ", 1);
bus.publish(message); bus.publish(message);
assertTrue(message.wasHandledBy("handleMethodAccessEL")); assertTrue(message.wasHandledBy("handleMethodAccessEL"));
assertFalse(message.wasHandledBy("handleInvalidEL")); assertFalse(message.wasHandledBy("handleInvalidEL"));
} }
} }

2
src/test/java/net/engio/mbassy/common/ListenerFactory.java
View File

@ -30,7 +30,7 @@ public class ListenerFactory {
return this; return this;
} }
public ListenerFactory create(int numberOfInstances, Class[] classes){ public ListenerFactory create(int numberOfInstances, Class ...classes){
for(Class clazz : classes) for(Class clazz : classes)
create(numberOfInstances,clazz); create(numberOfInstances,clazz);
return this; return this;