From 13170472682e579e46833568ac739432aec432f3 Mon Sep 17 00:00:00 2001
From: Rik Veenboer <rik.veenboer@gmail.com>
Date: Mon, 20 Jun 2016 11:11:57 +0100
Subject: [PATCH] Snapshot of base part

---
 java/base/src/main/java/base/work/Listen.java | 204 ++++++++--------
 java/base/src/main/java/base/work/Work.java   | 146 +++++------
 .../java/base/worker/BackgroundListener.java  |  43 ++--
 .../main/java/base/worker/ThreadWorker.java   |  90 +++----
 .../src/main/java/base/worker/Worker.java     | 228 +++++++++---------
 java/base/src/test/java/junit/AllTests.java   |  31 +--
 6 files changed, 365 insertions(+), 377 deletions(-)

diff --git a/java/base/src/main/java/base/work/Listen.java b/java/base/src/main/java/base/work/Listen.java
index c323c4c..57be36e 100644
--- a/java/base/src/main/java/base/work/Listen.java
+++ b/java/base/src/main/java/base/work/Listen.java
@@ -1,108 +1,96 @@
-package base.work;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-
-import base.exception.worker.ActivateException;
-import base.worker.ForegroundListener;
-import base.worker.BackgroundListener;
-import base.worker.Worker;
-import base.worker.pool.Listener;
-import base.worker.pool.ListenerPool;
-import base.worker.pool.PooledListener;
-
-public abstract class Listen<E> extends Work implements Listener<E> {
-    protected static final Worker.Type WORKER_TYPE = Worker.Type.DIRECT;
-
-    protected Listener<E> listener;
-    protected Worker.Type workerType;
-    public Queue<E> queue;
-
-    public Listen() {
-        this(WORKER_TYPE);
-    }
-
-    protected Listen(Worker.Type workerType) {
-        this.workerType = workerType;
-        switch (workerType) {
-            case DIRECT:
-                return;
-            case FOREGROUND:
-                listener = new ForegroundListener<E>(this);
-                break;
-            default:
-                listener = new BackgroundListener<E>(this);
-                break;
-        }
-        queue = new ConcurrentLinkedQueue<E>();
-    }
-
-    protected Listen(Worker worker) {
-        this.worker = worker;
-        queue = new ConcurrentLinkedQueue<E>();
-    }
-
-    protected Listen(ListenerPool<E> listenerPool) {
-        listener = new PooledListener<E>(this);
-        listenerPool.add((PooledListener<E>) listener);
-        queue = new ConcurrentLinkedQueue<E>();
-    }
-
-    public synchronized void add(E element) {
-        if (workerType.equals(Worker.Type.DIRECT)) {
-            input(element);
-        } else {
-            listener.add(element);
-        }
-    }
-
-    public void start() {
-        if (workerType.equals(Worker.Type.DIRECT)) {
-            try {
-                activate();
-            } catch (ActivateException e) {
-                logger.error("Failed to start directly", e);
-            }
-        } else {
-            super.start();
-        }
-    }
-
-    public void stop() {
-        super.stop();
-        synchronized (this) {
-            notifyAll();
-        }
-    }
-
-    public void work() {
-        while (!queue.isEmpty()) {
-            logger.debug("Listen: work() > input");
-            input(queue.poll());
-        }
-        synchronized (this) {
-            logger.debug("Listen: work() > wait");
-            try {                
-                wait();                
-            } catch (InterruptedException e) {}
-            logger.debug("Listen: work() > notified");
-        }
-    }
-
-    public void input(Object object) {
-        MethodType methodType = MethodType.methodType(void.class, object.getClass());
-        MethodHandles.Lookup lookup = MethodHandles.lookup();
-        MethodHandle methodHandle;
-        try {
-            methodHandle = lookup.findVirtual(getClass(), "input", methodType);
-            methodHandle.invoke(this, object);
-        } catch (Exception e) {
-            logger.error("", e);
-        } catch (Throwable e) {
-            logger.error("", e);
-        }
-    }
-}
+package base.work;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import base.exception.worker.ActivateException;
+import base.worker.BackgroundListener;
+import base.worker.ForegroundListener;
+import base.worker.Worker;
+import base.worker.pool.Listener;
+import base.worker.pool.ListenerPool;
+import base.worker.pool.PooledListener;
+
+public abstract class Listen<E> extends Work implements Listener<E> {
+    protected static final Worker.Type WORKER_TYPE = Worker.Type.DIRECT;
+
+    protected Listener<E> listener;
+    protected Worker.Type workerType;
+    public Queue<E> queue;
+
+    public Listen() {
+        this(WORKER_TYPE);
+    }
+
+    protected Listen(Worker.Type workerType) {
+        queue = new ConcurrentLinkedQueue<E>();
+        this.workerType = workerType;
+        switch (workerType) {
+            case DIRECT:
+                return;
+            case FOREGROUND:
+                listener = new ForegroundListener<E>(this);
+                break;
+            default:
+                listener = new BackgroundListener<E>(this);
+                break;
+        }
+    }
+
+    protected Listen(Worker worker) {
+        this.worker = worker;
+        queue = new ConcurrentLinkedQueue<E>();
+    }
+
+    protected Listen(ListenerPool<E> listenerPool) {
+        listener = new PooledListener<E>(this);
+        listenerPool.add((PooledListener<E>) listener);
+        queue = new ConcurrentLinkedQueue<E>();
+    }
+
+    public synchronized void add(E element) {
+        if (workerType.equals(Worker.Type.DIRECT)) {
+            input(element);
+        } else {
+            queue.add(element);
+            listener.add(element);
+        }
+    }
+
+    public void start() {
+        if (workerType.equals(Worker.Type.DIRECT)) {
+            try {
+                activate();
+            } catch (ActivateException e) {
+                logger.error("Failed to start directly", e);
+            }
+        } else {
+            super.start();
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        synchronized (this) {
+            notifyAll();
+        }
+    }
+
+    public void work() {
+        while (!queue.isEmpty()) {
+            logger.debug("Listen: work() > input");
+            input(queue.poll());
+        }
+        synchronized (this) {
+            logger.debug("Listen: work() > wait");
+            try {                
+                wait();                
+            } catch (InterruptedException e) {}
+            logger.debug("Listen: work() > notified");
+        }
+    }
+
+    public void input(E element) {
+        System.err.println(element);
+    }
+}
diff --git a/java/base/src/main/java/base/work/Work.java b/java/base/src/main/java/base/work/Work.java
index 2ee9928..c4f93c2 100644
--- a/java/base/src/main/java/base/work/Work.java
+++ b/java/base/src/main/java/base/work/Work.java
@@ -1,73 +1,73 @@
-package base.work;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import base.Control;
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.worker.DirectWorker;
-import base.worker.ThreadWorker;
-import base.worker.Worker;
-import base.worker.pool.PooledWorker;
-import base.worker.pool.WorkerPool;
-
-public abstract class Work implements Control {
-    protected static final Worker.Type WORKER_TYPE = Worker.Type.BACKGROUND;
-
-    protected Logger logger = LoggerFactory.getLogger(getClass());
-
-    protected Worker worker;
-
-    protected Work() {
-        this(WORKER_TYPE);
-    }
-
-    protected Work(Worker.Type workerType) {
-        switch (workerType) {
-            case FOREGROUND:
-                worker = new DirectWorker(this);
-                break;
-            default:
-                worker = new ThreadWorker(this);
-                break;
-        }
-    }
-
-    protected Work(Worker worker) {
-        this.worker = worker;
-    }
-
-    protected Work(WorkerPool workerPool) {
-        worker = new PooledWorker(this);
-        workerPool.add((PooledWorker) worker);        
-    }
-
-    protected void sleep(int time) {
-        worker.sleep(time);
-    }
-
-    public void start() {
-        logger.debug("Work: start()");
-        worker.start();
-    }
-
-    public void stop() {
-        logger.debug("Work: stop()");
-        worker.stop();
-    }
-
-    public boolean active() {
-        logger.debug("Work: active()");
-        return worker.active();
-    }
-
-    public void exit() {
-        logger.debug("Work: exit()");
-        worker.exit();
-    }
-
-    public void activate() throws ActivateException {}
-    public void deactivate() throws DeactivateException {}
-    public abstract void work();
-}
+package base.work;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Control;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.worker.DirectWorker;
+import base.worker.ThreadWorker;
+import base.worker.Worker;
+import base.worker.pool.PooledWorker;
+import base.worker.pool.WorkerPool;
+
+public abstract class Work implements Control {
+    protected static final Worker.Type WORKER_TYPE = Worker.Type.BACKGROUND;
+
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+
+    protected Worker worker;
+
+    protected Work() {
+        this(WORKER_TYPE);
+    }
+
+    protected Work(Worker.Type workerType) {
+        switch (workerType) {
+            case FOREGROUND:
+                worker = new DirectWorker(this);
+                break;
+            default:
+                worker = new ThreadWorker(this);
+                break;
+        }
+    }
+
+    protected Work(Worker worker) {
+        this.worker = worker;
+    }
+
+    protected Work(WorkerPool workerPool) {
+        worker = new PooledWorker(this);
+        workerPool.add((PooledWorker) worker);        
+    }
+
+    protected void sleep(int time) {
+        worker.sleep(time);
+    }
+
+    public void start() {
+        logger.trace("Work: start()");
+        worker.start();
+    }
+
+    public void stop() {
+        logger.trace("Work: stop()");
+        worker.stop();
+    }
+
+    public boolean active() {
+        logger.trace("Work: active()");
+        return worker.active();
+    }
+
+    public void exit() {
+        logger.debug("Work: exit()");
+        worker.exit();
+    }
+
+    public void activate() throws ActivateException {}
+    public void deactivate() throws DeactivateException {}
+    public abstract void work();
+}
diff --git a/java/base/src/main/java/base/worker/BackgroundListener.java b/java/base/src/main/java/base/worker/BackgroundListener.java
index f0b1fe2..24c10bf 100644
--- a/java/base/src/main/java/base/worker/BackgroundListener.java
+++ b/java/base/src/main/java/base/worker/BackgroundListener.java
@@ -1,22 +1,21 @@
-package base.worker;
-
-import base.work.Listen;
-import base.worker.pool.Listener;
-
-public class BackgroundListener<E> extends ThreadWorker implements Listener<E> {
-    protected Listen<E> listen;
-
-    public BackgroundListener(Listen<E> listen) {
-        super(listen);
-        this.listen = listen;
-    }
-
-    public BackgroundListener(Listen<E> listen, boolean start) {
-        super(listen);
-    }
-
-    public void add(E element) {
-        listen.queue.add(element);
-        listen.notify();
-    }
-}
+package base.worker;
+
+import base.work.Listen;
+import base.worker.pool.Listener;
+
+public class BackgroundListener<E> extends ThreadWorker implements Listener<E> {
+    protected Listen<E> listen;
+
+    public BackgroundListener(Listen<E> listen) {
+        this(listen, true);
+    }
+
+    public BackgroundListener(Listen<E> listen, boolean thread) {
+       super(listen, thread);
+       this.listen = listen;
+    }
+
+    public void add(E element) {
+        listen.notify();
+    }
+}
diff --git a/java/base/src/main/java/base/worker/ThreadWorker.java b/java/base/src/main/java/base/worker/ThreadWorker.java
index 5711172..a9b3e5c 100644
--- a/java/base/src/main/java/base/worker/ThreadWorker.java
+++ b/java/base/src/main/java/base/worker/ThreadWorker.java
@@ -1,45 +1,45 @@
-package base.worker;
-
-import base.work.Work;
-
-public class ThreadWorker extends Worker implements Runnable {
-    protected static final boolean THREAD = true;
-
-    protected boolean thread = true;
-
-    public ThreadWorker(Work work, boolean thread) {
-        this(work);
-        this.thread = thread;
-    }
-
-    public ThreadWorker(Work work) {
-        super(work);
-    }
-
-    public synchronized void start(boolean thread) {
-        if (!active) {
-            activate = true;
-        }
-        if (!run) {
-            run = true;
-            if (thread) {
-                logger.debug("Start thread");
-                new Thread(this, work.getClass().getName()).start();
-            } else {
-                logger.debug("Run directly");
-                run();
-            }
-        } else {
-            notifyAll();
-        }
-    }
-
-    public synchronized void start() {
-        start(thread);
-    }
-
-    public void exit() {
-        work.stop();
-        run = false;
-    }
-}
+package base.worker;
+
+import base.work.Work;
+
+public class ThreadWorker extends Worker implements Runnable {
+    protected static final boolean THREAD = true;
+
+    protected boolean thread = true;
+
+    public ThreadWorker(Work work, boolean thread) {
+        this(work);
+        this.thread = thread;
+    }
+
+    public ThreadWorker(Work work) {
+        super(work);
+    }
+
+    public synchronized void start(boolean thread) {
+        if (!active) {
+            activate = true;
+        }
+        if (!run) {
+            run = true;
+            if (thread) {
+                logger.debug("Start thread");
+                new Thread(this, work.getClass().getName()).start();
+            } else {
+                logger.debug("Run directly");
+                run();
+            }
+        } else {
+            notifyAll();
+        }
+    }
+
+    public synchronized void start() {
+        start(thread);
+    }
+
+    public void exit() {
+        run = false;
+        work.stop();
+    }
+}
diff --git a/java/base/src/main/java/base/worker/Worker.java b/java/base/src/main/java/base/worker/Worker.java
index 9dcf368..b5e769d 100644
--- a/java/base/src/main/java/base/worker/Worker.java
+++ b/java/base/src/main/java/base/worker/Worker.java
@@ -1,114 +1,114 @@
-package base.worker;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.work.Work;
-
-public abstract class Worker {
-    public enum Type {
-        DIRECT, FOREGROUND, BACKGROUND, POOLED
-    }
-
-    public static final int SLEEP = 100;
-
-    protected Logger logger;
-
-    protected boolean run = false;
-    protected boolean active = false;
-    protected boolean activate = false;
-    protected boolean deactivate = false;
-
-    protected Work work;
-
-    public Worker(Work work) {
-        this.work = work;
-        logger = LoggerFactory.getLogger(work.getClass());
-    }
-
-    public boolean active() {
-        logger.debug("Worker: active()");
-        return deactivate || active;
-    }
-
-    public final void run() {
-        logger.debug("Worker: run()");
-        while (run || deactivate) {
-            runActivate();
-            runDeactivate();
-            runWork();
-        }
-    }
-
-    public void runActivate() {        
-        if (activate && !active) {
-            logger.debug("Worker: runActivate()");
-            try {
-                work.activate();
-                active = true;
-            } catch (ActivateException e) {
-                logger.error("", e);
-            } finally {
-                activate = false;
-            }
-        }
-    }
-
-    public void runDeactivate() {
-        if (deactivate && active) {
-            logger.debug("Worker: runDeactivate()");
-            try {
-               work.deactivate();
-            } catch (DeactivateException e) {
-                logger.error("", e);
-            } finally {
-                deactivate = false;
-                active = false;
-            }
-        }
-    }
-
-    public void runWork() {
-        if (active) {
-            logger.debug("Worker: runWork() > work");
-            work.work();
-        } else if (run) {
-            try {
-                logger.debug("Worker: runWork() > wait");
-                synchronized (this) {
-                    wait();
-                }
-            } catch (InterruptedException e) {
-                logger.info("", e);
-            }
-        }
-    }
-
-    public void sleep() {
-        sleep(SLEEP);
-    }
-
-    public void sleep(int time) {
-        try {
-            if (time > 0) {
-                Thread.sleep(time);
-            }
-        } catch (InterruptedException e) {
-            logger.info("", e);
-        }
-    }
-
-    public abstract void start();
-
-    public void stop() {
-        logger.debug("Worker: stop()");
-        if (active && !activate) {
-            deactivate = true;
-        }
-        activate = false;
-    }
-
-    abstract public void exit();
-}
+package base.worker;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public abstract class Worker {
+    public enum Type {
+        DIRECT, FOREGROUND, BACKGROUND, POOLED
+    }
+
+    public static final int SLEEP = 100;
+
+    protected Logger logger;
+
+    protected boolean run = false;
+    protected boolean active = false;
+    protected boolean activate = false;
+    protected boolean deactivate = false;
+
+    protected Work work;
+
+    public Worker(Work work) {
+        this.work = work;
+        logger = LoggerFactory.getLogger(work.getClass());
+    }
+
+    public boolean active() {
+        logger.trace("Worker: active()");
+        return deactivate || active;
+    }
+
+    public final void run() {
+        logger.debug("Worker: run()");
+        while (run || deactivate) {
+            runActivate();
+            runDeactivate();
+            runWork();
+        }
+    }
+
+    public void runActivate() {        
+        if (activate && !active) {
+            logger.trace("Worker: runActivate()");
+            try {
+                work.activate();
+                active = true;
+            } catch (ActivateException e) {
+                logger.error("", e);
+            } finally {
+                activate = false;
+            }
+        }
+    }
+
+    public void runDeactivate() {
+        if (deactivate && active) {
+            logger.trace("Worker: runDeactivate()");
+            try {
+               work.deactivate();
+            } catch (DeactivateException e) {
+                logger.error("", e);
+            } finally {
+                deactivate = false;
+                active = false;
+            }
+        }
+    }
+
+    public void runWork() {
+        if (active) {
+            logger.trace("Worker: runWork() > work");
+            work.work();
+        } else if (run) {
+            try {
+                logger.trace("Worker: runWork() > wait");
+                synchronized (this) {
+                    wait();
+                }
+            } catch (InterruptedException e) {
+                logger.info("", e);
+            }
+        }
+    }
+
+    public void sleep() {
+        sleep(SLEEP);
+    }
+
+    public void sleep(int time) {
+        try {
+            if (time > 0) {
+                Thread.sleep(time);
+            }
+        } catch (InterruptedException e) {
+            logger.info("", e);
+        }
+    }
+
+    public abstract void start();
+
+    public void stop() {
+        logger.trace("Worker: stop()");
+        if (active && !activate) {
+            deactivate = true;
+        }
+        activate = false;
+    }
+
+    abstract public void exit();
+}
diff --git a/java/base/src/test/java/junit/AllTests.java b/java/base/src/test/java/junit/AllTests.java
index d42cc63..51827a3 100644
--- a/java/base/src/test/java/junit/AllTests.java
+++ b/java/base/src/test/java/junit/AllTests.java
@@ -1,16 +1,17 @@
-package junit;
-
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@RunWith(Suite.class)
-@SuiteClasses({
-    TestTcpSocketCommunication.class,
-    TestTcpChannelCommunication.class,
-    TestUdpUnicastCommunication.class,
-    TestUdpMulticastCommunication.class
-})
-
-public class AllTests {}
+package junit;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+    TestTcpSocketCommunication.class,
+    TestTcpChannelCommunication.class,
+    TestUdpUnicastCommunication.class,
+    TestUdpMulticastCommunication.class,
+    TestUdpDuplexCommunication.class
+})
+
+public class AllTests {}
 // Should test start()/stop() of components, check implementation
\ No newline at end of file