migration

assira1/src/main/java/net/ranides/assira/events/CoreEvent.java

@@ -1,111 +1,110 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.events;
-
-/**
- *
- * @author ranides
- * @todo (migration) assira (events)
- */
-public abstract class CoreEvent implements Event {
-
-    private final EventListener source;
-
-    public EventListener<?> source() {
-        return source;
-    }
-
-    protected CoreEvent(EventListener source) {
-        this.source = source;
-    }
-
-    @Override
-    public String toString() {
-        return "CoreEvent." + getClass().getSimpleName() + "<" + source() + ">";
-    }
-
-    public static Dispose dispose(EventRouter source) {
-        return new Dispose(source);
-    }
-
-    public static Stop stop(EventRouter source) {
-        return new Stop(source);
-    }
-
-    public static Shutdown shutdown(EventRouter source) {
-        return new Shutdown(source);
-    }
-
-    public static Interrupt interrupt(EventRouter source) {
-        return new Interrupt(source);
-    }
-
-    public static Failure failure(EventListener<?> source, Throwable cause) {
-        return new Failure(source, cause);
-    }
-
-    public static class Dispose extends CoreEvent {
-        protected Dispose(EventRouter router) {
-            super(router);
-        }
-        @Override
-        public EventRouter source() {
-            return (EventRouter)super.source();
-        }
-    }
-
-    /**
-     * Zdarzenie, które może zostać wysłane do routera, w celu zakończenia jego pracy.
-     * Router rozsyła to zdarzenie do obserwatorów, tak samo jak każde inne.
-     * Router kończy działanie tylko jeśli jako źródło podany jest referencja do
-     * routera.
-     */
-    public static class Stop extends Dispose {
-        protected Stop(EventRouter router) {
-            super(router);
-        }
-    }
-
-    /**
-     * Zdarzenie wysyłane do wszystkich zainteresowanych obserwatorów routera.
-     * Informuje, że router zakończył swoją pracę. Jeśli router zakończył pracę
-     * z powodu przerwania (failure), to komunikat podanej klasy również jest
-     * rozsyłany (dokładniej: jego klasa pochodna).
-     * @see InterruptEvent
-     */
-    public static class Shutdown extends CoreEvent {
-        protected Shutdown(EventRouter source) {
-            super(source);
-        }
-
-    }
-
-    /**
-     * Zdarzenie wysyłane do wszystkich zainteresowanych obserwatorów routera.
-     * Informuje, że router zakończył swoją pracę z powodu wymuszenia - nastąpiło
-     * przerwanie i wyjątek {@link InterruptedException}.
-     */
-    public static class Interrupt extends Shutdown {
-        protected Interrupt(EventRouter name) {
-            super(name);
-        }
-    }
-
-    public static class Failure extends CoreEvent {
-
-        private final Throwable cause;
-
-        protected Failure(EventListener source, Throwable cause) {
-            super(source);
-            this.cause = cause;
-        }
-        public Throwable cause() {
-            return cause;
-        }
-    }
-
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.events;
+
+/**
+ *
+ * @author ranides
+ */
+public abstract class CoreEvent implements Event {
+
+    private final EventListener source;
+
+    public EventListener<?> source() {
+        return source;
+    }
+
+    protected CoreEvent(EventListener source) {
+        this.source = source;
+    }
+
+    @Override
+    public String toString() {
+        return "CoreEvent." + getClass().getSimpleName() + "<" + source() + ">";
+    }
+
+    public static Dispose dispose(EventRouter source) {
+        return new Dispose(source);
+    }
+
+    public static Stop stop(EventRouter source) {
+        return new Stop(source);
+    }
+
+    public static Shutdown shutdown(EventRouter source) {
+        return new Shutdown(source);
+    }
+
+    public static Interrupt interrupt(EventRouter source) {
+        return new Interrupt(source);
+    }
+
+    public static Failure failure(EventListener<?> source, Throwable cause) {
+        return new Failure(source, cause);
+    }
+
+    public static class Dispose extends CoreEvent {
+        protected Dispose(EventRouter router) {
+            super(router);
+        }
+        @Override
+        public EventRouter source() {
+            return (EventRouter)super.source();
+        }
+    }
+
+    /**
+     * Zdarzenie, które może zostać wysłane do routera, w celu zakończenia jego pracy.
+     * Router rozsyła to zdarzenie do obserwatorów, tak samo jak każde inne.
+     * Router kończy działanie tylko jeśli jako źródło podany jest referencja do
+     * routera.
+     */
+    public static class Stop extends Dispose {
+        protected Stop(EventRouter router) {
+            super(router);
+        }
+    }
+
+    /**
+     * Zdarzenie wysyłane do wszystkich zainteresowanych obserwatorów routera.
+     * Informuje, że router zakończył swoją pracę. Jeśli router zakończył pracę
+     * z powodu przerwania (failure), to komunikat podanej klasy również jest
+     * rozsyłany (dokładniej: jego klasa pochodna).
+     * @see InterruptEvent
+     */
+    public static class Shutdown extends CoreEvent {
+        protected Shutdown(EventRouter source) {
+            super(source);
+        }
+
+    }
+
+    /**
+     * Zdarzenie wysyłane do wszystkich zainteresowanych obserwatorów routera.
+     * Informuje, że router zakończył swoją pracę z powodu wymuszenia - nastąpiło
+     * przerwanie i wyjątek {@link InterruptedException}.
+     */
+    public static class Interrupt extends Shutdown {
+        protected Interrupt(EventRouter name) {
+            super(name);
+        }
+    }
+
+    public static class Failure extends CoreEvent {
+
+        private final Throwable cause;
+
+        protected Failure(EventListener source, Throwable cause) {
+            super(source);
+            this.cause = cause;
+        }
+        public Throwable cause() {
+            return cause;
+        }
+    }
+
+}

assira1/src/main/java/net/ranides/assira/events/Event.java

@@ -11,7 +11,6 @@ package net.ranides.assira.events;
  * Podstawowy interfejs, który musi implementować każda klasa, która chce być
  * przesyłana jako zdarzenie przez {@link EventRouter}
  * @author ranides
- * @todo (migration) assira (events)
  */
 public interface Event {
 

assira1/src/main/java/net/ranides/assira/events/EventBinding.java

@@ -1,65 +1,64 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.events;
-
-import net.ranides.assira.annotations.Meta;
-
-/**
- *
- * @author ranides
- * @todo (migration) assira (events)
- */
-public abstract class EventBinding<T extends Event> {
-
-    public abstract Class<T> event();
-
-    public abstract EventListener<? super T> listener();
-
-    @SuppressWarnings("unchecked")
-    public static void copyTo(EventRouter target, EventRouter source) {
-        for(EventBinding entry : source.getEventListeners()) {
-            target.addEventListener(entry.event(), entry.listener());
-        }
-    }
-
-    public static <TT extends Event> EventBinding<TT> make(Class<TT> event, EventListener<? super TT> listener) {
-        return new Simple<>(event, listener);
-    }
-
-    @Meta.Unsafe
-    @SuppressWarnings("unchecked")
-    static EventBinding<?> $make(Object event, Object listener) {
-        assert event instanceof Class;
-        assert listener instanceof EventListener;
-        return new Simple((Class)event, (EventListener)listener);
-    }
-
-    private static final class Simple<TT extends Event> extends EventBinding<TT> {
-
-        private final Class<TT> event;
-        private final EventListener<? super TT> listener;
-
-        public Simple(Class<TT> event, EventListener<? super TT> listener) {
-            this.event = event;
-            this.listener = listener;
-        }
-
-        @Override
-        public Class<TT> event() {
-            return event;
-        }
-
-        @Override
-        public EventListener<? super TT> listener() {
-            return listener;
-        }
-
-    }
-
-//    Map.Entry<Class<? extends Event>, EventListener<? super Event>>
-
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.events;
+
+import net.ranides.assira.annotations.Meta;
+
+/**
+ *
+ * @author ranides
+ */
+public abstract class EventBinding<T extends Event> {
+
+    public abstract Class<T> event();
+
+    public abstract EventListener<? super T> listener();
+
+    @SuppressWarnings("unchecked")
+    public static void copyTo(EventRouter target, EventRouter source) {
+        for(EventBinding entry : source.getEventListeners()) {
+            target.addEventListener(entry.event(), entry.listener());
+        }
+    }
+
+    public static <TT extends Event> EventBinding<TT> make(Class<TT> event, EventListener<? super TT> listener) {
+        return new Simple<>(event, listener);
+    }
+
+    @Meta.Unsafe
+    @SuppressWarnings("unchecked")
+    static EventBinding<?> $make(Object event, Object listener) {
+        assert event instanceof Class;
+        assert listener instanceof EventListener;
+        return new Simple((Class)event, (EventListener)listener);
+    }
+
+    private static final class Simple<TT extends Event> extends EventBinding<TT> {
+
+        private final Class<TT> event;
+        private final EventListener<? super TT> listener;
+
+        public Simple(Class<TT> event, EventListener<? super TT> listener) {
+            this.event = event;
+            this.listener = listener;
+        }
+
+        @Override
+        public Class<TT> event() {
+            return event;
+        }
+
+        @Override
+        public EventListener<? super TT> listener() {
+            return listener;
+        }
+
+    }
+
+//    Map.Entry<Class<? extends Event>, EventListener<? super Event>>
+
+}

assira1/src/main/java/net/ranides/assira/events/EventDispatcher.java

@@ -1,229 +1,228 @@
-/*
- *  @author Ranides Atterwim <ranides@gmail.com>
- *  @copyright Ranides Atterwim
- *  @license WTFPL
- *  @url http://ranides.net/projects/assira
- */
-
-package net.ranides.assira.events;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import net.ranides.assira.trace.AdvLogger;
-import net.ranides.assira.trace.LoggerUtils;
-import net.ranides.assira.trace.ThreadInspector;
-import org.apache.log4j.Level;
-
-/**
- * Beznarzutowy EventRouter, nie kolejkuje zdarzeń.
- * Wywołuje procedury obsługi natychmiast po wywołaniu zdarzenia, w wątku, który
- * zasygnalizował event.
- * <p>
- * Użyteczny wszędzie tam, gdzie mamy pewność, że nadawcy i odbiorcy działają
- * w jednym wątku, albo wtedy, gdy rejestrowani obserwatorzy zdarzeń realizują
- * obsługę komunikatów w taki sposób, że mogą ruszyć w dowolnym wątku (bo wykonują
- * operacje thread-safe, albo używają innych metod synchronizacji).
- * </p>
- * @author ranides
- * @todo (migration) assira (events)
- */
-public class EventDispatcher implements EventRouter {
-
-    private static final AdvLogger LOGGER = LoggerUtils.getLogger();
-
-    private Object[] listeners = null;
-
-    @Override
-    public <T extends Event> void addEventListener(Class<T> event, EventListener<? super T> listener) {
-        // atomic operation, signal update
-        synchronized(this) {
-            if(null == listeners) {
-                listeners = new Object[]{event, listener};
-            } else {
-                int size = listeners.length;
-                Object[] realloc = new Object[size+2];
-                System.arraycopy(listeners, 0, realloc, 0, size);
-                realloc[size] = event;
-                realloc[size+1] = listener;
-                listeners = realloc;
-            }
-        }
-    }
-
-    @Override
-    public <T extends Event> void removeEventListener(Class<T> event, EventListener<? super T> listener) {
-        // atomic operation, signal update
-        synchronized(this) {
-            if(null == listeners) {
-                return;
-            }
-            int index = -1;
-            for (int i = listeners.length-2; i>=0; i-=2) {
-                if ((listeners[i]==event) && listeners[i+1].equals(listener) ) {
-                    index = i;
-                    break;
-                }
-            }
-
-            if (index != -1) {
-                if(listeners.length==2) {
-                    listeners = null;
-                } else {
-                    int size = listeners.length-2;
-                    Object[] realloc = new Object[size];
-                    System.arraycopy(listeners, 0, realloc, 0, index);
-                    if (index < size) {
-                        System.arraycopy(listeners, index+2, realloc, index, size-index);
-                    }
-                    listeners = realloc;
-                }
-            }
-        }
-    }
-
-    @Override
-    public void removeAllEventListeners() {
-        // atomic operation, signal update
-        synchronized(this) {
-            listeners = null;
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public Collection<EventBinding<?>> getEventListeners() {
-        Object[] array;
-        // read updated
-        synchronized(this) {
-            array = listeners;
-        }
-        // read update
-        if(null == array) {
-            return Collections.emptyList();
-        }
-        List<EventBinding<?>> list = new ArrayList<>();
-        for(int i=0, n=array.length; i<n; i+=2) {
-            list.add(EventBinding.$make(array[i], array[i+1]));
-        }
-        return list;
-    }
-    
-    @Override
-    @SuppressWarnings("unchecked")
-    public int getEventListenersCount() {
-        synchronized(this) {
-            return null == listeners ? 0 : listeners.length / 2;
-        }
-    }
-
-    /**
-     * Metoda blokująca, uruchamia kolejno obsługę zdarzenia u wszystkich
-     * zarejestrowanych obserwatorów, które na zdarzenie o określonym typie oczekują.
-     * Domyślna implementacja wywołuje tę metodę bezpośrednio w {@link #signalEvent}.
-     * Metody pochodne mogą użyć poniższej metody w zupełnie inny sposób i w
-     * zupełnie innym wątku, aby zaimplementować inną strategię przetwarzania zdarzeń.
-     *
-     * <div class="message-note">thread-safe method</div>
-     * @param event
-     */
-    protected void dispatchEvent(Event event) {
-        dispatchEvent(event, false);
-    }
-
-    @SuppressWarnings("unchecked")
-    protected void dispatchEvent(Event event, boolean direct) {
-        Object[] array;
-        // read updated
-        synchronized(this) {
-            array = this.listeners;
-        }
-        if(array == null) {
-            return;
-        }
-        Class<?> clazz = event.getClass();
-        for(int i=0, n=array.length; i<n; i+=2) {
-            if( ((Class)array[i]).isAssignableFrom(clazz) ) {
-                try {
-                    if(direct) {
-                        ((EventListener)array[i+1]).handleEvent(event);
-                    } else {
-                        dispatchEvent((EventListener)array[i+1], event);
-                    }
-                } catch(Exception ex) {
-                    LOGGER.xdebug("Exception thrown from event listener. Thread: %s. Listener: %s. Event: %s",
-                        ex, Thread.currentThread().getName(), array[i+1], event
-                    );
-                    signalEvent(CoreEvent.failure(this, ex));
-                }
-            }
-        }
-    }
-
-    protected <T extends Event> void dispatchEvent(EventListener<? super T> listener, T event) {
-        listener.handleEvent(event);
-    }
-
-    /**
-     * {@inheritDoc}
-     * <p>
-     * Metoda czeka na obsłużenie komunikatu przez wszystkich zarejestrowanych obserwatorów.
-     * Obsługa komunikatu jest uruchamiana natychmiastowo, w bieżącym wątku
-     * (t.j. w tym samym, który zasygnalizował zdarzenie).
-     * </p>
-     * <p>Interesującym przypadkiem jest przekazanie Dispatcher'owi obserwatora,
-     * który jest {@code EventRouterThread}'em. Taki obserwator w bieżącym wątku
-     * obsłuży zdarzenie <i>w swoim imieniu</i>, ale ta obsługa, to nic więcej, niż zapis do
-     * wewnętrznej kolejki. Dokładniej, zgodnie z dokumentacją:</p>
-     *  <ul>
-     *      <li>ruszy metoda {@link EventRouterThread#handleEvent}</li>
-     *      <li>metoda wydeleguje obsługę do {@link EventRouterThread#signalEvent}</li>
-     *      <li>{@code signalEvent} wstawi komunikat do kolejki zdarzeń oczekujących</li>
-     *      <li>wstawiony komunikat zostanie przekazany do obserwatorów w zupełnie
-     *      innym wątku</li>
-     *      <li>w szczególności, czas obsługi jest całkowicie niezdefiniowany.
-     *          Może nastąpić przed zakończeniem metody signal z bieżącego wątku.
-     *          A może być odwrotnie - nastapić długo po jej zakończeniu</li>
-     *  </ul>
-     *
-     * <div class="message-note">thread-safe method</div>
-     * @param event
-     */
-    @Override
-    public boolean signalEvent(Event event) {
-        ThreadInspector.logLocks(Level.TRACE, LOGGER);
-        dispatchEvent(event);
-        return true;
-    }
-
-    /**
-     * Rozsyła otrzymany komunikat do wszystkich obserwatorów, delegując
-     * obsługę zdarzenia do metody {@link #signalEvent}
-     * <div class="message-note">thread-safe method</div>
-     * @param event
-     */
-    @Override
-    public void handleEvent(Event event) {
-        signalEvent(event);
-    }
-
-    protected void dispose(boolean direct) {
-        dispatchEvent(CoreEvent.dispose(this), direct);
-        // signal update
-        synchronized(this) {
-            this.listeners = null;
-        }
-    }
-
-    @Override
-    public void dispose() {
-        dispose(true);
-    }
-
-    @Override
-    public String toString() {
-        return "EventDispatcher";
-    }
-
-}
+/*
+ *  @author Ranides Atterwim <ranides@gmail.com>
+ *  @copyright Ranides Atterwim
+ *  @license WTFPL
+ *  @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.events;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import net.ranides.assira.trace.AdvLogger;
+import net.ranides.assira.trace.LoggerUtils;
+import net.ranides.assira.trace.ThreadInspector;
+import org.apache.log4j.Level;
+
+/**
+ * Beznarzutowy EventRouter, nie kolejkuje zdarzeń.
+ * Wywołuje procedury obsługi natychmiast po wywołaniu zdarzenia, w wątku, który
+ * zasygnalizował event.
+ * <p>
+ * Użyteczny wszędzie tam, gdzie mamy pewność, że nadawcy i odbiorcy działają
+ * w jednym wątku, albo wtedy, gdy rejestrowani obserwatorzy zdarzeń realizują
+ * obsługę komunikatów w taki sposób, że mogą ruszyć w dowolnym wątku (bo wykonują
+ * operacje thread-safe, albo używają innych metod synchronizacji).
+ * </p>
+ * @author ranides
+ */
+public class EventDispatcher implements EventRouter {
+
+    private static final AdvLogger LOGGER = LoggerUtils.getLogger();
+
+    private Object[] listeners = null;
+
+    @Override
+    public <T extends Event> void addEventListener(Class<T> event, EventListener<? super T> listener) {
+        // atomic operation, signal update
+        synchronized(this) {
+            if(null == listeners) {
+                listeners = new Object[]{event, listener};
+            } else {
+                int size = listeners.length;
+                Object[] realloc = new Object[size+2];
+                System.arraycopy(listeners, 0, realloc, 0, size);
+                realloc[size] = event;
+                realloc[size+1] = listener;
+                listeners = realloc;
+            }
+        }
+    }
+
+    @Override
+    public <T extends Event> void removeEventListener(Class<T> event, EventListener<? super T> listener) {
+        // atomic operation, signal update
+        synchronized(this) {
+            if(null == listeners) {
+                return;
+            }
+            int index = -1;
+            for (int i = listeners.length-2; i>=0; i-=2) {
+                if ((listeners[i]==event) && listeners[i+1].equals(listener) ) {
+                    index = i;
+                    break;
+                }
+            }
+
+            if (index != -1) {
+                if(listeners.length==2) {
+                    listeners = null;
+                } else {
+                    int size = listeners.length-2;
+                    Object[] realloc = new Object[size];
+                    System.arraycopy(listeners, 0, realloc, 0, index);
+                    if (index < size) {
+                        System.arraycopy(listeners, index+2, realloc, index, size-index);
+                    }
+                    listeners = realloc;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void removeAllEventListeners() {
+        // atomic operation, signal update
+        synchronized(this) {
+            listeners = null;
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Collection<EventBinding<?>> getEventListeners() {
+        Object[] array;
+        // read updated
+        synchronized(this) {
+            array = listeners;
+        }
+        // read update
+        if(null == array) {
+            return Collections.emptyList();
+        }
+        List<EventBinding<?>> list = new ArrayList<>();
+        for(int i=0, n=array.length; i<n; i+=2) {
+            list.add(EventBinding.$make(array[i], array[i+1]));
+        }
+        return list;
+    }
+    
+    @Override
+    @SuppressWarnings("unchecked")
+    public int getEventListenersCount() {
+        synchronized(this) {
+            return null == listeners ? 0 : listeners.length / 2;
+        }
+    }
+
+    /**
+     * Metoda blokująca, uruchamia kolejno obsługę zdarzenia u wszystkich
+     * zarejestrowanych obserwatorów, które na zdarzenie o określonym typie oczekują.
+     * Domyślna implementacja wywołuje tę metodę bezpośrednio w {@link #signalEvent}.
+     * Metody pochodne mogą użyć poniższej metody w zupełnie inny sposób i w
+     * zupełnie innym wątku, aby zaimplementować inną strategię przetwarzania zdarzeń.
+     *
+     * <div class="message-note">thread-safe method</div>
+     * @param event
+     */
+    protected void dispatchEvent(Event event) {
+        dispatchEvent(event, false);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected void dispatchEvent(Event event, boolean direct) {
+        Object[] array;
+        // read updated
+        synchronized(this) {
+            array = this.listeners;
+        }
+        if(array == null) {
+            return;
+        }
+        Class<?> clazz = event.getClass();
+        for(int i=0, n=array.length; i<n; i+=2) {
+            if( ((Class)array[i]).isAssignableFrom(clazz) ) {
+                try {
+                    if(direct) {
+                        ((EventListener)array[i+1]).handleEvent(event);
+                    } else {
+                        dispatchEvent((EventListener)array[i+1], event);
+                    }
+                } catch(Exception ex) {
+                    LOGGER.xdebug("Exception thrown from event listener. Thread: %s. Listener: %s. Event: %s",
+                        ex, Thread.currentThread().getName(), array[i+1], event
+                    );
+                    signalEvent(CoreEvent.failure(this, ex));
+                }
+            }
+        }
+    }
+
+    protected <T extends Event> void dispatchEvent(EventListener<? super T> listener, T event) {
+        listener.handleEvent(event);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Metoda czeka na obsłużenie komunikatu przez wszystkich zarejestrowanych obserwatorów.
+     * Obsługa komunikatu jest uruchamiana natychmiastowo, w bieżącym wątku
+     * (t.j. w tym samym, który zasygnalizował zdarzenie).
+     * </p>
+     * <p>Interesującym przypadkiem jest przekazanie Dispatcher'owi obserwatora,
+     * który jest {@code EventRouterThread}'em. Taki obserwator w bieżącym wątku
+     * obsłuży zdarzenie <i>w swoim imieniu</i>, ale ta obsługa, to nic więcej, niż zapis do
+     * wewnętrznej kolejki. Dokładniej, zgodnie z dokumentacją:</p>
+     *  <ul>
+     *      <li>ruszy metoda {@link EventRouterThread#handleEvent}</li>
+     *      <li>metoda wydeleguje obsługę do {@link EventRouterThread#signalEvent}</li>
+     *      <li>{@code signalEvent} wstawi komunikat do kolejki zdarzeń oczekujących</li>
+     *      <li>wstawiony komunikat zostanie przekazany do obserwatorów w zupełnie
+     *      innym wątku</li>
+     *      <li>w szczególności, czas obsługi jest całkowicie niezdefiniowany.
+     *          Może nastąpić przed zakończeniem metody signal z bieżącego wątku.
+     *          A może być odwrotnie - nastapić długo po jej zakończeniu</li>
+     *  </ul>
+     *
+     * <div class="message-note">thread-safe method</div>
+     * @param event
+     */
+    @Override
+    public boolean signalEvent(Event event) {
+        ThreadInspector.logLocks(Level.TRACE, LOGGER);
+        dispatchEvent(event);
+        return true;
+    }
+
+    /**
+     * Rozsyła otrzymany komunikat do wszystkich obserwatorów, delegując
+     * obsługę zdarzenia do metody {@link #signalEvent}
+     * <div class="message-note">thread-safe method</div>
+     * @param event
+     */
+    @Override
+    public void handleEvent(Event event) {
+        signalEvent(event);
+    }
+
+    protected void dispose(boolean direct) {
+        dispatchEvent(CoreEvent.dispose(this), direct);
+        // signal update
+        synchronized(this) {
+            this.listeners = null;
+        }
+    }
+
+    @Override
+    public void dispose() {
+        dispose(true);
+    }
+
+    @Override
+    public String toString() {
+        return "EventDispatcher";
+    }
+
+}

assira1/src/main/java/net/ranides/assira/events/EventJoiner.java

@@ -1,42 +1,41 @@
-/*
- *  @author Ranides Atterwim <ranides@gmail.com>
- *  @copyright Ranides Atterwim
- *  @license WTFPL
- *  @url http://ranides.net/projects/assira
- */
-
-package net.ranides.assira.events;
-
-/**
- * Interfejs reprezentujący strategię łączenia wielu zdarzeń, w jedno grupowe.
- * Idea złączania wielu następujących po sobie zdarzeń zbliżonego rodzaju jest 
- * między innymi intensywnie używana w blibliotece AWT oraz Swing - gdzie pozwala
- * uniknąć wielokrotnego przerysowywania tego samego elementu, albo wykonać
- * jedną operację przerysowania większego obszaru, zamiast dużej ilości odrysowań
- * "po kawałku".
- * 
- * <p>Złączanie ma realne zastosowanie wszędzie tam, gdzie można pominąć 
- * (albo złączyć) wiele kroków pośrednich, bo konsument jest zainteresowany
- * jedynie jak najszybszym powiadomieniem o osiągnięciu/otrzymaniu efektu końcowego.</p>
- * @author ranides
- * @todo (migration) assira (events)
- */
-public interface EventJoiner {
-    
-    /**
-     * Sprawdza, czy dwa następujące po sobie zdarzenia można złączyć w jedno
-     * @param first
-     * @param second
-     * @return
-     */
-    boolean isJoinable(Event first, Event second);
-    
-    /**
-     * Łączy dwa podane komunikaty i zwraca wynik złączenia jako nowe - jedno - zdarzenie.
-     * @param first
-     * @param second
-     * @return
-     */
-    Event join(Event first, Event second);
-    
-}
+/*
+ *  @author Ranides Atterwim <ranides@gmail.com>
+ *  @copyright Ranides Atterwim
+ *  @license WTFPL
+ *  @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.events;
+
+/**
+ * Interfejs reprezentujący strategię łączenia wielu zdarzeń, w jedno grupowe.
+ * Idea złączania wielu następujących po sobie zdarzeń zbliżonego rodzaju jest 
+ * między innymi intensywnie używana w blibliotece AWT oraz Swing - gdzie pozwala
+ * uniknąć wielokrotnego przerysowywania tego samego elementu, albo wykonać
+ * jedną operację przerysowania większego obszaru, zamiast dużej ilości odrysowań
+ * "po kawałku".
+ * 
+ * <p>Złączanie ma realne zastosowanie wszędzie tam, gdzie można pominąć 
+ * (albo złączyć) wiele kroków pośrednich, bo konsument jest zainteresowany
+ * jedynie jak najszybszym powiadomieniem o osiągnięciu/otrzymaniu efektu końcowego.</p>
+ * @author ranides
+ */
+public interface EventJoiner {
+    
+    /**
+     * Sprawdza, czy dwa następujące po sobie zdarzenia można złączyć w jedno
+     * @param first
+     * @param second
+     * @return
+     */
+    boolean isJoinable(Event first, Event second);
+    
+    /**
+     * Łączy dwa podane komunikaty i zwraca wynik złączenia jako nowe - jedno - zdarzenie.
+     * @param first
+     * @param second
+     * @return
+     */
+    Event join(Event first, Event second);
+    
+}

assira1/src/main/java/net/ranides/assira/events/EventListener.java

@@ -13,7 +13,6 @@ package net.ranides.assira.events;
  * klasy (lub klasy pochodnej). 
  * @param <T> typ obsługiwanych zdarzeń
  * @author ranides
- * @todo (migration) assira (events)
  */
 public interface EventListener<T extends Event> {
 

assira1/src/main/java/net/ranides/assira/events/EventLock.java

@@ -1,197 +1,196 @@
-/*
- *  @author Ranides Atterwim <ranides@gmail.com>
- *  @copyright Ranides Atterwim
- *  @license WTFPL
- *  @url http://ranides.net/projects/assira
- */
-
-package net.ranides.assira.events;
-
-import net.ranides.assira.annotations.Meta;
-import net.ranides.assira.events.EventLockQue.OwnableLockQue;
-import net.ranides.assira.events.EventLockQue.SingleLock;
-
-/**
- * Klasa pozwalająca na synchroniczną obsługę zdarzeń. Pozwala wstrzymać wykonanie
- * bieżącego wątku i oczekiwać, aż do wskazanego {@link EventRouter}'a dotrze
- * zdarzenie określonego typu.
- * <p>
- * Zależnie od rodzaju implementacji, klasa może oferować usługi o różnym stopniu
- * dokładności i bezpieczeństwa.
- * </p>
- * <p>Najsilniejsze gwarancje, to możliwość obsługi wszystkich zdarzeń określonego
- * rodzaju bez ryzyka pominięcia żadnego. Nawet jeśli jedno lub więcej zdarzeń
- * nastąpiło przed (lub pomiędzy) wywołaniem metody {@link #waitForEvent}, to zostanie
- * ono dostarczone. Gwarantowana jest również prawidłowa kolejność dostarczenia
- * komunikatów przez kolejne wywołania metod blokujących. Implementacje "silne"
- * mają duże wymagania pamięciowe, w ekstremalnym przypadku mogą spowodować
- * przepełnienie sterty, jeśli program zostanie zalany komunikatami.
- * </p>
- * <p>
- * "Słaby {@code EventLock}" daje gwarancje, że metody {@link #waitForEvent} nie
- * będą blokować, jeśli pomiędzy ich wywołaniami (albo przed wywołaniem) wystąpiło
- * obserwowane zdarzenie. Nie dają jednak gwarancji dostarczenia wszystkich
- * komunikatów - część z nich może być utracona/pominięta, w przypadku wysokiego
- * obciążenia. Słaby {@code EventLock} udostępnia informację o ilości zgubionych
- * komunikatów. Jego zaletą jest znacznie mniejsze zużycie pamięci oraz brak podatności
- * na przeciążenie aplikacji.
- * </p>
- * <p>
- * "Niebezpieczny {@code EventLock}" nie oferuje żadnych gwarancji. Co więcej:
- * metody {@link #waitForEvent} zawsze blokują, a jako wynik zwracają tylko i
- * wyłącznie wydarzenie, które nastąpiło w czasie blokady. Z tego powodu jest
- * silnie podatny na <i>race condition</i>. Jego zaletą jest niemal całkowity
- * brak obciążenia pamięci oraz procesora. Z tego powodu może być z powodzeniem
- * używany do obserwacji zdarzeń przychodzących w bardzo dużo odstępach (względem czasu
- * obsługi) bez obaw o wydajność aplikacji.
- * </p>
- * @author ranides
- * @todo (migration) assira (events)
- */
-public abstract class EventLock {
-
-    /**
-     * Niszczy obiekt {@code EventLock} i zwalnia wszystkie zasoby.
-     */
-    public abstract void release();
-
-    /**
-     * Resetuje stan obiektu - jeśli {@code EventLock} przechowywał w kolejce
-     * nieobsłużone zdarzenia - są one usuwane. Wywołanie funkcji {@code reset}
-     * pomiędzy dwoma wywołaniami metody {@code wait} może spowodować, że część zdarzeń,
-     * którymi {@code EventLock} był zainteresowany zostanie utracona.
-     */
-    public abstract void reset();
-
-    /**
-     * Metoda, której obsługa przez konkretne implementacje jest obowiązkowa.
-     * Obiekt zwrócony przez metodę jest używany do łączenia z routerem, na który
-     * będziemy oczekiwać.
-     * @return
-     */
-    protected abstract EventListener<? super Event> listener();
-
-    /**
-     * Metoda blokująca: wstrzymuje wykonanie bieżącego wątku do momentu, aż
-     * do obserwowanego {@code EventRouter}'a dotrze dowolne zdarzenie oczekiwane
-     * przez {@code EventLock} lub wystąpi wyjątek {@code InterruptedException}.
-     * Zobacz opis klasy {@link EventLock} aby poznać szczegóły.
-     * @return oczekiwane zdarzenie
-     * @throws InterruptedException
-     */
-    public abstract Event waitForEvent() throws InterruptedException;
-
-    /**
-     * Metoda blokująca: wstrzymuje wykonanie bieżącego wątku do momentu, aż
-     * do obserwowanego {@code EventRouter}'a dotrze dowolne zdarzenie oczekiwane
-     * przez {@code EventLock}, wystąpi wyjątek {@code InterruptedException}, lub
-     * minie podany czas.
-     * Zobacz opis klasy {@link EventLock} aby poznać szczegóły.
-     * @param timeout
-     * @return oczekiwane zdarzenie
-     * @throws InterruptedException
-     */
-    public abstract Event waitForEvent(long timeout) throws InterruptedException;
-
-    /**
-     * Wersja oczekująca na zdarzenie konkretnego rodzaju. Zachowuje się identycznie
-     * jak {@link #waitForEvent()}, z tą różnicą, że reaguje na mniejszy zakres
-     * zdarzeń - zawężony tylko do podanej klasy oraz jej pochodnych.
-     * <p>
-     * Metoda przydatna szczególnie wtedy, gdy utworzony obiekt {@code EventLock}
-     * reaguje na bardzo ogólną klasę zdarzeń, a użytkownik w danym momencie chce
-     * wstrzymać wykonanie w oczekiwaniu na zdarzenie bardziej szczegółowe.
-     * </p>
-     * @param <T>
-     * @param event
-     * @return oczekiwane zdarzenie lub {@code null}, jeśli minął {@code timeout}
-     * @throws InterruptedException
-     */
-    public abstract <T extends Event> T waitForEvent(Class<T> event) throws InterruptedException;
-
-    /**
-     * Wersja oczekująca na zdarzenie konkretnego rodzaju. Zachowuje się identycznie
-     * jak {@link #waitForEvent(long timeout)}, z tą różnicą, że reaguje na mniejszy zakres
-     * zdarzeń - zawężony tylko do podanej klasy oraz jej pochodnych.
-     * <p>
-     * Metoda przydatna szczególnie wtedy, gdy utworzony obiekt {@code EventLock}
-     * reaguje na bardzo ogólną klasę zdarzeń, a użytkownik w danym momencie chce
-     * wstrzymać wykonanie w oczekiwaniu na zdarzenie bardziej szczegółowe.
-     * </p>
-     * @param <T>
-     * @param event
-     * @param timeout
-     * @return oczekiwane zdarzenie lub {@code null}, jeśli minął {@code timeout}
-     * @throws InterruptedException
-     */
-    public abstract <T extends Event> T waitForEvent(Class<T> event, long timeout) throws InterruptedException;
-
-
-
-    /**
-     * Metoda tworzy silny {@code EventLock} - szczegóły "silnego kontraktu"
-     * są w opisie klasy {@link EventLock}).
-     * <p>
-     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
-     * </p>
-     * @param event
-     * @param router
-     * @return
-     */
-    public static EventLockQue lock(Class<? extends Event> event, EventRouter router) {
-        return bind(event, router, new OwnableLockQue(event, router));
-    }
-
-    /**
-     * Metoda tworzy słaby {@code EventLock} - szczegóły "słabego kontraktu"
-     * są w opisie klasy {@link EventLock}).
-     * <p>
-     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
-     * </p>
-     * @param event
-     * @param router
-     * @param capacity
-     * @return
-     */
-    public static EventLockQue weakLock(Class<? extends Event> event, EventRouter router, int capacity) {
-        return bind(event, router, new OwnableLockQue(event, router, capacity));
-    }
-
-    /**
-     * Metoda tworzy słaby {@code EventLock}, który może zostać wykorzystany tylko raz
-     * - szczegóły "słabego kontraktu" są w opisie klasy {@link EventLock}).
-     * <p>
-     * Po wywołaniu zakończeniu metody {@code waitForEvent} obiekt sam automatycznie
-     * zwalnia wszystkie zasoby i przestaje być funcjonalny.
-     * </p>
-     * @param event
-     * @param router
-     * @return
-     */
-    public static EventLock singleLock(Class<? extends Event> event, EventRouter router) {
-        return bind(event, router, new SingleLock(event, router));
-    }
-
-    /**
-     * Metoda tworzy niebezpieczny {@code EventLock} - szczegóły "niebezpiecznego kontraktu"
-     * są w opisie klasy {@link EventLock}).
-     * <p>
-     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
-     * </p>
-     * @param event
-     * @param router
-     * @return
-     */
-    @Meta.Unsafe
-    public static EventLock unsafeLock(Class<? extends Event> event, EventRouter router) {
-        return bind(event, router, new EventLockUnsafe(event, router) );
-    }
-
-
-    @SuppressWarnings("PMD.UnusedPrivateMethod") // false positive
-    private static <T extends EventLock> T bind(Class<? extends Event> event, EventRouter router, T lock) {
-        router.addEventListener(event, lock.listener());
-        return lock;
-    }
-
-}
+/*
+ *  @author Ranides Atterwim <ranides@gmail.com>
+ *  @copyright Ranides Atterwim
+ *  @license WTFPL
+ *  @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.events;
+
+import net.ranides.assira.annotations.Meta;
+import net.ranides.assira.events.EventLockQue.OwnableLockQue;
+import net.ranides.assira.events.EventLockQue.SingleLock;
+
+/**
+ * Klasa pozwalająca na synchroniczną obsługę zdarzeń. Pozwala wstrzymać wykonanie
+ * bieżącego wątku i oczekiwać, aż do wskazanego {@link EventRouter}'a dotrze
+ * zdarzenie określonego typu.
+ * <p>
+ * Zależnie od rodzaju implementacji, klasa może oferować usługi o różnym stopniu
+ * dokładności i bezpieczeństwa.
+ * </p>
+ * <p>Najsilniejsze gwarancje, to możliwość obsługi wszystkich zdarzeń określonego
+ * rodzaju bez ryzyka pominięcia żadnego. Nawet jeśli jedno lub więcej zdarzeń
+ * nastąpiło przed (lub pomiędzy) wywołaniem metody {@link #waitForEvent}, to zostanie
+ * ono dostarczone. Gwarantowana jest również prawidłowa kolejność dostarczenia
+ * komunikatów przez kolejne wywołania metod blokujących. Implementacje "silne"
+ * mają duże wymagania pamięciowe, w ekstremalnym przypadku mogą spowodować
+ * przepełnienie sterty, jeśli program zostanie zalany komunikatami.
+ * </p>
+ * <p>
+ * "Słaby {@code EventLock}" daje gwarancje, że metody {@link #waitForEvent} nie
+ * będą blokować, jeśli pomiędzy ich wywołaniami (albo przed wywołaniem) wystąpiło
+ * obserwowane zdarzenie. Nie dają jednak gwarancji dostarczenia wszystkich
+ * komunikatów - część z nich może być utracona/pominięta, w przypadku wysokiego
+ * obciążenia. Słaby {@code EventLock} udostępnia informację o ilości zgubionych
+ * komunikatów. Jego zaletą jest znacznie mniejsze zużycie pamięci oraz brak podatności
+ * na przeciążenie aplikacji.
+ * </p>
+ * <p>
+ * "Niebezpieczny {@code EventLock}" nie oferuje żadnych gwarancji. Co więcej:
+ * metody {@link #waitForEvent} zawsze blokują, a jako wynik zwracają tylko i
+ * wyłącznie wydarzenie, które nastąpiło w czasie blokady. Z tego powodu jest
+ * silnie podatny na <i>race condition</i>. Jego zaletą jest niemal całkowity
+ * brak obciążenia pamięci oraz procesora. Z tego powodu może być z powodzeniem
+ * używany do obserwacji zdarzeń przychodzących w bardzo dużo odstępach (względem czasu
+ * obsługi) bez obaw o wydajność aplikacji.
+ * </p>
+ * @author ranides
+ */
+public abstract class EventLock {
+
+    /**
+     * Niszczy obiekt {@code EventLock} i zwalnia wszystkie zasoby.
+     */
+    public abstract void release();
+
+    /**
+     * Resetuje stan obiektu - jeśli {@code EventLock} przechowywał w kolejce
+     * nieobsłużone zdarzenia - są one usuwane. Wywołanie funkcji {@code reset}
+     * pomiędzy dwoma wywołaniami metody {@code wait} może spowodować, że część zdarzeń,
+     * którymi {@code EventLock} był zainteresowany zostanie utracona.
+     */
+    public abstract void reset();
+
+    /**
+     * Metoda, której obsługa przez konkretne implementacje jest obowiązkowa.
+     * Obiekt zwrócony przez metodę jest używany do łączenia z routerem, na który
+     * będziemy oczekiwać.
+     * @return
+     */
+    protected abstract EventListener<? super Event> listener();
+
+    /**
+     * Metoda blokująca: wstrzymuje wykonanie bieżącego wątku do momentu, aż
+     * do obserwowanego {@code EventRouter}'a dotrze dowolne zdarzenie oczekiwane
+     * przez {@code EventLock} lub wystąpi wyjątek {@code InterruptedException}.
+     * Zobacz opis klasy {@link EventLock} aby poznać szczegóły.
+     * @return oczekiwane zdarzenie
+     * @throws InterruptedException
+     */
+    public abstract Event waitForEvent() throws InterruptedException;
+
+    /**
+     * Metoda blokująca: wstrzymuje wykonanie bieżącego wątku do momentu, aż
+     * do obserwowanego {@code EventRouter}'a dotrze dowolne zdarzenie oczekiwane
+     * przez {@code EventLock}, wystąpi wyjątek {@code InterruptedException}, lub
+     * minie podany czas.
+     * Zobacz opis klasy {@link EventLock} aby poznać szczegóły.
+     * @param timeout
+     * @return oczekiwane zdarzenie
+     * @throws InterruptedException
+     */
+    public abstract Event waitForEvent(long timeout) throws InterruptedException;
+
+    /**
+     * Wersja oczekująca na zdarzenie konkretnego rodzaju. Zachowuje się identycznie
+     * jak {@link #waitForEvent()}, z tą różnicą, że reaguje na mniejszy zakres
+     * zdarzeń - zawężony tylko do podanej klasy oraz jej pochodnych.
+     * <p>
+     * Metoda przydatna szczególnie wtedy, gdy utworzony obiekt {@code EventLock}
+     * reaguje na bardzo ogólną klasę zdarzeń, a użytkownik w danym momencie chce
+     * wstrzymać wykonanie w oczekiwaniu na zdarzenie bardziej szczegółowe.
+     * </p>
+     * @param <T>
+     * @param event
+     * @return oczekiwane zdarzenie lub {@code null}, jeśli minął {@code timeout}
+     * @throws InterruptedException
+     */
+    public abstract <T extends Event> T waitForEvent(Class<T> event) throws InterruptedException;
+
+    /**
+     * Wersja oczekująca na zdarzenie konkretnego rodzaju. Zachowuje się identycznie
+     * jak {@link #waitForEvent(long timeout)}, z tą różnicą, że reaguje na mniejszy zakres
+     * zdarzeń - zawężony tylko do podanej klasy oraz jej pochodnych.
+     * <p>
+     * Metoda przydatna szczególnie wtedy, gdy utworzony obiekt {@code EventLock}
+     * reaguje na bardzo ogólną klasę zdarzeń, a użytkownik w danym momencie chce
+     * wstrzymać wykonanie w oczekiwaniu na zdarzenie bardziej szczegółowe.
+     * </p>
+     * @param <T>
+     * @param event
+     * @param timeout
+     * @return oczekiwane zdarzenie lub {@code null}, jeśli minął {@code timeout}
+     * @throws InterruptedException
+     */
+    public abstract <T extends Event> T waitForEvent(Class<T> event, long timeout) throws InterruptedException;
+
+
+
+    /**
+     * Metoda tworzy silny {@code EventLock} - szczegóły "silnego kontraktu"
+     * są w opisie klasy {@link EventLock}).
+     * <p>
+     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
+     * </p>
+     * @param event
+     * @param router
+     * @return
+     */
+    public static EventLockQue lock(Class<? extends Event> event, EventRouter router) {
+        return bind(event, router, new OwnableLockQue(event, router));
+    }
+
+    /**
+     * Metoda tworzy słaby {@code EventLock} - szczegóły "słabego kontraktu"
+     * są w opisie klasy {@link EventLock}).
+     * <p>
+     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
+     * </p>
+     * @param event
+     * @param router
+     * @param capacity
+     * @return
+     */
+    public static EventLockQue weakLock(Class<? extends Event> event, EventRouter router, int capacity) {
+        return bind(event, router, new OwnableLockQue(event, router, capacity));
+    }
+
+    /**
+     * Metoda tworzy słaby {@code EventLock}, który może zostać wykorzystany tylko raz
+     * - szczegóły "słabego kontraktu" są w opisie klasy {@link EventLock}).
+     * <p>
+     * Po wywołaniu zakończeniu metody {@code waitForEvent} obiekt sam automatycznie
+     * zwalnia wszystkie zasoby i przestaje być funcjonalny.
+     * </p>
+     * @param event
+     * @param router
+     * @return
+     */
+    public static EventLock singleLock(Class<? extends Event> event, EventRouter router) {
+        return bind(event, router, new SingleLock(event, router));
+    }
+
+    /**
+     * Metoda tworzy niebezpieczny {@code EventLock} - szczegóły "niebezpiecznego kontraktu"
+     * są w opisie klasy {@link EventLock}).
+     * <p>
+     * Jeśli obiekt nie jest już potrzebny, musi zostać zwolniony za pomocą metody {@link #release()}
+     * </p>
+     * @param event
+     * @param router
+     * @return
+     */
+    @Meta.Unsafe
+    public static EventLock unsafeLock(Class<? extends Event> event, EventRouter router) {
+        return bind(event, router, new EventLockUnsafe(event, router) );
+    }
+
+
+    @SuppressWarnings("PMD.UnusedPrivateMethod") // false positive
+    private static <T extends EventLock> T bind(Class<? extends Event> event, EventRouter router, T lock) {
+        router.addEventListener(event, lock.listener());
+        return lock;
+    }
+
+}

assira1/src/main/java/net/ranides/assira/events/EventLockQue.java

@@ -19,7 +19,6 @@ import net.ranides.assira.trace.LoggerUtils;
  * {@link EventLock#weakLock},
  * {@link EventLock#singleLock},
  * @author ranides
- * @todo (migration) assira (events)
  */
 public abstract class EventLockQue extends EventLock implements EventListener<Event> {
     

assira1/src/main/java/net/ranides/assira/events/EventLockUnsafe.java

@@ -12,7 +12,6 @@ import net.ranides.assira.annotations.Meta;
 /**
  * Implementacja zwracana przez {@link EventLock#unsafeLock}
  * @author ranides
- * @todo (migration) assira (events)
  */
 @Meta.Unsafe
 public class EventLockUnsafe extends EventLock implements EventListener<Event> {

assira1/src/main/java/net/ranides/assira/events/EventProactor.java

@@ -26,7 +26,6 @@ import net.ranides.assira.trace.LoggerUtils;
  *
  * <div class="message-note">thread-safe method</div>
  * @author ranides
- * @todo (migration) assira (events)
  */
 public class EventProactor extends EventDispatcher {
 

assira1/src/main/java/net/ranides/assira/events/EventReactor.java

@@ -28,7 +28,6 @@ import org.apache.log4j.Level;
  *
  * <div class="message-note">thread-safe method</div>
  * @author ranides
- * @todo (migration) assira (events)
  */
 public class EventReactor extends EventDispatcher {
     

assira1/src/main/java/net/ranides/assira/events/EventRouter.java

@@ -21,7 +21,6 @@ import java.util.Collection;
  * posiadamy</li>
  * </ul>
  * @author ranides
- * @todo (migration) assira (events)
  */
 public interface EventRouter extends EventListener<Event> {