protected <T> ListenerHelper<T> makeListenerHelper(Class<T> listenerInterface) { return new ListenerHelper<>(listenerInterface); }
private static <T> T setupHelper(ListenerHelper<T> lh, T ... instances) { for (T instance : instances) { lh.addListener(instance); } return lh.call(); } }
/** * Constructs a new {@link ListenerHelper} that will handle listeners with the provided * interface. The provided class MUST be an interface. * * @param listenerInterface Interface that listeners need to implement */ public ListenerHelper(Class<? super T> listenerInterface) { ArgumentVerifier.assertNotNull(listenerInterface, "listenerInterface"); if (! listenerInterface.isInterface()) { throw new IllegalArgumentException("listenerInterface must be an interface"); } proxyInstance = makeProxyInstance(listenerInterface); listenersLock = new Object(); }
private void removeListenerTest(Executor executor) { ListenerHelper<TestInterface> ch = makeListenerHelper(TestInterface.class); TestImp ti = new TestImp(); assertFalse(ch.removeListener(null)); ch.addListener(ti, executor); assertFalse(ch.removeListener(null)); assertFalse(ch.removeListener(new TestImp())); assertEquals(1, ch.registeredListenerCount()); assertTrue(ch.removeListener(ti)); assertEquals(0, ch.registeredListenerCount()); ch.call().call(10, StringUtils.makeRandomString(10)); // verify not called assertNull(ti.lastString); }
ch.addListener(new TestImp(), executor); ch.addListener(new TestImp(), executor); ch.addListener(ti, executor); ch.addListener(new TestImp(), executor); ch.addListener(new TestImp(), executor); ch.addListener(removedListener, executor); ch.addListener(new TestImp(), executor); ch.addListener(new TestImp(), executor); TestImp lastListener = new TestImp(); ch.addListener(lastListener, executor); ch.call().call(firstCallInt, firstCallStr); assertEquals(8, ch.registeredListenerCount()); ch.call().call(secondCallInt, secondCallStr); assertEquals(firstCallInt, removedListener.lastInt); assertEquals(firstCallStr, removedListener.lastString);
/** * Adds a listener to be executed on the next {@link #call()} to this instance. This is the same * as adding a listener and providing null for the {@link Executor}. * * @param listener Listener to be called when {@link #call()} is invoked */ public void addListener(T listener) { addListener(listener, null); }
@Test public void getSubscribedListenersTest() { ListenerHelper<TestInterface> lh = makeListenerHelper(TestInterface.class); assertTrue(lh.getSubscribedListeners().isEmpty()); TestImp ti = new TestImp(); lh.addListener(ti); assertTrue(lh.getSubscribedListeners().contains(ti)); lh.removeListener(ti); assertTrue(lh.getSubscribedListeners().isEmpty()); }
@Test public void getSubscribedListenersMixedExecutionTest() { ListenerHelper<TestInterface> lh = makeListenerHelper(TestInterface.class); TestImp ti1 = new TestImp(); TestImp ti2 = new TestImp(); lh.addListener(ti1); lh.addListener(ti2, SameThreadSubmitterExecutor.instance()); assertTrue(lh.getSubscribedListeners().contains(ti1)); assertTrue(lh.getSubscribedListeners().contains(ti2)); }
@Test public void registeredListenerCountTest() { ListenerHelper<TestInterface> ch = makeListenerHelper(TestInterface.class); assertEquals(0, ch.registeredListenerCount()); ch.addListener(new TestImp()); assertEquals(1, ch.registeredListenerCount()); ch.addListener(new TestImp(), SameThreadSubmitterExecutor.instance()); assertEquals(2, ch.registeredListenerCount()); }
@Test public void clearListenersTest() { ListenerHelper<TestInterface> ch = makeListenerHelper(TestInterface.class); ch.addListener(new TestImp()); ch.addListener(new TestImp(), SameThreadSubmitterExecutor.instance()); assertEquals(2, ch.registeredListenerCount()); ch.clearListeners(); assertEquals(0, ch.registeredListenerCount()); }
@Test (expected = RuntimeException.class) public void callFail() { @SuppressWarnings("rawtypes") ListenerHelper<List> ch = makeListenerHelper(List.class); ch.call().get(0); }
if (addingFromCallingThread && executorListeners != null) { executorListeners = copyAndAdd(executorListeners, new Pair<>(listener, executor)); } else { if (executorListeners == null) { if (addingFromCallingThread && inThreadListeners != null) { inThreadListeners = copyAndAdd(inThreadListeners, listener); } else { if (inThreadListeners == null) {
@Override public void call(int i, String s) { super.call(i, s); ch.removeListener(removedListener); } };
ch.addListener(ti); ch.addListener(new TestImp()); ch.addListener(new TestImp()); TestImp lastListener = new TestImp(); ch.addListener(lastListener); ch.call().call(firstCallInt, firstCallStr); assertEquals(5, ch.registeredListenerCount()); ch.call().call(secondCallInt, secondCallStr); assertEquals(secondCallInt, addedListener.lastInt); assertEquals(secondCallStr, addedListener.lastString);
/** * Adds a listener to be executed on the next {@link #call()} to this instance. This is the same * as adding a listener and providing null for the {@link Executor}. * * @param listener Listener to be called when {@link #call()} is invoked */ public void addListener(T listener) { addListener(listener, null); }
@Test public void getSubscribedListenersInThreadOnlyTest() { ListenerHelper<TestInterface> lh = makeListenerHelper(TestInterface.class); TestImp ti = new TestImp(); lh.addListener(ti); assertTrue(lh.getSubscribedListeners().contains(ti)); }
@Test public void addListenerTest() { ListenerHelper<TestInterface> ch = makeListenerHelper(TestInterface.class); TestImp ti = new TestImp(); ch.addListener(ti); assertEquals(1, ch.registeredListenerCount()); if (ch instanceof DefaultExecutorListenerHelper) { // special case for extending class assertTrue(Pair.containsLeft(ch.executorListeners, ti)); } else { assertTrue(ch.inThreadListeners.contains(ti)); } }
if (addingFromCallingThread && executorListeners != null) { executorListeners = copyAndAdd(executorListeners, new Pair<>(listener, executor)); } else { if (executorListeners == null) { if (addingFromCallingThread && inThreadListeners != null) { inThreadListeners = copyAndAdd(inThreadListeners, listener); } else { if (inThreadListeners == null) {
private static <T> T setupHelper(ListenerHelper<T> lh, T ... instances) { for (T instance : instances) { lh.addListener(instance); } return lh.call(); } }
@Override public void addListener(T listener, Executor executor) { if (listener == null) { return; } if (executor == null) { executor = taskDistributor.getExecutorForKey(listener); } super.addListener(listener, executor); } }