Move files in anticipation of move to modular system

java/application.lightroom/build.gradle

@@ -0,0 +1,3 @@
+dependencies {
+	compile 'com.github.boukefalos:jlibwinapi:0.1'
+}

java/application.lightroom/src/main/java/winapi/Amount.java

@@ -0,0 +1,14 @@
+package winapi;
+
+public enum Amount {
+    DECREASE_MUCH ("--"),
+    DECREASE_LITTLE ("-"),
+    INCREASE_LITTLE ("+"),
+    INCREASE_MUCH ("++");
+    
+    public String value;
+
+    Amount(String value) {
+        this.value = value;
+    }
+}

java/application.lightroom/src/main/java/winapi/Slider.java

@@ -0,0 +1,20 @@
+package winapi;
+public enum Slider {
+    EXPOSURE,
+    CONTRAST,
+    HIGHLIGHTS,
+    SHADOWS,
+    WHITES,
+    BLACKS,
+    CLARITY,
+    VIBRANCE;
+
+    public String getLabel() {
+        String name = this.name();
+        return String.format("%s%s", name.substring(0,  1), name.toLowerCase().substring(1));
+    }
+
+    public String getLabel(Amount amount) {
+        return String.format("%s %s", getLabel(), amount.value);
+    }
+}

java/application.lightroom/src/main/java/winapi/Test.java

@@ -0,0 +1,115 @@
+package winapi;
+import java.util.HashMap;
+import java.util.Random;
+
+import org.synthuse.Api;
+import org.synthuse.objects.MenuItem;
+
+import com.sun.jna.platform.win32.WinDef.HWND;
+
+public class Test {    
+    protected Api api;
+
+    protected HashMap<Slider, HashMap<Amount, MenuItem>> sliderMap;
+    protected HashMap<Slider, HWND> valueMap;
+
+    public Test() {
+        api = new Api();
+        sliderMap = new HashMap<Slider, HashMap<Amount, MenuItem>>();
+        valueMap = new HashMap<Slider, HWND>();
+    }
+
+    public static void main(String[] args) throws Exception {
+        Test test = new Test();
+        test.start();
+
+        //test.moveSlider(Slider.CONTRAST, Amount.INCREASE_LITTLE);
+
+        for (int k = 0; k < 5; ++k) {
+            Slider slider = Slider.values()[new Random().nextInt(Slider.values().length)];
+            for (int j = 0; j < 5; ++j) {
+                for (int i = 0; i < 10; ++i) {
+                    test.moveSlider(slider, Amount.INCREASE_LITTLE);
+                    System.out.println(test.getValue(slider));
+                    Thread.sleep(200);
+                }
+                Thread.sleep(400);
+                for (int i = 0; i < 10; ++i) {
+                    test.moveSlider(slider, Amount.INCREASE_LITTLE);
+                    Thread.sleep(200);
+                }
+            }
+        }
+    }
+
+    public Slider[] getSliders() {
+        return sliderMap.keySet().toArray(new Slider[0]);
+    }
+
+    public void moveSlider(Slider slider, Amount amount) throws Exception {
+        MenuItem menuItem = sliderMap.get(slider).get(amount);
+        api.activateItem(menuItem);
+    }
+
+    public float getValue(Slider slider) {
+        if (valueMap.containsKey(slider)) {
+            HWND hWnd = valueMap.get(slider);
+            String text = Api.getWindowText(hWnd);
+            return Float.valueOf(text.replace(" ", ""));
+        } else {
+            return 0;
+        }
+    }
+
+    public void start() throws Exception {  
+        // Find Lightroom window
+        HWND hWndTopWindow = api.findTopWindow("Lightroom", "AgWinMainFrame");
+        if (hWndTopWindow == null) {
+            throw new Exception("Can't find top window");
+        }
+
+        // Find menu options from Keyboard Tamer
+        String[] path = {"&File", "Pl&ug-in Extras", ""};
+        for (Slider slider : Slider.values()) {
+            HashMap<Amount, MenuItem> amountMap = new HashMap<Amount, MenuItem>();
+            for (Amount amount : Amount.values()) {                
+                String label = slider.getLabel(amount);
+                path[2] = String.format("   %s", label);
+                MenuItem menuItem = api.loadMenuItem(hWndTopWindow, true, path);
+                amountMap.put(amount, menuItem);
+            }
+            sliderMap.put(slider, amountMap);
+        }
+
+        // Find develop sliders
+        path = new String[]{"", "Top", "Main", "Panel", "Last Panel", "View", "ClipView", "Accordion", "Accordion"};
+        HWND hWnd = api.findChildWindow(hWndTopWindow, path);
+        if (hWnd == null) {
+            throw new Exception("Can't find window");
+        }
+        for (HWND hWndLoop : api.findAllChildWindow(hWnd, "Collapsible")) {
+            path = new String[]{"Basic", "View"};
+            hWnd = api.findChildWindow(hWndLoop, path);
+            if (hWnd != null) {
+                Slider slider = null;
+                for (HWND hWndSubLoop : api.findAllChildWindow(hWnd, "")) {
+                    //String className = Api.getWindowClassName(hWndSubLoop);
+                    String text = Api.getWindowText(hWndSubLoop);
+                    if (!text.contains("Bridge") && !text.contains("View") && text.length() > 0) {
+                        if (slider != null) {
+                            System.out.printf("%s = %s (%.2f)\n", slider.getLabel(), text, Float.valueOf(text.replace(" ", "")));
+                            valueMap.put(slider, hWndSubLoop);
+                            slider = null;
+                        } else {
+                            for (Slider sliderLoop : Slider.values()) {
+                                if (sliderLoop.getLabel().equals(text)) {
+                                    slider = sliderLoop;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

java/base/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-#Sun Jun 14 13:41:53 BST 2015
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.2-bin.zip

java/base/gradlew

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
-
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

java/build.gradle

@@ -1,7 +1,12 @@
-allprojects  {
+subprojects  {
     apply plugin: 'java'
+    apply plugin: 'maven'
+    apply plugin: 'eclipse'
+    apply plugin: 'license'
 
-	version = '0.1'
+    task wrapper(type: Wrapper) {
+        gradleVersion = '2.14'
+    }
 
     repositories {
         maven {
@@ -34,8 +39,37 @@ allprojects  {
         maven {
             url 'https://github.com/Boukefalos/jlibxinput/raw/mvn-repo/'
         }
+        maven {
+            url 'https://github.com/Boukefalos/jlibxinput/raw/mvn-repo/'
+        }
+        maven {
+            url 'https://github.com/Boukefalos/jlibwinapi/raw/mvn-repo/'
+        }
         mavenCentral()
     }
+
+    license {
+        header rootProject.file('HEADER.txt')
+        strictCheck true
+
+        skipExistingHeaders false
+        ext.year = Calendar.getInstance().get(Calendar.YEAR)
+        ext.name = 'Rik Veenboer'
+        ext.email = 'rik.veenboer@gmail.com'
+        ext.project = 'this program'
+        ext.Project = 'This program'
+        include "**/*.java"
+    }
+
+	group = 'com.github.boukefalos'
+	version = '0.1'
+	archivesBaseName = 'mimis-' + project.name
+
+    uploadArchives {
+		repositories.mavenDeployer {
+			repository(url: uri('../../.maven'))
+		}
+	}
 }
 
 buildscript {

java/core.legacy/build.gradle

@@ -1,11 +1,3 @@
-task wrapper(type: Wrapper) {
-	gradleVersion = '2.2'
-}
-
-repositories {
-	mavenCentral();
-}
-
 dependencies {
 	compile 'org.slf4j:slf4j-log4j12:1.7.7'	
 	compile 'org.picocontainer:picocontainer:2.15'

java/core.legacy/gradlew

@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,31 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`

java/core.legacy/gradlew.bat

@@ -1,90 +1,90 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

java/core.legacy/sources.txt

@@ -0,0 +1,79 @@
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\module-info.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\Control.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\Duplex.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\Forwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\Receiver.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\Sender.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\LoaderException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\WorkerException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\ActivateException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\AlreadyActiveException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\AlreadyRunningException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\DeactivateException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\NotActiveException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\NotRunningException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\exception\worker\StartException.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\loader\AbstractLoader.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\channel\TcpClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\channel\TcpServer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\channel\TcpServerClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\AbstractUdpClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpDuplexAutoClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpDuplexClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpDuplexHelper.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpDuplexServer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpMulticastClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpMulticastServer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpSender.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\datagram\UdpServer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\TcpChannelServerForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\TcpClientChannelForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\TcpClientSocketForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\TcpSocketServerForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\UdpDuplexClientForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\UdpDuplexServerForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\forwarder\UdpServerForwarder.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\receiver\AbstractReceiver.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\socket\AbstractTcpClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\socket\TcpClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\socket\TcpServer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\server\socket\TcpServerClient.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\util\ArrayCycle.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\util\Buffer.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\util\Bufferable.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\util\BufferedArrayCycle.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\util\Dummy.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\work\Listen.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\work\ReflectiveListen.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\work\Work.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\BackgroundListener.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\DirectIntervalWorker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\DirectWorker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\ForegroundListener.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\IntervalWork.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\ThreadIntervalWorker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\ThreadWorker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\Worker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\Listener.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\ListenerPool.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\ListenerPoolRunnable.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\PooledListener.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\PooledWorker.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\WorkerPool.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\WorkerPoolRunnable.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\main\java\base\worker\pool\Wrapper.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\AllTests.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\TestTcpChannelCommunication.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\TestTcpSocketCommunication.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\TestUdpDuplexCommunication.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\TestUdpMulticastCommunication.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\junit\TestUdpUnicastCommunication.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\test\Test.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\TestDirectWork.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\TestIntervalWork.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\TestListen.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\TestPooledListen.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\TestPooledWork.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\dummy\DummyIntervalWork.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\dummy\DummyListen.java
+C:\Users\Rik\Git\github\mimis\java\core.legacy\src\test\java\worker\dummy\DummyWork.java

java/core.legacy/src/main/java/base/Control.java

@@ -1,7 +1,7 @@
-package base;
-
-public interface Control {
-    public void start();
-    public void stop();
-    public void exit();
-}
+package base;
+
+public interface Control {
+    public void start();
+    public void stop();
+    public void exit();
+}

java/core.legacy/src/main/java/base/Duplex.java

@@ -1,3 +1,3 @@
-package base;
-
-public interface Duplex extends Forwarder, Sender {}
+package base;
+
+public interface Duplex extends Forwarder, Sender {}

java/core.legacy/src/main/java/base/Forwarder.java

@@ -1,6 +1,6 @@
-package base;
-
-public interface Forwarder extends Control {
-    public void register(Receiver receiver);
-    public void remove(Receiver receiver);
+package base;
+
+public interface Forwarder extends Control {
+    public void register(Receiver receiver);
+    public void remove(Receiver receiver);
 }

java/core.legacy/src/main/java/base/Receiver.java

@@ -1,5 +1,5 @@
-package base;
-
-public interface Receiver {
-    public void receive(byte[] buffer);
-}
+package base;
+
+public interface Receiver {
+    public void receive(byte[] buffer);
+}

java/core.legacy/src/main/java/base/Sender.java

@@ -1,7 +1,7 @@
-package base;
-
-import java.io.IOException;
-
-public interface Sender extends Control {
-    public void send(byte[] buffer) throws IOException;
-}
+package base;
+
+import java.io.IOException;
+
+public interface Sender extends Control {
+    public void send(byte[] buffer) throws IOException;
+}

java/core.legacy/src/main/java/base/exception/LoaderException.java

@@ -1,9 +1,9 @@
-package base.exception;
-
-public class LoaderException extends Exception {
-    protected static final long serialVersionUID = 1L;
-
-    public LoaderException(String message) {
-        super(message);
-    }
-}
+package base.exception;
+
+public class LoaderException extends Exception {
+    protected static final long serialVersionUID = 1L;
+
+    public LoaderException(String message) {
+        super(message);
+    }
+}

java/core.legacy/src/main/java/base/exception/WorkerException.java

@@ -1,5 +1,5 @@
-package base.exception;
-
-public class WorkerException extends Exception {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception;
+
+public class WorkerException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/ActivateException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class ActivateException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class ActivateException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/AlreadyActiveException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class AlreadyActiveException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class AlreadyActiveException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/AlreadyRunningException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class AlreadyRunningException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class AlreadyRunningException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/DeactivateException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class DeactivateException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class DeactivateException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
 }

java/core.legacy/src/main/java/base/exception/worker/NotActiveException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class NotActiveException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class NotActiveException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/NotRunningException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class NotRunningException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class NotRunningException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/exception/worker/StartException.java

@@ -1,7 +1,7 @@
-package base.exception.worker;
-
-import base.exception.WorkerException;
-
-public class StartException extends WorkerException {
-    protected static final long serialVersionUID = 1L;
-}
+package base.exception.worker;
+
+import base.exception.WorkerException;
+
+public class StartException extends WorkerException {
+    protected static final long serialVersionUID = 1L;
+}

java/core.legacy/src/main/java/base/loader/AbstractLoader.java

@@ -1,146 +1,146 @@
-package base.loader;
-
-import java.io.IOException;
-import java.util.Properties;
-
-import org.picocontainer.DefaultPicoContainer;
-import org.picocontainer.MutablePicoContainer;
-import org.picocontainer.Parameter;
-import org.picocontainer.parameters.ConstantParameter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import base.Duplex;
-import base.Forwarder;
-import base.Sender;
-import base.exception.LoaderException;
-import base.server.datagram.UdpSender;
-import base.server.forwarder.UdpDuplexClientForwarder;
-import base.server.forwarder.UdpDuplexServerForwarder;
-
-public class AbstractLoader<T> {
-    protected static final String PROPERTIES_FILE = "loader.properties";
-    protected static final Properties SERVER = null;
-
-    protected Logger logger = LoggerFactory.getLogger(AbstractLoader.class);
-    protected MutablePicoContainer pico;
-    
-    public AbstractLoader() {
-        /* Initialise container */
-        pico = new DefaultPicoContainer();
-    }
-
-    public AbstractLoader(Properties properties) {
-        this();
-    }
-
-    @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> T getLoader() throws LoaderException {
-        return (T) new AbstractLoader(readProperties(PROPERTIES_FILE));
-    }
-
-    public static Properties readProperties(String propertiesFile) throws LoaderException {
-        /* Read properties file */
-        Properties properties = new Properties();        
-        try {
-            properties.load(AbstractLoader.class.getClassLoader().getResourceAsStream(propertiesFile));
-        } catch (IOException e) {
-            throw new LoaderException("Faield to read properties file: " + PROPERTIES_FILE);
-        }        
-        return properties;
-    }
-
-    protected Class<?> getSenderClass(String protocol, String implementation) throws LoaderException {
-        switch (protocol) {
-            case "tcp":
-                switch (implementation) {
-                    case "channel":
-                        return base.server.channel.TcpClient.class; 
-                    default:
-                    case "socket":
-                        return base.server.socket.TcpClient.class; 
-                    }
-                case "udp":
-                    return UdpSender.class;
-        }
-        throw new LoaderException("Failed to determine <Sender>");
-    }
-
-    protected Class<?> getClientForwarderClass(String protocol, String implementation) throws LoaderException {
-        switch (protocol) {
-            case "tcp":
-                switch (implementation) {
-                    case "channel":
-                        return base.server.forwarder.TcpClientChannelForwarder.class;
-                    default:
-                    case "socket":
-                        return base.server.forwarder.TcpClientSocketForwarder.class;
-                }
-            case "udp":
-                return UdpDuplexClientForwarder.class;
-        }
-        throw new LoaderException("Failed to determine <Forwarder>");
-    }
-
-    protected Class<?> getServerForwarderClass(String protocol, String implementation) throws LoaderException {
-        switch (protocol) {
-            case "tcp":
-                switch (implementation) {
-                    case "channel":
-                        return base.server.forwarder.TcpChannelServerForwarder.class;
-                    default:
-                    case "socket":
-                        return base.server.forwarder.TcpSocketServerForwarder.class;
-                }
-            case "udp":
-                return UdpDuplexServerForwarder.class;
-        }
-        throw new LoaderException("Failed to determine <Forwarder>");
-    }
-
-    protected void addClientSender(String protocol, String implementation, String host, int port) throws LoaderException {
-        Class<?> senderClass = getSenderClass(protocol, implementation);
-        logger.debug("Adding " + senderClass);
-        pico.addComponent(Sender.class, senderClass, new Parameter[]{
-            new ConstantParameter(host),
-            new ConstantParameter(port)});
-    }
-
-    protected void addServerSender(String protocol, String implementation, int port) throws LoaderException {
-        Class<?> senderClass = getSenderClass(protocol, implementation);
-        logger.debug("Adding " + senderClass);
-        pico.addComponent(Sender.class, senderClass, new Parameter[]{
-            new ConstantParameter(port)});
-    }
-
-    protected void addClientForwarder(String protocol, String implementation, String host, int port) throws LoaderException {
-        Class<?> forwarderClass = getClientForwarderClass(protocol, implementation);
-        logger.debug("Adding " + forwarderClass);
-        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
-            new ConstantParameter(host),
-            new ConstantParameter(port)});
-    }
-
-    protected void addClientDuplex(String protocol, String implementation, String host, int port) throws LoaderException {
-        Class<?> duplexClass = getClientForwarderClass(protocol, implementation);
-        logger.debug("Adding " + duplexClass);
-        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
-            new ConstantParameter(host),
-            new ConstantParameter(port)});
-        
-    }
-
-    protected void addServerForwarder(String protocol, String implementation, int port) throws LoaderException {
-        Class<?> forwarderClass = getServerForwarderClass(protocol, implementation);
-        logger.debug("Adding " + forwarderClass);
-        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
-            new ConstantParameter(port)});        
-    }
-
-    protected void addServerDuplex(String protocol, String implementation, int port) throws LoaderException {
-        Class<?> duplexClass = getServerForwarderClass(protocol, implementation);
-        logger.debug("Adding " + duplexClass);
-        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
-            new ConstantParameter(port)});        
-    }
-}
+package base.loader;
+
+import java.io.IOException;
+import java.util.Properties;
+
+import org.picocontainer.DefaultPicoContainer;
+import org.picocontainer.MutablePicoContainer;
+import org.picocontainer.Parameter;
+import org.picocontainer.parameters.ConstantParameter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Duplex;
+import base.Forwarder;
+import base.Sender;
+import base.exception.LoaderException;
+import base.server.datagram.UdpSender;
+import base.server.forwarder.UdpDuplexClientForwarder;
+import base.server.forwarder.UdpDuplexServerForwarder;
+
+public class AbstractLoader<T> {
+    protected static final String PROPERTIES_FILE = "loader.properties";
+    protected static final Properties SERVER = null;
+
+    protected Logger logger = LoggerFactory.getLogger(AbstractLoader.class);
+    protected MutablePicoContainer pico;
+    
+    public AbstractLoader() {
+        /* Initialise container */
+        pico = new DefaultPicoContainer();
+    }
+
+    public AbstractLoader(Properties properties) {
+        this();
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> T getLoader() throws LoaderException {
+        return (T) new AbstractLoader(readProperties(PROPERTIES_FILE));
+    }
+
+    public static Properties readProperties(String propertiesFile) throws LoaderException {
+        /* Read properties file */
+        Properties properties = new Properties();        
+        try {
+            properties.load(AbstractLoader.class.getClassLoader().getResourceAsStream(propertiesFile));
+        } catch (IOException e) {
+            throw new LoaderException("Faield to read properties file: " + PROPERTIES_FILE);
+        }        
+        return properties;
+    }
+
+    protected Class<?> getSenderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.channel.TcpClient.class; 
+                    default:
+                    case "socket":
+                        return base.server.socket.TcpClient.class; 
+                    }
+                case "udp":
+                    return UdpSender.class;
+        }
+        throw new LoaderException("Failed to determine <Sender>");
+    }
+
+    protected Class<?> getClientForwarderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.forwarder.TcpClientChannelForwarder.class;
+                    default:
+                    case "socket":
+                        return base.server.forwarder.TcpClientSocketForwarder.class;
+                }
+            case "udp":
+                return UdpDuplexClientForwarder.class;
+        }
+        throw new LoaderException("Failed to determine <Forwarder>");
+    }
+
+    protected Class<?> getServerForwarderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.forwarder.TcpChannelServerForwarder.class;
+                    default:
+                    case "socket":
+                        return base.server.forwarder.TcpSocketServerForwarder.class;
+                }
+            case "udp":
+                return UdpDuplexServerForwarder.class;
+        }
+        throw new LoaderException("Failed to determine <Forwarder>");
+    }
+
+    protected void addClientSender(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> senderClass = getSenderClass(protocol, implementation);
+        logger.debug("Adding " + senderClass);
+        pico.addComponent(Sender.class, senderClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+    }
+
+    protected void addServerSender(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> senderClass = getSenderClass(protocol, implementation);
+        logger.debug("Adding " + senderClass);
+        pico.addComponent(Sender.class, senderClass, new Parameter[]{
+            new ConstantParameter(port)});
+    }
+
+    protected void addClientForwarder(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> forwarderClass = getClientForwarderClass(protocol, implementation);
+        logger.debug("Adding " + forwarderClass);
+        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+    }
+
+    protected void addClientDuplex(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> duplexClass = getClientForwarderClass(protocol, implementation);
+        logger.debug("Adding " + duplexClass);
+        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+        
+    }
+
+    protected void addServerForwarder(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> forwarderClass = getServerForwarderClass(protocol, implementation);
+        logger.debug("Adding " + forwarderClass);
+        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
+            new ConstantParameter(port)});        
+    }
+
+    protected void addServerDuplex(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> duplexClass = getServerForwarderClass(protocol, implementation);
+        logger.debug("Adding " + duplexClass);
+        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
+            new ConstantParameter(port)});        
+    }
+}

java/core.legacy/src/main/java/base/server/channel/TcpClient.java

@@ -1,137 +1,137 @@
-package base.server.channel;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.nio.ByteBuffer;
-import java.nio.channels.SelectionKey;
-import java.nio.channels.Selector;
-import java.nio.channels.SocketChannel;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Set;
-
-import base.Sender;
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.work.Listen;
-import base.work.Work;
-import base.worker.Worker;
-
-public class TcpClient extends Work implements Sender {
-    protected static final String HOST = "localhost";
-    protected static final int BUFFER_SIZE = 1024;
-
-    protected String host;
-    protected int port;
-    protected int bufferSize;
-    protected SocketChannel socketChannel;
-    protected Selector selector;
-    protected ArrayList<Listen<byte[]>> listenList = new ArrayList<Listen<byte[]>>();
-
-    public TcpClient(int port) {
-        this(HOST, port);
-    }
-
-    public TcpClient(String host, int port) {
-        this(host, port, BUFFER_SIZE);
-    }
-
-    public TcpClient(String host, int port, int bufferSize) {
-        this.host = host;
-        this.port = port;
-        this.bufferSize = bufferSize;
-    }
-
-    public void activate() throws ActivateException {
-        System.out.println("Client: Activate!");
-        try {
-            InetSocketAddress hostAddress = new InetSocketAddress(host, port);
-            socketChannel = SocketChannel.open(hostAddress);
-            socketChannel.configureBlocking(false);
-            while (!socketChannel.finishConnect()) {
-                sleep(Worker.SLEEP);
-            }
-            selector = Selector.open();
-            socketChannel.register(selector, SelectionKey.OP_READ);
-            synchronized (host) {
-                host.notifyAll();
-            }
-        } catch (Exception e) {
-            logger.error("", e);
-            throw new ActivateException();
-        }
-        super.activate();
-    }
-
-    public void deactivate() throws DeactivateException {
-        System.out.println("Client: Deactivate!");
-        try {
-            selector.close();
-            socketChannel.close();
-        } catch (IOException e) {
-            throw new DeactivateException();
-        }
-    }
-
-    public void stop() {
-        super.stop();
-        if (selector != null) {
-            selector.wakeup();
-        }
-    }
-
-    public final void work() {
-        try {
-            logger.debug("Client: Waiting for select... ");    
-            logger.debug("Client: Number of selected keys: " + selector.select());
-            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
-            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
-
-            while (selectionKeyIterator.hasNext()) {    
-                SelectionKey selectionKey = selectionKeyIterator.next();
-                if (selectionKey.isReadable()) {
-                    ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize);
-                    socketChannel.read(byteBuffer);
-                    byte[] buffer = byteBuffer.array();
-                    input(buffer);
-                } else if (selectionKey.isWritable()) {
-                    byte[] buffer;
-                    buffer = (byte[]) selectionKey.attachment();
-                    ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
-                    socketChannel.write(byteBuffer);
-                    //selectionKey.cancel();
-                    socketChannel.register(selector, SelectionKey.OP_READ);
-                }
-                selectionKeyIterator.remove();
-            }
-        } catch (Exception e) {
-            logger.error("", e);
-        }
-    }
-
-    protected void input(byte[] buffer) {}
-
-    public void send(byte[] buffer) throws IOException {
-        if (selector == null) {
-            try {
-                synchronized (host) {
-                    host.wait();
-                }
-            } catch (InterruptedException e) {}
-        }
-        selector.wakeup();
-        socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE, buffer);
-    }
-
-    public void close() throws IOException {
-        socketChannel.close();        
-    }
-
-    /*public void register(Listen<byte[]> listen) {
-        listenList.add(listen);
-    }
-
-    public void remove(Listen<byte[]> listen) {
-        listenList.remove(listen);
-    }*/
+package base.server.channel;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.SocketChannel;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Listen;
+import base.work.Work;
+import base.worker.Worker;
+
+public class TcpClient extends Work implements Sender {
+    protected static final String HOST = "localhost";
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected String host;
+    protected int port;
+    protected int bufferSize;
+    protected SocketChannel socketChannel;
+    protected Selector selector;
+    protected ArrayList<Listen<byte[]>> listenList = new ArrayList<Listen<byte[]>>();
+
+    public TcpClient(int port) {
+        this(HOST, port);
+    }
+
+    public TcpClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public TcpClient(String host, int port, int bufferSize) {
+        this.host = host;
+        this.port = port;
+        this.bufferSize = bufferSize;
+    }
+
+    public void activate() throws ActivateException {
+        System.out.println("Client: Activate!");
+        try {
+            InetSocketAddress hostAddress = new InetSocketAddress(host, port);
+            socketChannel = SocketChannel.open(hostAddress);
+            socketChannel.configureBlocking(false);
+            while (!socketChannel.finishConnect()) {
+                sleep(Worker.SLEEP);
+            }
+            selector = Selector.open();
+            socketChannel.register(selector, SelectionKey.OP_READ);
+            synchronized (host) {
+                host.notifyAll();
+            }
+        } catch (Exception e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        System.out.println("Client: Deactivate!");
+        try {
+            selector.close();
+            socketChannel.close();
+        } catch (IOException e) {
+            throw new DeactivateException();
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (selector != null) {
+            selector.wakeup();
+        }
+    }
+
+    public final void work() {
+        try {
+            logger.debug("Client: Waiting for select... ");    
+            logger.debug("Client: Number of selected keys: " + selector.select());
+            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
+            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
+
+            while (selectionKeyIterator.hasNext()) {    
+                SelectionKey selectionKey = selectionKeyIterator.next();
+                if (selectionKey.isReadable()) {
+                    ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize);
+                    socketChannel.read(byteBuffer);
+                    byte[] buffer = byteBuffer.array();
+                    input(buffer);
+                } else if (selectionKey.isWritable()) {
+                    byte[] buffer;
+                    buffer = (byte[]) selectionKey.attachment();
+                    ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
+                    socketChannel.write(byteBuffer);
+                    //selectionKey.cancel();
+                    socketChannel.register(selector, SelectionKey.OP_READ);
+                }
+                selectionKeyIterator.remove();
+            }
+        } catch (Exception e) {
+            logger.error("", e);
+        }
+    }
+
+    protected void input(byte[] buffer) {}
+
+    public void send(byte[] buffer) throws IOException {
+        if (selector == null) {
+            try {
+                synchronized (host) {
+                    host.wait();
+                }
+            } catch (InterruptedException e) {}
+        }
+        selector.wakeup();
+        socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE, buffer);
+    }
+
+    public void close() throws IOException {
+        socketChannel.close();        
+    }
+
+    /*public void register(Listen<byte[]> listen) {
+        listenList.add(listen);
+    }
+
+    public void remove(Listen<byte[]> listen) {
+        listenList.remove(listen);
+    }*/
 }

java/core.legacy/src/main/java/base/server/channel/TcpServer.java

@@ -1,158 +1,158 @@
-package base.server.channel;
-
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.net.BindException;
-import java.net.InetSocketAddress;
-import java.nio.ByteBuffer;
-import java.nio.channels.SelectionKey;
-import java.nio.channels.Selector;
-import java.nio.channels.ServerSocketChannel;
-import java.nio.channels.SocketChannel;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Set;
-
-import base.Sender;
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.server.channel.TcpServerClient;
-import base.work.Work;
-
-public class TcpServer extends Work implements Sender {
-    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
-    protected static final int BUFFER_SIZE = 1024;
-
-    protected int port;
-    protected int bufferSize;
-    protected Constructor<?> clientConstructor;
-    protected Selector selector;
-    protected ServerSocketChannel serverSocket;
-    protected ArrayList<TcpServerClient> clientList;
-
-    public TcpServer(int port) {
-        this(port, CLIENT_CLASS);
-    }
-
-    public TcpServer(int port, Class<?> clientClass) {
-        this(port, clientClass, BUFFER_SIZE);
-    }
-
-    public TcpServer(int port, Class<?> clientClass, int bufferSize) {
-        this.port = port;
-        this.bufferSize = bufferSize;
-        try {
-            // Allow dependency injection, constructor arguments
-            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, SocketChannel.class, Integer.class);
-        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
-            logger.error("Failed to initialise client constructor", e);
-        }
-        clientList = new ArrayList<TcpServerClient>();
-    }
-
-    public void activate() throws ActivateException {
-        System.out.println("Server: Activate!");    
-        try {
-            // Get selector
-            selector = Selector.open();
-
-            // Get server socket channel and register with selector
-            serverSocket = ServerSocketChannel.open();
-            InetSocketAddress hostAddress = new InetSocketAddress(port);
-            serverSocket.bind(hostAddress);
-            serverSocket.configureBlocking(false);
-            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
-            synchronized (clientConstructor) {
-                clientConstructor.notifyAll();
-            }
-            return;
-        } catch (BindException e) {
-            logger.error("Address already in use", e);
-        } catch (IOException e) {
-            logger.error("", e);
-        }
-        throw new ActivateException();
-    }
-
-    public void deactivate() throws DeactivateException {
-        System.out.println("Server: Deactivate!");
-        try {
-            selector.close();
-            serverSocket.close();
-        } catch (IOException e) {
-            throw new DeactivateException();
-        } finally {
-            for (TcpServerClient client : clientList) {
-                client.stop();
-            }
-        }
-    }
-
-    public void stop() {
-        super.stop();
-        if (selector != null) {
-            selector.wakeup();
-        }
-    }
-
-    public void work() {
-        try {
-            System.out.println("Server: Waiting for select... ");    
-            System.out.println("Server: Number of selected keys: " + selector.select());
-    
-            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
-            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
-    
-            while (selectionKeyIterator.hasNext()) {    
-                SelectionKey selectionKey = selectionKeyIterator.next();    
-                if (selectionKey.isAcceptable()) {    
-                    // Accept the new client connection
-                    SocketChannel socketChannel = serverSocket.accept();
-                    socketChannel.configureBlocking(false);
-
-                    // Add the new connection to the selector
-                    TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socketChannel, bufferSize);
-                    clientList.add(client);
-                    socketChannel.register(selector, SelectionKey.OP_READ, client);
-                    //initClient(client);
-                    System.out.println("Accepted new connection from client: " + socketChannel);
-                } else if (selectionKey.isReadable()) {    
-                    // Read the data from client
-                    TcpServerClient serverClient = (TcpServerClient) selectionKey.attachment();
-                    serverClient.readable();    
-                } else if (selectionKey.isWritable()) {
-                    // Write to client?
-                }
-                selectionKeyIterator.remove();
-            }
-        }/* catch (IOException e) {} catch (InstantiationException e) {
-            logger.error("", e);
-        } catch (IllegalAccessException e) {
-            logger.error("", e);
-        } catch (IllegalArgumentException e) {
-            logger.error("", e);
-        } catch (InvocationTargetException e) {
-            logger.error("", e);
-        } */catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    protected void initClient(TcpServerClient client) {
-        try {
-            client.write(ByteBuffer.wrap(new String("Hi there!").getBytes()));
-        } catch (IOException e) {
-            logger.error("", e);
-        }
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        logger.debug("Number of clients = " + clientList.size());
-        for (TcpServerClient client : clientList) {
-            // Should be dealt with in clients own thread
-            client.send(buffer);
-        }        
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {}
+package base.server.channel;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.net.BindException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.server.channel.TcpServerClient;
+import base.work.Work;
+
+public class TcpServer extends Work implements Sender {
+    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected int port;
+    protected int bufferSize;
+    protected Constructor<?> clientConstructor;
+    protected Selector selector;
+    protected ServerSocketChannel serverSocket;
+    protected ArrayList<TcpServerClient> clientList;
+
+    public TcpServer(int port) {
+        this(port, CLIENT_CLASS);
+    }
+
+    public TcpServer(int port, Class<?> clientClass) {
+        this(port, clientClass, BUFFER_SIZE);
+    }
+
+    public TcpServer(int port, Class<?> clientClass, int bufferSize) {
+        this.port = port;
+        this.bufferSize = bufferSize;
+        try {
+            // Allow dependency injection, constructor arguments
+            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, SocketChannel.class, Integer.class);
+        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
+            logger.error("Failed to initialise client constructor", e);
+        }
+        clientList = new ArrayList<TcpServerClient>();
+    }
+
+    public void activate() throws ActivateException {
+        System.out.println("Server: Activate!");    
+        try {
+            // Get selector
+            selector = Selector.open();
+
+            // Get server socket channel and register with selector
+            serverSocket = ServerSocketChannel.open();
+            InetSocketAddress hostAddress = new InetSocketAddress(port);
+            serverSocket.bind(hostAddress);
+            serverSocket.configureBlocking(false);
+            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
+            synchronized (clientConstructor) {
+                clientConstructor.notifyAll();
+            }
+            return;
+        } catch (BindException e) {
+            logger.error("Address already in use", e);
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+        throw new ActivateException();
+    }
+
+    public void deactivate() throws DeactivateException {
+        System.out.println("Server: Deactivate!");
+        try {
+            selector.close();
+            serverSocket.close();
+        } catch (IOException e) {
+            throw new DeactivateException();
+        } finally {
+            for (TcpServerClient client : clientList) {
+                client.stop();
+            }
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (selector != null) {
+            selector.wakeup();
+        }
+    }
+
+    public void work() {
+        try {
+            System.out.println("Server: Waiting for select... ");    
+            System.out.println("Server: Number of selected keys: " + selector.select());
+    
+            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
+            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
+    
+            while (selectionKeyIterator.hasNext()) {    
+                SelectionKey selectionKey = selectionKeyIterator.next();    
+                if (selectionKey.isAcceptable()) {    
+                    // Accept the new client connection
+                    SocketChannel socketChannel = serverSocket.accept();
+                    socketChannel.configureBlocking(false);
+
+                    // Add the new connection to the selector
+                    TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socketChannel, bufferSize);
+                    clientList.add(client);
+                    socketChannel.register(selector, SelectionKey.OP_READ, client);
+                    //initClient(client);
+                    System.out.println("Accepted new connection from client: " + socketChannel);
+                } else if (selectionKey.isReadable()) {    
+                    // Read the data from client
+                    TcpServerClient serverClient = (TcpServerClient) selectionKey.attachment();
+                    serverClient.readable();    
+                } else if (selectionKey.isWritable()) {
+                    // Write to client?
+                }
+                selectionKeyIterator.remove();
+            }
+        }/* catch (IOException e) {} catch (InstantiationException e) {
+            logger.error("", e);
+        } catch (IllegalAccessException e) {
+            logger.error("", e);
+        } catch (IllegalArgumentException e) {
+            logger.error("", e);
+        } catch (InvocationTargetException e) {
+            logger.error("", e);
+        } */catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected void initClient(TcpServerClient client) {
+        try {
+            client.write(ByteBuffer.wrap(new String("Hi there!").getBytes()));
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        logger.debug("Number of clients = " + clientList.size());
+        for (TcpServerClient client : clientList) {
+            // Should be dealt with in clients own thread
+            client.send(buffer);
+        }        
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {}
 }

java/core.legacy/src/main/java/base/server/channel/TcpServerClient.java

@@ -1,54 +1,54 @@
-package base.server.channel;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.channels.SocketChannel;
-
-import base.Sender;
-import base.work.Listen;
-
-public class TcpServerClient extends Listen<byte[]> implements Sender {
-    protected static final int BUFFER_SIZE = 1024;
-
-    protected TcpServer server;
-    protected SocketChannel socketChannel;
-    protected int bufferSize;
-    protected ByteBuffer byteBuffer;
-
-    public TcpServerClient(TcpServer server, SocketChannel socketChannel) {
-        this(server, socketChannel, BUFFER_SIZE);
-    }
-
-    public TcpServerClient(TcpServer server, SocketChannel socketChannel, Integer bufferSize) {
-        super();
-        this.server = server;
-        this.socketChannel = socketChannel;
-        this.bufferSize = bufferSize;
-        byteBuffer = ByteBuffer.allocate(bufferSize);
-    }
-
-    public void write(ByteBuffer byteBuffer) throws IOException {
-         socketChannel.write(byteBuffer);
-    }
-
-    public void readable() throws IOException {
-        int read;        
-        while (( read = socketChannel.read(byteBuffer)) > 0) {
-            byteBuffer.flip();
-            byte[] buffer = byteBuffer.array();
-            input(buffer);
-            byteBuffer.clear();
-        }
-        if (read < 0) {
-            socketChannel.close();
-        }
-    }
-
-    public void input(byte[] buffer) {
-        server.input(this, buffer);        
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        write(ByteBuffer.wrap(buffer));        
-    }
-}
+package base.server.channel;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+
+import base.Sender;
+import base.work.Listen;
+
+public class TcpServerClient extends Listen<byte[]> implements Sender {
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected TcpServer server;
+    protected SocketChannel socketChannel;
+    protected int bufferSize;
+    protected ByteBuffer byteBuffer;
+
+    public TcpServerClient(TcpServer server, SocketChannel socketChannel) {
+        this(server, socketChannel, BUFFER_SIZE);
+    }
+
+    public TcpServerClient(TcpServer server, SocketChannel socketChannel, Integer bufferSize) {
+        super();
+        this.server = server;
+        this.socketChannel = socketChannel;
+        this.bufferSize = bufferSize;
+        byteBuffer = ByteBuffer.allocate(bufferSize);
+    }
+
+    public void write(ByteBuffer byteBuffer) throws IOException {
+         socketChannel.write(byteBuffer);
+    }
+
+    public void readable() throws IOException {
+        int read;        
+        while (( read = socketChannel.read(byteBuffer)) > 0) {
+            byteBuffer.flip();
+            byte[] buffer = byteBuffer.array();
+            input(buffer);
+            byteBuffer.clear();
+        }
+        if (read < 0) {
+            socketChannel.close();
+        }
+    }
+
+    public void input(byte[] buffer) {
+        server.input(this, buffer);        
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        write(ByteBuffer.wrap(buffer));        
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/AbstractUdpClient.java

@@ -1,46 +1,46 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.MulticastSocket;
-
-import base.work.Work;
-
-public abstract class AbstractUdpClient extends Work {
-    protected static final int BUFFER_SIZE = 2048;
-
-    protected int bufferSize;
-    protected MulticastSocket socket;
-    protected DatagramPacket datagramPacket;
-
-    public AbstractUdpClient() {}
-
-    public AbstractUdpClient(MulticastSocket socket) {
-        this(socket, BUFFER_SIZE);
-    }
-
-    public AbstractUdpClient(MulticastSocket socket, int bufferSize) {
-        this.socket = socket;
-        this.bufferSize = bufferSize;
-        byte[] buffer = new byte[bufferSize];
-        datagramPacket = new DatagramPacket(buffer, buffer.length);
-    }
-
-    public void work() {        
-        try {
-            byte[] buffer = new byte[bufferSize];
-            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
-            socket.receive(packet);
-            System.out.println("iets ontvangen!!!!!");
-            buffer = packet.getData();
-            input(buffer);
-        } catch (IOException e) {}
-    }
-
-    public void stop() {
-        socket.close();
-        super.stop();
-    }
-
-    protected abstract void input(byte[] buffer);
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.MulticastSocket;
+
+import base.work.Work;
+
+public abstract class AbstractUdpClient extends Work {
+    protected static final int BUFFER_SIZE = 2048;
+
+    protected int bufferSize;
+    protected MulticastSocket socket;
+    protected DatagramPacket datagramPacket;
+
+    public AbstractUdpClient() {}
+
+    public AbstractUdpClient(MulticastSocket socket) {
+        this(socket, BUFFER_SIZE);
+    }
+
+    public AbstractUdpClient(MulticastSocket socket, int bufferSize) {
+        this.socket = socket;
+        this.bufferSize = bufferSize;
+        byte[] buffer = new byte[bufferSize];
+        datagramPacket = new DatagramPacket(buffer, buffer.length);
+    }
+
+    public void work() {        
+        try {
+            byte[] buffer = new byte[bufferSize];
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+            socket.receive(packet);
+            System.out.println("iets ontvangen!!!!!");
+            buffer = packet.getData();
+            input(buffer);
+        } catch (IOException e) {}
+    }
+
+    public void stop() {
+        socket.close();
+        super.stop();
+    }
+
+    protected abstract void input(byte[] buffer);
+}

java/core.legacy/src/main/java/base/server/datagram/UdpDuplexAutoClient.java

@@ -1,17 +1,17 @@
-package base.server.datagram;
-
-import java.net.UnknownHostException;
-
-public class UdpDuplexAutoClient extends UdpDuplexClient {
-    public UdpDuplexAutoClient(int bindPort, int sendPort) throws UnknownHostException {
-        super(HOST, bindPort, null, sendPort);
-    }
-
-    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort) throws UnknownHostException {
-        super(bindHost, bindPort, null, sendPort);
-    }
-
-    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort, int bufferSize) throws UnknownHostException {
-        super(bindHost, bindPort, null, sendPort, bufferSize);
-    }
-}
+package base.server.datagram;
+
+import java.net.UnknownHostException;
+
+public class UdpDuplexAutoClient extends UdpDuplexClient {
+    public UdpDuplexAutoClient(int bindPort, int sendPort) throws UnknownHostException {
+        super(HOST, bindPort, null, sendPort);
+    }
+
+    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort) throws UnknownHostException {
+        super(bindHost, bindPort, null, sendPort);
+    }
+
+    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort, int bufferSize) throws UnknownHostException {
+        super(bindHost, bindPort, null, sendPort, bufferSize);
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/UdpDuplexClient.java

@@ -1,51 +1,51 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.UnknownHostException;
-
-import base.Sender;
-
-public class UdpDuplexClient extends UdpMulticastClient implements Sender {
-    protected int sendPort;
-    protected Sender sender;
-
-    public UdpDuplexClient(int bindPort, String sendHost, int sendPort) throws UnknownHostException {
-        this(HOST, bindPort, sendHost, sendPort);
-    }
-
-    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
-        this(bindHost, bindPort, sendHost, sendPort, BUFFER_SIZE);
-    }
-
-    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort, int bufferSize) throws UnknownHostException {
-        super(bindHost, bindPort, bufferSize);
-        this.sendPort = sendPort;
-        if (sendHost != null) {
-            sender = new UdpSender(sendHost, sendPort);
-        }
-    }
-
-    public void work() {        
-        try {
-            byte[] buffer = new byte[bufferSize];
-            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
-            socket.receive(packet);
-            buffer = packet.getData();
-            System.out.println("Receive from " + packet.getAddress().getHostAddress());
-            if (sender == null) {
-                String sendHost = packet.getAddress().getHostAddress();
-                sender = new UdpSender(sendHost, sendPort);
-            }
-            input(buffer);
-        } catch (IOException e) {}
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        if (sender != null) {
-            sender.send(buffer);
-        }
-    }
-
-    public void input(byte[] buffer) {}
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.UnknownHostException;
+
+import base.Sender;
+
+public class UdpDuplexClient extends UdpMulticastClient implements Sender {
+    protected int sendPort;
+    protected Sender sender;
+
+    public UdpDuplexClient(int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        this(HOST, bindPort, sendHost, sendPort);
+    }
+
+    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        this(bindHost, bindPort, sendHost, sendPort, BUFFER_SIZE);
+    }
+
+    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort, int bufferSize) throws UnknownHostException {
+        super(bindHost, bindPort, bufferSize);
+        this.sendPort = sendPort;
+        if (sendHost != null) {
+            sender = new UdpSender(sendHost, sendPort);
+        }
+    }
+
+    public void work() {        
+        try {
+            byte[] buffer = new byte[bufferSize];
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+            socket.receive(packet);
+            buffer = packet.getData();
+            System.out.println("Receive from " + packet.getAddress().getHostAddress());
+            if (sender == null) {
+                String sendHost = packet.getAddress().getHostAddress();
+                sender = new UdpSender(sendHost, sendPort);
+            }
+            input(buffer);
+        } catch (IOException e) {}
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        if (sender != null) {
+            sender.send(buffer);
+        }
+    }
+
+    public void input(byte[] buffer) {}
+}

java/core.legacy/src/main/java/base/server/datagram/UdpDuplexHelper.java

@@ -1,19 +1,19 @@
-package base.server.datagram;
-
-import java.net.MulticastSocket;
-
-import base.work.Listen;
-
-public class UdpDuplexHelper extends AbstractUdpClient {
-    protected Listen<byte[]> listen;
-
-    public UdpDuplexHelper(Listen<byte[]> listen, MulticastSocket socket) {
-        super(socket);
-        this.listen = listen;
-    }
-
-    public void input(byte[] buffer) {
-        System.out.println("jajajaja");
-        listen.add(buffer);
-    }
-}
+package base.server.datagram;
+
+import java.net.MulticastSocket;
+
+import base.work.Listen;
+
+public class UdpDuplexHelper extends AbstractUdpClient {
+    protected Listen<byte[]> listen;
+
+    public UdpDuplexHelper(Listen<byte[]> listen, MulticastSocket socket) {
+        super(socket);
+        this.listen = listen;
+    }
+
+    public void input(byte[] buffer) {
+        System.out.println("jajajaja");
+        listen.add(buffer);
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/UdpDuplexServer.java

@@ -1,59 +1,59 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.InetAddress;
-import java.net.MulticastSocket;
-
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-
-public class UdpDuplexServer extends UdpMulticastServer {
-    protected int bindPort;
-    protected UdpDuplexHelper helper;
-
-    public UdpDuplexServer(int sendPort, int bindPort) {
-        super(sendPort);
-        this.bindPort = bindPort;
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            socket = new MulticastSocket(bindPort);
-            synchronized (this) {
-                notifyAll();
-            }
-            helper = new UdpDuplexHelper(this, socket);
-            helper.start();
-        } catch (IOException e) {
-            throw new ActivateException();
-        }
-        super.activate();
-    }
-
-    public void deactivate() throws DeactivateException {
-        helper.stop();
-        super.deactivate();
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        if (socket == null) {
-            synchronized (this) {
-                try {
-                    wait();
-                } catch (InterruptedException e) {
-                    return;
-                }
-            }
-        }
-        try {
-            InetAddress group = InetAddress.getByName(host);
-            System.out.println("Send to " + host + " " + port);
-            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
-            socket.send(packet);
-        }
-        catch (IOException e) {
-            logger.error("", e);
-        }
-    }
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+
+public class UdpDuplexServer extends UdpMulticastServer {
+    protected int bindPort;
+    protected UdpDuplexHelper helper;
+
+    public UdpDuplexServer(int sendPort, int bindPort) {
+        super(sendPort);
+        this.bindPort = bindPort;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket(bindPort);
+            synchronized (this) {
+                notifyAll();
+            }
+            helper = new UdpDuplexHelper(this, socket);
+            helper.start();
+        } catch (IOException e) {
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        helper.stop();
+        super.deactivate();
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        if (socket == null) {
+            synchronized (this) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                    return;
+                }
+            }
+        }
+        try {
+            InetAddress group = InetAddress.getByName(host);
+            System.out.println("Send to " + host + " " + port);
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
+            socket.send(packet);
+        }
+        catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/UdpMulticastClient.java

@@ -1,42 +1,42 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.MulticastSocket;
-
-import base.exception.worker.ActivateException;
-
-public class UdpMulticastClient extends AbstractUdpClient {
-    protected static final String HOST = "239.255.255.255";
-
-    protected String host;
-    protected int port;
-
-    public UdpMulticastClient(int port) {
-        this(HOST, port);
-    }
-
-    public UdpMulticastClient(String host, int port) {
-        this(host, port, BUFFER_SIZE);
-    }
-
-    public UdpMulticastClient(String host, int port, int bufferSize) {
-        this.host = host;
-        this.port = port;
-        this.bufferSize = BUFFER_SIZE;
-        System.out.println("Client bind: " + host + " " + port);
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            socket = new MulticastSocket(port);
-            InetAddress group = InetAddress.getByName(host);
-            socket.joinGroup(group);
-        } catch (IOException e) {
-            logger.error("", e);
-            throw new ActivateException();
-        }
-    }
-
-    protected void input(byte[] buffer) {}
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.exception.worker.ActivateException;
+
+public class UdpMulticastClient extends AbstractUdpClient {
+    protected static final String HOST = "239.255.255.255";
+
+    protected String host;
+    protected int port;
+
+    public UdpMulticastClient(int port) {
+        this(HOST, port);
+    }
+
+    public UdpMulticastClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public UdpMulticastClient(String host, int port, int bufferSize) {
+        this.host = host;
+        this.port = port;
+        this.bufferSize = BUFFER_SIZE;
+        System.out.println("Client bind: " + host + " " + port);
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket(port);
+            InetAddress group = InetAddress.getByName(host);
+            socket.joinGroup(group);
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    protected void input(byte[] buffer) {}
+}

java/core.legacy/src/main/java/base/server/datagram/UdpMulticastServer.java

@@ -1,61 +1,61 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.InetAddress;
-import java.net.MulticastSocket;
-
-import base.Sender;
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.work.Listen;
-import base.worker.Worker;
-
-public class UdpMulticastServer extends Listen<byte[]> implements Sender {
-    protected static final String HOST = "239.255.255.255";
-    protected static final int BUFFER_SIZE = 2048;
-
-    protected String host;
-    protected int port;
-    protected MulticastSocket socket;
-
-    public UdpMulticastServer(int port) {
-        this(HOST, port);
-    }
-
-    public UdpMulticastServer(String host, int port) {
-        super(Worker.Type.BACKGROUND);
-        this.host = host;
-        this.port = port;
-        System.out.println("Server send: " + host + " " + port);
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            socket = new MulticastSocket();
-        } catch (IOException e) {
-            throw new ActivateException();
-        }
-        super.activate();
-    }
-
-    public void deactivate() throws DeactivateException {
-        socket.close();
-        super.deactivate();
-    }
-
-    public void input(byte[] buffer) {
-        try {
-            InetAddress group = InetAddress.getByName(host);
-            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
-            socket.send(packet);
-        }
-        catch (IOException e) {
-            logger.error("", e);
-        }    
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        add(buffer);
-    }
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Listen;
+import base.worker.Worker;
+
+public class UdpMulticastServer extends Listen<byte[]> implements Sender {
+    protected static final String HOST = "239.255.255.255";
+    protected static final int BUFFER_SIZE = 2048;
+
+    protected String host;
+    protected int port;
+    protected MulticastSocket socket;
+
+    public UdpMulticastServer(int port) {
+        this(HOST, port);
+    }
+
+    public UdpMulticastServer(String host, int port) {
+        super(Worker.Type.BACKGROUND);
+        this.host = host;
+        this.port = port;
+        System.out.println("Server send: " + host + " " + port);
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket();
+        } catch (IOException e) {
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        socket.close();
+        super.deactivate();
+    }
+
+    public void input(byte[] buffer) {
+        try {
+            InetAddress group = InetAddress.getByName(host);
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
+            socket.send(packet);
+        }
+        catch (IOException e) {
+            logger.error("", e);
+        }    
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        add(buffer);
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/UdpSender.java

@@ -1,56 +1,56 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.DatagramSocket;
-import java.net.InetAddress;
-import java.net.SocketException;
-import java.net.UnknownHostException;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import base.Sender;
-
-public class UdpSender implements Sender {
-    protected static final String HOST = "localhost";
-    protected Logger logger = LoggerFactory.getLogger(getClass());
-
-    protected DatagramSocket datagramSocket;
-    protected InetAddress inetAddress;
-    protected int port;
-
-    public UdpSender(int port) throws UnknownHostException {
-        this(HOST, port);
-    }
-
-    public UdpSender(String host, int port) throws UnknownHostException {
-        System.out.println("Sender use: " + host + " " + port);
-        inetAddress = InetAddress.getByName(host);
-        this.port = port;
-        try {
-            datagramSocket = new DatagramSocket();
-        } catch (SocketException e) {
-            logger.error("Failed to create socket", e);
-        }        
-    }
-
-    public void start() {}
-
-    public void stop() {
-        datagramSocket.close();
-    }
-
-    public void exit() {
-        stop();
-    }
-
-    public void send(byte[] buffer) {
-        try {
-            DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length, inetAddress, port);
-            datagramSocket.send(datagramPacket);
-        } catch (IOException e) {
-            logger.error("Failed to send buffer", e);
-        }        
-    }
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Sender;
+
+public class UdpSender implements Sender {
+    protected static final String HOST = "localhost";
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+
+    protected DatagramSocket datagramSocket;
+    protected InetAddress inetAddress;
+    protected int port;
+
+    public UdpSender(int port) throws UnknownHostException {
+        this(HOST, port);
+    }
+
+    public UdpSender(String host, int port) throws UnknownHostException {
+        System.out.println("Sender use: " + host + " " + port);
+        inetAddress = InetAddress.getByName(host);
+        this.port = port;
+        try {
+            datagramSocket = new DatagramSocket();
+        } catch (SocketException e) {
+            logger.error("Failed to create socket", e);
+        }        
+    }
+
+    public void start() {}
+
+    public void stop() {
+        datagramSocket.close();
+    }
+
+    public void exit() {
+        stop();
+    }
+
+    public void send(byte[] buffer) {
+        try {
+            DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length, inetAddress, port);
+            datagramSocket.send(datagramPacket);
+        } catch (IOException e) {
+            logger.error("Failed to send buffer", e);
+        }        
+    }
+}

java/core.legacy/src/main/java/base/server/datagram/UdpServer.java

@@ -1,64 +1,64 @@
-package base.server.datagram;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.DatagramSocket;
-import java.net.SocketException;
-
-import base.exception.worker.ActivateException;
-import base.work.Work;
-
-public class UdpServer extends Work {
-    protected static final int BUFFER_SIZE = 1024;
-    protected static final int TIMEOUT = 1000;
-
-    protected int port;
-    protected int bufferSize;
-    protected DatagramSocket diagramSocket;
-
-    public UdpServer(int port) {
-        this(port, BUFFER_SIZE);
-    }
-
-    public UdpServer(int port, int bufferSize) {
-        super();
-        this.port = port;
-        this.bufferSize = bufferSize;
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            logger.debug("Starting datagram socket on port " + port);
-            diagramSocket = new DatagramSocket(port);
-            diagramSocket.setSoTimeout(TIMEOUT);
-            super.activate();
-        } catch (SocketException e) {
-            logger.error("Failed to initialize socket", e);
-            throw new ActivateException();
-        }
-    }
-
-    public void stop() {
-        super.stop();
-        if (diagramSocket != null) {
-            diagramSocket.close();
-        }
-    }
-
-    public void work() {
-        byte[] buffer = new byte[bufferSize];        
-        DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
-        try {
-            diagramSocket.receive(datagramPacket);
-        } catch (SocketException e) {
-            stop();
-        } catch (IOException e) {
-            logger.error("Failed to receive packet", e);
-            stop();
-            return;
-        }
-        input(buffer);
-    }
-
-    protected void input(byte[] buffer) {}
-}
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.SocketException;
+
+import base.exception.worker.ActivateException;
+import base.work.Work;
+
+public class UdpServer extends Work {
+    protected static final int BUFFER_SIZE = 1024;
+    protected static final int TIMEOUT = 1000;
+
+    protected int port;
+    protected int bufferSize;
+    protected DatagramSocket diagramSocket;
+
+    public UdpServer(int port) {
+        this(port, BUFFER_SIZE);
+    }
+
+    public UdpServer(int port, int bufferSize) {
+        super();
+        this.port = port;
+        this.bufferSize = bufferSize;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            logger.debug("Starting datagram socket on port " + port);
+            diagramSocket = new DatagramSocket(port);
+            diagramSocket.setSoTimeout(TIMEOUT);
+            super.activate();
+        } catch (SocketException e) {
+            logger.error("Failed to initialize socket", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (diagramSocket != null) {
+            diagramSocket.close();
+        }
+    }
+
+    public void work() {
+        byte[] buffer = new byte[bufferSize];        
+        DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
+        try {
+            diagramSocket.receive(datagramPacket);
+        } catch (SocketException e) {
+            stop();
+        } catch (IOException e) {
+            logger.error("Failed to receive packet", e);
+            stop();
+            return;
+        }
+        input(buffer);
+    }
+
+    protected void input(byte[] buffer) {}
+}

java/core.legacy/src/main/java/base/server/forwarder/TcpChannelServerForwarder.java

@@ -1,31 +1,31 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.channel.TcpServer;
-import base.server.channel.TcpServerClient;
-
-public class TcpChannelServerForwarder extends TcpServer implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public TcpChannelServerForwarder(int port) {
-         super(port);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.channel.TcpServer;
+import base.server.channel.TcpServerClient;
+
+public class TcpChannelServerForwarder extends TcpServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpChannelServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/TcpClientChannelForwarder.java

@@ -1,31 +1,31 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.socket.TcpClient;
-import base.server.socket.TcpServerClient;
-
-public class TcpClientChannelForwarder extends TcpClient implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public TcpClientChannelForwarder(String host, int port) {
-         super(host, port);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.socket.TcpClient;
+import base.server.socket.TcpServerClient;
+
+public class TcpClientChannelForwarder extends TcpClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpClientChannelForwarder(String host, int port) {
+         super(host, port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/TcpClientSocketForwarder.java

@@ -1,31 +1,31 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.channel.TcpClient;
-import base.server.channel.TcpServerClient;
-
-public class TcpClientSocketForwarder extends TcpClient implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public TcpClientSocketForwarder(String host, int port) {
-         super(host, port);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.channel.TcpClient;
+import base.server.channel.TcpServerClient;
+
+public class TcpClientSocketForwarder extends TcpClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpClientSocketForwarder(String host, int port) {
+         super(host, port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/TcpSocketServerForwarder.java

@@ -1,31 +1,31 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.socket.TcpServer;
-import base.server.socket.TcpServerClient;
-
-public class TcpSocketServerForwarder extends TcpServer implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public TcpSocketServerForwarder(int port) {
-         super(port);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.socket.TcpServer;
+import base.server.socket.TcpServerClient;
+
+public class TcpSocketServerForwarder extends TcpServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpSocketServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/UdpDuplexClientForwarder.java

@@ -1,31 +1,31 @@
-package base.server.forwarder;
-
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.datagram.UdpDuplexClient;
-
-public class UdpDuplexClientForwarder extends UdpDuplexClient implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public UdpDuplexClientForwarder(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
-        super(bindHost, bindPort, sendHost, sendPort);
-        receiverList = new ArrayList<Receiver>();
-    }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.datagram.UdpDuplexClient;
+
+public class UdpDuplexClientForwarder extends UdpDuplexClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpDuplexClientForwarder(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        super(bindHost, bindPort, sendHost, sendPort);
+        receiverList = new ArrayList<Receiver>();
+    }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/UdpDuplexServerForwarder.java

@@ -1,30 +1,30 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Duplex;
-import base.Receiver;
-import base.server.datagram.UdpDuplexServer;
-
-public class UdpDuplexServerForwarder extends UdpDuplexServer implements Duplex {
-    protected ArrayList<Receiver> receiverList;
-
-    public UdpDuplexServerForwarder(int port, int listenPort) {
-         super(port, listenPort);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.datagram.UdpDuplexServer;
+
+public class UdpDuplexServerForwarder extends UdpDuplexServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpDuplexServerForwarder(int port, int listenPort) {
+         super(port, listenPort);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/forwarder/UdpServerForwarder.java

@@ -1,30 +1,30 @@
-package base.server.forwarder;
-
-import java.util.ArrayList;
-
-import base.Forwarder;
-import base.Receiver;
-import base.server.datagram.UdpServer;
-
-public class UdpServerForwarder extends UdpServer implements Forwarder {
-    protected ArrayList<Receiver> receiverList;
-
-    public UdpServerForwarder(int port) {
-         super(port);
-         receiverList = new ArrayList<Receiver>();
-     }
-
-    public void register(Receiver receiver) {
-        receiverList.add(receiver);
-    }
-
-    public void remove(Receiver receiver) {
-        receiverList.remove(receiver);
-    }
-
-    public void input(byte[] buffer) {
-        for (Receiver receiver: receiverList) {
-            receiver.receive(buffer);
-        }
-    }
-}
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Forwarder;
+import base.Receiver;
+import base.server.datagram.UdpServer;
+
+public class UdpServerForwarder extends UdpServer implements Forwarder {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}

java/core.legacy/src/main/java/base/server/receiver/AbstractReceiver.java

@@ -1,33 +1,33 @@
-package base.server.receiver;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import base.Control;
-import base.Forwarder;
-import base.Receiver;
-
-public abstract class AbstractReceiver implements Receiver, Control {
-    protected Logger logger = LoggerFactory.getLogger(getClass());
-
-    protected Forwarder forwarder;
-
-    public AbstractReceiver(Forwarder forwarder) {
-        this.forwarder = forwarder;
-        forwarder.register(this);
-    }
-
-    public void start() {
-        forwarder.start();        
-    }
-
-    public void stop() {
-        forwarder.stop();        
-    }
-
-    public void exit() {
-        forwarder.exit();        
-    }
-
-    abstract public void receive(byte[] buffer);
-}
+package base.server.receiver;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Control;
+import base.Forwarder;
+import base.Receiver;
+
+public abstract class AbstractReceiver implements Receiver, Control {
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+
+    protected Forwarder forwarder;
+
+    public AbstractReceiver(Forwarder forwarder) {
+        this.forwarder = forwarder;
+        forwarder.register(this);
+    }
+
+    public void start() {
+        forwarder.start();        
+    }
+
+    public void stop() {
+        forwarder.stop();        
+    }
+
+    public void exit() {
+        forwarder.exit();        
+    }
+
+    abstract public void receive(byte[] buffer);
+}

java/core.legacy/src/main/java/base/server/socket/AbstractTcpClient.java

@@ -1,72 +1,72 @@
-package base.server.socket;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.Socket;
-
-import base.Sender;
-import base.exception.worker.DeactivateException;
-import base.work.Work;
-
-public abstract class AbstractTcpClient extends Work implements Sender {
-    protected static final int BUFFER_SIZE = 1024;
-
-    protected Object object = new Object();
-    protected int bufferSize;
-    protected Socket socket;
-    protected InputStream inputStream;
-    protected OutputStream outputStream;
-
-    public AbstractTcpClient(Integer bufferSize) {
-        this.bufferSize = bufferSize;
-    }
-
-    public boolean active() {
-        return super.active() && socket.isConnected();
-    }
-
-    public void deactivate() throws DeactivateException {
-        super.deactivate();
-        try {
-            inputStream.close();
-            outputStream.close();
-            socket.close();
-        } catch (IOException e) {
-            logger.error("", e);
-        }
-    }
-
-    public void exit() {
-        super.exit();
-        try {
-            socket.close();
-        } catch (IOException e) {
-            logger.error("", e);
-        }
-    }
-
-    public void work() {
-        byte[] buffer = new byte[bufferSize];
-        try {
-            while (inputStream.read(buffer) > 0) {
-                input(buffer);
-            }
-        } catch (IOException e) {
-            stop();
-        }
-    }
-
-    protected abstract void input(byte[] buffer);
-
-    public void send(byte[] buffer) throws IOException {
-        if (outputStream == null) {
-            try {
-                synchronized (object) {
-                    object.wait();
-                }
-            } catch (InterruptedException e) {}
-        }
-        outputStream.write(buffer);
-    }
-}
+package base.server.socket;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import base.Sender;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public abstract class AbstractTcpClient extends Work implements Sender {
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected Object object = new Object();
+    protected int bufferSize;
+    protected Socket socket;
+    protected InputStream inputStream;
+    protected OutputStream outputStream;
+
+    public AbstractTcpClient(Integer bufferSize) {
+        this.bufferSize = bufferSize;
+    }
+
+    public boolean active() {
+        return super.active() && socket.isConnected();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        try {
+            inputStream.close();
+            outputStream.close();
+            socket.close();
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        try {
+            socket.close();
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void work() {
+        byte[] buffer = new byte[bufferSize];
+        try {
+            while (inputStream.read(buffer) > 0) {
+                input(buffer);
+            }
+        } catch (IOException e) {
+            stop();
+        }
+    }
+
+    protected abstract void input(byte[] buffer);
+
+    public void send(byte[] buffer) throws IOException {
+        if (outputStream == null) {
+            try {
+                synchronized (object) {
+                    object.wait();
+                }
+            } catch (InterruptedException e) {}
+        }
+        outputStream.write(buffer);
+    }
+}

java/core.legacy/src/main/java/base/server/socket/TcpClient.java

@@ -1,49 +1,49 @@
-package base.server.socket;
-
-import java.io.IOException;
-import java.net.Socket;
-import java.net.UnknownHostException;
-
-import base.Sender;
-import base.exception.worker.ActivateException;
-
-public class TcpClient extends AbstractTcpClient implements Sender {
-    protected static final String HOST = "localhost";
-
-    protected String host;
-    protected int port;
-
-    public TcpClient(int port) {
-        this(HOST, port);
-    }
-
-    public TcpClient(String host, int port) {
-        this(host, port, BUFFER_SIZE);
-    }
-
-    public TcpClient(String host, int port, int bufferSize) {
-        super(bufferSize);
-        this.host = host;
-        this.port = port;
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            socket = new Socket(host, port);
-            inputStream = socket.getInputStream();
-            outputStream = socket.getOutputStream();
-            synchronized (object) {
-                object.notifyAll();
-            }
-        } catch (UnknownHostException e) {
-            logger.error("", e);
-            throw new ActivateException();
-        } catch (IOException e) {
-            logger.error("", e);
-            throw new ActivateException();
-        }
-        super.activate();
-    }
-
-    protected void input(byte[] buffer) {}
+package base.server.socket;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+
+public class TcpClient extends AbstractTcpClient implements Sender {
+    protected static final String HOST = "localhost";
+
+    protected String host;
+    protected int port;
+
+    public TcpClient(int port) {
+        this(HOST, port);
+    }
+
+    public TcpClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public TcpClient(String host, int port, int bufferSize) {
+        super(bufferSize);
+        this.host = host;
+        this.port = port;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new Socket(host, port);
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+            synchronized (object) {
+                object.notifyAll();
+            }
+        } catch (UnknownHostException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    protected void input(byte[] buffer) {}
 }

java/core.legacy/src/main/java/base/server/socket/TcpServer.java

@@ -1,86 +1,86 @@
-package base.server.socket;
-
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.util.ArrayList;
-
-import base.Sender;
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.work.Work;
-
-public class TcpServer extends Work implements Sender {
-    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
-
-    protected int port;
-    protected ServerSocket serverSocket;
-    protected Constructor<?> clientConstructor;
-    protected ArrayList<TcpServerClient> clientList;
-
-    public TcpServer(int port) {
-        this(port, CLIENT_CLASS);
-    }
-
-    public TcpServer(int port, Class<?> clientClass) {
-        this.port = port;
-        try {
-            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, Socket.class);
-        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
-            logger.error("Failed to initialise client constructor");
-        }
-        clientList = new ArrayList<TcpServerClient>();
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            serverSocket = new ServerSocket(port);
-        } catch (IOException e) {
-            logger.error("", e);
-            throw new ActivateException();
-        }
-    }
-
-    public void deactivate() throws DeactivateException {
-        for (TcpServerClient client : clientList) {
-            client.stop();
-        }
-    }
-
-    public void exit() {
-        super.exit();
-        try {
-            serverSocket.close();
-            for (TcpServerClient client : clientList) {
-                client.exit();
-            }
-        } catch (IOException e) {
-            logger.error("", e);
-        }
-    }
-
-    public void work() {
-        try {
-            Socket socket = serverSocket.accept();
-            TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socket);
-            clientList.add(client);
-            client.start();
-            System.out.println("Accepted new connection from client: " + socket);
-        } catch (IOException e) {
-            stop();
-        } catch (Exception e) {
-            logger.error("", e);
-        }
-    }
-
-    public void send(byte[] buffer) throws IOException {
-        logger.debug("Number of clients = " + clientList.size());
-        for (TcpServerClient client : clientList) {
-            // Should be dealt with in clients own thread?
-            client.send(buffer);
-        }        
-    }
-
-    public void input(TcpServerClient client, byte[] buffer) {}
-}
+package base.server.socket;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayList;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public class TcpServer extends Work implements Sender {
+    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
+
+    protected int port;
+    protected ServerSocket serverSocket;
+    protected Constructor<?> clientConstructor;
+    protected ArrayList<TcpServerClient> clientList;
+
+    public TcpServer(int port) {
+        this(port, CLIENT_CLASS);
+    }
+
+    public TcpServer(int port, Class<?> clientClass) {
+        this.port = port;
+        try {
+            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, Socket.class);
+        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
+            logger.error("Failed to initialise client constructor");
+        }
+        clientList = new ArrayList<TcpServerClient>();
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            serverSocket = new ServerSocket(port);
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void deactivate() throws DeactivateException {
+        for (TcpServerClient client : clientList) {
+            client.stop();
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        try {
+            serverSocket.close();
+            for (TcpServerClient client : clientList) {
+                client.exit();
+            }
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void work() {
+        try {
+            Socket socket = serverSocket.accept();
+            TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socket);
+            clientList.add(client);
+            client.start();
+            System.out.println("Accepted new connection from client: " + socket);
+        } catch (IOException e) {
+            stop();
+        } catch (Exception e) {
+            logger.error("", e);
+        }
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        logger.debug("Number of clients = " + clientList.size());
+        for (TcpServerClient client : clientList) {
+            // Should be dealt with in clients own thread?
+            client.send(buffer);
+        }        
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {}
+}

java/core.legacy/src/main/java/base/server/socket/TcpServerClient.java

@@ -1,37 +1,37 @@
-package base.server.socket;
-
-import java.io.IOException;
-import java.net.Socket;
-
-import base.exception.worker.ActivateException;
-
-public class TcpServerClient extends AbstractTcpClient {
-    private TcpServer server;
-
-    public TcpServerClient(TcpServer server, Socket socket) {
-        this(server, socket, BUFFER_SIZE);
-    }
-
-    public TcpServerClient(TcpServer server, Socket socket, Integer bufferSize) {
-        super(bufferSize);
-        this.server = server;
-        this.socket = socket;
-    }
-
-    public void activate() throws ActivateException {
-        try {
-            inputStream = socket.getInputStream();
-            outputStream = socket.getOutputStream();
-            synchronized (object) {
-                object.notifyAll();
-            }
-        } catch (IOException e) {
-            logger.error("", e);
-            throw new ActivateException();
-        }
-    }
-
-    public void input(byte[] buffer) {
-        server.input(this, buffer);        
-    }
-}
+package base.server.socket;
+
+import java.io.IOException;
+import java.net.Socket;
+
+import base.exception.worker.ActivateException;
+
+public class TcpServerClient extends AbstractTcpClient {
+    private TcpServer server;
+
+    public TcpServerClient(TcpServer server, Socket socket) {
+        this(server, socket, BUFFER_SIZE);
+    }
+
+    public TcpServerClient(TcpServer server, Socket socket, Integer bufferSize) {
+        super(bufferSize);
+        this.server = server;
+        this.socket = socket;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+            synchronized (object) {
+                object.notifyAll();
+            }
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void input(byte[] buffer) {
+        server.input(this, buffer);        
+    }
+}

java/core.legacy/src/main/java/base/util/ArrayCycle.java

@@ -1,40 +1,40 @@
-package base.util;
-
-import java.util.concurrent.CopyOnWriteArrayList;
-
-public class ArrayCycle<E> extends CopyOnWriteArrayList<E> {
-    protected static final long serialVersionUID = 1L;
-
-    protected int index = 0;
-
-    @SuppressWarnings("unchecked")
-    public ArrayCycle(E... elementArray) {
-        if (elementArray != null) {
-            for (E element : elementArray) {
-                add(element);
-            }
-        }
-    }
-
-    public E current() {
-        return this.get(index);
-    }
-
-    public synchronized E previous() {
-        if (--index < 0) {
-            index = Math.max(0, size() - 1);
-        }
-        return get(index);
-    }
-
-    public synchronized E next() {
-        if (++index >= size()) {
-            index = 0;
-        }
-        return size() == 0 ? null : get(index);
-    }
-
-    public E reset() {
-        return get(index = 0);
-    }
-}
+package base.util;
+
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class ArrayCycle<E> extends CopyOnWriteArrayList<E> {
+    protected static final long serialVersionUID = 1L;
+
+    protected int index = 0;
+
+    @SuppressWarnings("unchecked")
+    public ArrayCycle(E... elementArray) {
+        if (elementArray != null) {
+            for (E element : elementArray) {
+                add(element);
+            }
+        }
+    }
+
+    public E current() {
+        return this.get(index);
+    }
+
+    public synchronized E previous() {
+        if (--index < 0) {
+            index = Math.max(0, size() - 1);
+        }
+        return get(index);
+    }
+
+    public synchronized E next() {
+        if (++index >= size()) {
+            index = 0;
+        }
+        return size() == 0 ? null : get(index);
+    }
+
+    public E reset() {
+        return get(index = 0);
+    }
+}

java/core.legacy/src/main/java/base/util/Buffer.java

@@ -1,41 +1,41 @@
-package base.util;
-
-public class Buffer {
-    protected byte[] elements;
-    protected int capacity;
-    protected int index;
-    protected int size;
-
-    public Buffer(int capacity) {
-        this.elements = new byte[capacity];
-        this.capacity = capacity;
-        index = 0;
-        size = 0;
-    }
-
-    public synchronized void add(byte... elements) {
-        for (byte element : elements) {
-            this.elements[index++ % capacity] = element;
-            if (size < capacity) {
-                ++size;
-            }
-        }
-    }
-
-    public synchronized void write(byte[] elements, int offset, int length) {
-        for (int i = offset; i < length; ++i) {
-            this.elements[index++ % capacity] = elements[i];
-            if (size < capacity) {
-                ++size;
-            }
-        }
-    }
-
-    public synchronized byte[] get() {
-        byte[] elements = new byte[size];
-        for (int i = 0; i < size; i++) {
-            elements[i] = this.elements[(index + i) % size];
-        }
-        return elements;
-    }
-}
+package base.util;
+
+public class Buffer {
+    protected byte[] elements;
+    protected int capacity;
+    protected int index;
+    protected int size;
+
+    public Buffer(int capacity) {
+        this.elements = new byte[capacity];
+        this.capacity = capacity;
+        index = 0;
+        size = 0;
+    }
+
+    public synchronized void add(byte... elements) {
+        for (byte element : elements) {
+            this.elements[index++ % capacity] = element;
+            if (size < capacity) {
+                ++size;
+            }
+        }
+    }
+
+    public synchronized void write(byte[] elements, int offset, int length) {
+        for (int i = offset; i < length; ++i) {
+            this.elements[index++ % capacity] = elements[i];
+            if (size < capacity) {
+                ++size;
+            }
+        }
+    }
+
+    public synchronized byte[] get() {
+        byte[] elements = new byte[size];
+        for (int i = 0; i < size; i++) {
+            elements[i] = this.elements[(index + i) % size];
+        }
+        return elements;
+    }
+}

java/core.legacy/src/main/java/base/util/Bufferable.java

@@ -1,6 +1,6 @@
-package base.util;
-
-public interface Bufferable {
-    public void load();
-    public void unload();
-}
+package base.util;
+
+public interface Bufferable {
+    public void load();
+    public void unload();
+}

java/core.legacy/src/main/java/base/util/BufferedArrayCycle.java

@@ -1,74 +1,74 @@
-package base.util;
-
-public class BufferedArrayCycle<E extends Bufferable> extends ArrayCycle<E> {
-    protected static final long serialVersionUID = 1L;
-
-    protected ArrayCycle<? extends Bufferable> buffer;
-    protected int before;
-    protected int after;
-    protected int indexFirst;
-    protected int indexLast;
-    //protected int indexBuffer;
-    //protected Bufferable[] bufferableArray;
-
-    @SuppressWarnings("unchecked")
-    public BufferedArrayCycle(int before, int after) {
-        this.before = before;
-        this.after = after;
-        indexFirst = 0;
-        indexLast = 0;
-        //bufferableArray = new Bufferable[before + after + 1];
-        //buffer = new ArrayCycle<Bufferable>();
-        
-    }
-
-    public E previous() {
-        get(indexFirst).unload();
-        indexFirst = previous(indexFirst);
-        indexLast = previous(indexLast);
-        get(indexLast).load();
-        // eerste before weg
-
-        // eerste after wordt huidig
-        
-        // voeg laatste after toe
-        
-        return current();
-    }
-
-    public E next() {
-
-        // eerste before weg
-
-        // eerste after wordt huidig        
-        
-        // voeg laatste after toe
-        
-        return size() == 0 ? null : get(index);
-    }
-
-    protected int previous(int index) {
-        if (--index < 0) {
-            index = Math.max(0, size() - 1);
-        }
-        return index;
-    }
-
-    protected int next(int index) {
-        System.out.println(index);
-        if (++index >= size()) {
-            index = 0;
-        
-        }
-        return index;
-    }
-
-    public static void main(String[] args) {
-        BufferedArrayCycle<Dummy> bac = new BufferedArrayCycle<Dummy>(2, 3);
-        for (int i = 1; i <= 10; ++i) {
-            bac.add(new Dummy(i));
-        }
-        bac.remove(0);
-        System.out.println(bac.get(2).id);
-    }
+package base.util;
+
+public class BufferedArrayCycle<E extends Bufferable> extends ArrayCycle<E> {
+    protected static final long serialVersionUID = 1L;
+
+    protected ArrayCycle<? extends Bufferable> buffer;
+    protected int before;
+    protected int after;
+    protected int indexFirst;
+    protected int indexLast;
+    //protected int indexBuffer;
+    //protected Bufferable[] bufferableArray;
+
+    @SuppressWarnings("unchecked")
+    public BufferedArrayCycle(int before, int after) {
+        this.before = before;
+        this.after = after;
+        indexFirst = 0;
+        indexLast = 0;
+        //bufferableArray = new Bufferable[before + after + 1];
+        //buffer = new ArrayCycle<Bufferable>();
+        
+    }
+
+    public E previous() {
+        get(indexFirst).unload();
+        indexFirst = previous(indexFirst);
+        indexLast = previous(indexLast);
+        get(indexLast).load();
+        // eerste before weg
+
+        // eerste after wordt huidig
+        
+        // voeg laatste after toe
+        
+        return current();
+    }
+
+    public E next() {
+
+        // eerste before weg
+
+        // eerste after wordt huidig        
+        
+        // voeg laatste after toe
+        
+        return size() == 0 ? null : get(index);
+    }
+
+    protected int previous(int index) {
+        if (--index < 0) {
+            index = Math.max(0, size() - 1);
+        }
+        return index;
+    }
+
+    protected int next(int index) {
+        System.out.println(index);
+        if (++index >= size()) {
+            index = 0;
+        
+        }
+        return index;
+    }
+
+    public static void main(String[] args) {
+        BufferedArrayCycle<Dummy> bac = new BufferedArrayCycle<Dummy>(2, 3);
+        for (int i = 1; i <= 10; ++i) {
+            bac.add(new Dummy(i));
+        }
+        bac.remove(0);
+        System.out.println(bac.get(2).id);
+    }
 }

java/core.legacy/src/main/java/base/util/Dummy.java

@@ -1,18 +1,18 @@
-package base.util;
-
-public class Dummy implements Bufferable {
-    public int id;
-    
-    public Dummy(int id) {
-        this.id = id;
-    }
-
-    public void load() {
-        System.out.println("Dummy #" + id + ": load()");        
-    }
-
-    public void unload() {
-        System.out.println("Dummy #" + id + ": load()");        
-    }
-
-}
+package base.util;
+
+public class Dummy implements Bufferable {
+    public int id;
+    
+    public Dummy(int id) {
+        this.id = id;
+    }
+
+    public void load() {
+        System.out.println("Dummy #" + id + ": load()");        
+    }
+
+    public void unload() {
+        System.out.println("Dummy #" + id + ": load()");        
+    }
+
+}

java/core.legacy/src/main/java/base/worker/DirectIntervalWorker.java

@@ -1,14 +1,14 @@
-package base.worker;
-
-import base.work.Work;
-
-public class DirectIntervalWorker extends ThreadIntervalWorker {
-    public DirectIntervalWorker(Work work, int interval) {
-        super(work, false);
-        this.interval = interval;
-    }
-
-    public DirectIntervalWorker(IntervalWork intervalWork) {
-        super(intervalWork);
-    }
-}
+package base.worker;
+
+import base.work.Work;
+
+public class DirectIntervalWorker extends ThreadIntervalWorker {
+    public DirectIntervalWorker(Work work, int interval) {
+        super(work, false);
+        this.interval = interval;
+    }
+
+    public DirectIntervalWorker(IntervalWork intervalWork) {
+        super(intervalWork);
+    }
+}

java/core.legacy/src/main/java/base/worker/DirectWorker.java

@@ -1,9 +1,9 @@
-package base.worker;
-
-import base.work.Work;
-
-public class DirectWorker extends ThreadWorker {
-    public DirectWorker(Work work) {
-        super(work, false);
-    }
+package base.worker;
+
+import base.work.Work;
+
+public class DirectWorker extends ThreadWorker {
+    public DirectWorker(Work work) {
+        super(work, false);
+    }
 }

java/core.legacy/src/main/java/base/worker/ForegroundListener.java

@@ -1,10 +1,10 @@
-package base.worker;
-
-import base.work.Listen;
-import base.worker.pool.Listener;
-
-public class ForegroundListener<E> extends BackgroundListener<E> implements Listener<E> {
-    public ForegroundListener(Listen<E> listen) {
-        super(listen, false);
-    }
+package base.worker;
+
+import base.work.Listen;
+import base.worker.pool.Listener;
+
+public class ForegroundListener<E> extends BackgroundListener<E> implements Listener<E> {
+    public ForegroundListener(Listen<E> listen) {
+        super(listen, false);
+    }
 }

java/core.legacy/src/main/java/base/worker/IntervalWork.java

@@ -1,37 +1,37 @@
-package base.worker;
-
-import base.work.Work;
-
-public abstract class IntervalWork extends Work {
-    protected IntervalWork() {
-        this(WORKER_TYPE);
-    }
-
-    protected IntervalWork(int interval) {
-        this(WORKER_TYPE, interval);
-    }
-
-    protected IntervalWork(Worker.Type workerType) {
-        switch (workerType) {
-            case FOREGROUND:
-                worker = new DirectIntervalWorker(this);
-                break;
-            default:
-            case BACKGROUND:
-                worker = new ThreadIntervalWorker(this);
-                break;
-        }
-    }
-
-    protected IntervalWork(Worker.Type workerType, int interval) {
-        switch (workerType) {
-            case FOREGROUND:
-                worker = new DirectIntervalWorker(this, interval);
-                break;
-            default:
-            case BACKGROUND:
-                worker = new ThreadIntervalWorker(this, interval);
-                break;
-        }
-    }
-}
+package base.worker;
+
+import base.work.Work;
+
+public abstract class IntervalWork extends Work {
+    protected IntervalWork() {
+        this(WORKER_TYPE);
+    }
+
+    protected IntervalWork(int interval) {
+        this(WORKER_TYPE, interval);
+    }
+
+    protected IntervalWork(Worker.Type workerType) {
+        switch (workerType) {
+            case FOREGROUND:
+                worker = new DirectIntervalWorker(this);
+                break;
+            default:
+            case BACKGROUND:
+                worker = new ThreadIntervalWorker(this);
+                break;
+        }
+    }
+
+    protected IntervalWork(Worker.Type workerType, int interval) {
+        switch (workerType) {
+            case FOREGROUND:
+                worker = new DirectIntervalWorker(this, interval);
+                break;
+            default:
+            case BACKGROUND:
+                worker = new ThreadIntervalWorker(this, interval);
+                break;
+        }
+    }
+}

java/core.legacy/src/main/java/base/worker/pool/Listener.java

@@ -1,5 +1,5 @@
-package base.worker.pool;
-
-public interface Listener<E> {
-    public void add(E element);
-}
+package base.worker.pool;
+
+public interface Listener<E> {
+    public void add(E element);
+}

java/core.legacy/src/main/java/base/worker/pool/ListenerPool.java

@@ -1,38 +1,38 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-
-public class ListenerPool<E> {
-    protected int poolSize;
-    protected BlockingQueue<Wrapper<E>> queue;
-    protected ExecutorService executorService;
-
-    public ListenerPool(int poolSize) {
-        this.poolSize = poolSize;
-        queue = new LinkedBlockingQueue<Wrapper<E>>();
-        executorService = Executors.newFixedThreadPool(poolSize);
-    }
-
-    public PooledListener<E> add(PooledListener<E> listener) {
-        listener.setPoolQueue(queue);
-        return listener;
-    }
-
-    public void start() {
-        for (int i = 0; i < poolSize; ++i) {
-            Runnable runnable = new ListenerPoolRunnable<E>(queue, i);
-            executorService.execute(runnable);
-        }
-    }
-
-    public void await() {
-        try {
-            executorService.awaitTermination(0, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {}        
-    }
-    
-}
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class ListenerPool<E> {
+    protected int poolSize;
+    protected BlockingQueue<Wrapper<E>> queue;
+    protected ExecutorService executorService;
+
+    public ListenerPool(int poolSize) {
+        this.poolSize = poolSize;
+        queue = new LinkedBlockingQueue<Wrapper<E>>();
+        executorService = Executors.newFixedThreadPool(poolSize);
+    }
+
+    public PooledListener<E> add(PooledListener<E> listener) {
+        listener.setPoolQueue(queue);
+        return listener;
+    }
+
+    public void start() {
+        for (int i = 0; i < poolSize; ++i) {
+            Runnable runnable = new ListenerPoolRunnable<E>(queue, i);
+            executorService.execute(runnable);
+        }
+    }
+
+    public void await() {
+        try {
+            executorService.awaitTermination(0, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {}        
+    }
+    
+}

java/core.legacy/src/main/java/base/worker/pool/ListenerPoolRunnable.java

@@ -1,24 +1,24 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-
-class ListenerPoolRunnable<E> implements Runnable {
-    protected BlockingQueue<Wrapper<E>> queue;
-    protected int id;
-
-    public ListenerPoolRunnable(BlockingQueue<Wrapper<E>> queue, int id) {
-        this.queue = queue;
-        this.id = id;
-    }
-
-    public void run() {
-        try {
-            while (true) {
-                System.out.println("Thread #" + id + " waiting...");
-                Wrapper<E> wrapper = queue.take();
-                wrapper.deliver();
-                Thread.sleep((int) (Math.random() * 1000));
-            }
-        } catch (InterruptedException e) {}            
-    }
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+
+class ListenerPoolRunnable<E> implements Runnable {
+    protected BlockingQueue<Wrapper<E>> queue;
+    protected int id;
+
+    public ListenerPoolRunnable(BlockingQueue<Wrapper<E>> queue, int id) {
+        this.queue = queue;
+        this.id = id;
+    }
+
+    public void run() {
+        try {
+            while (true) {
+                System.out.println("Thread #" + id + " waiting...");
+                Wrapper<E> wrapper = queue.take();
+                wrapper.deliver();
+                Thread.sleep((int) (Math.random() * 1000));
+            }
+        } catch (InterruptedException e) {}            
+    }
 }

java/core.legacy/src/main/java/base/worker/pool/PooledListener.java

@@ -1,28 +1,28 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-
-import base.work.Listen;
-
-public class PooledListener<E> extends PooledWorker implements Listener<E> {
-    protected BlockingQueue<Wrapper<E>> poolQueue;
-    protected Listen<E> listen;
-
-    public PooledListener(Listen<E> listen) {
-        super(listen);
-        this.listen = listen;
-    }
-
-    public void setPoolQueue(BlockingQueue<Wrapper<E>> poolQueue) {
-        this.poolQueue = poolQueue;
-    }
-
-    public synchronized void add(E element) {
-        Wrapper<E> wrapper = new Wrapper<E>(this, element);
-        poolQueue.add(wrapper);
-    }
-
-    void input(E element) {
-        listen.input(element);
-    }
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+
+import base.work.Listen;
+
+public class PooledListener<E> extends PooledWorker implements Listener<E> {
+    protected BlockingQueue<Wrapper<E>> poolQueue;
+    protected Listen<E> listen;
+
+    public PooledListener(Listen<E> listen) {
+        super(listen);
+        this.listen = listen;
+    }
+
+    public void setPoolQueue(BlockingQueue<Wrapper<E>> poolQueue) {
+        this.poolQueue = poolQueue;
+    }
+
+    public synchronized void add(E element) {
+        Wrapper<E> wrapper = new Wrapper<E>(this, element);
+        poolQueue.add(wrapper);
+    }
+
+    void input(E element) {
+        listen.input(element);
+    }
 }

java/core.legacy/src/main/java/base/worker/pool/PooledWorker.java

@@ -1,49 +1,49 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-
-import base.work.Work;
-import base.worker.Worker;
-
-public class PooledWorker extends Worker {
-    protected BlockingQueue<Worker> activateQueue;
-    protected BlockingQueue<Worker> deactivateQueue;
-
-    public PooledWorker(Work work) {
-        super(work);
-    }
-
-    public void setActivateQueue(BlockingQueue<Worker> activateQueue) {
-        this.activateQueue = activateQueue;
-    }
-
-    public void setDeactivateQueue(BlockingQueue<Worker> deactivateQueue) {
-        this.deactivateQueue = deactivateQueue;
-    }
-
-    public void start() {
-        if (!active) {
-            activate = true;
-        }
-        if (!run) {
-            run = true;
-        }
-        try {
-            deactivateQueue.remove(this);
-            activateQueue.put(this);
-        } catch (InterruptedException e) {}
-    }
-
-    public void stop() {
-        System.out.println("stop!! " + active);
-        if (active) {
-            deactivate = true;
-        }
-        activateQueue.remove(this);
-        deactivateQueue.add(this);
-    }
-
-    public void exit() {
-        stop();        
-    }
-}
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+
+import base.work.Work;
+import base.worker.Worker;
+
+public class PooledWorker extends Worker {
+    protected BlockingQueue<Worker> activateQueue;
+    protected BlockingQueue<Worker> deactivateQueue;
+
+    public PooledWorker(Work work) {
+        super(work);
+    }
+
+    public void setActivateQueue(BlockingQueue<Worker> activateQueue) {
+        this.activateQueue = activateQueue;
+    }
+
+    public void setDeactivateQueue(BlockingQueue<Worker> deactivateQueue) {
+        this.deactivateQueue = deactivateQueue;
+    }
+
+    public void start() {
+        if (!active) {
+            activate = true;
+        }
+        if (!run) {
+            run = true;
+        }
+        try {
+            deactivateQueue.remove(this);
+            activateQueue.put(this);
+        } catch (InterruptedException e) {}
+    }
+
+    public void stop() {
+        System.out.println("stop!! " + active);
+        if (active) {
+            deactivate = true;
+        }
+        activateQueue.remove(this);
+        deactivateQueue.add(this);
+    }
+
+    public void exit() {
+        stop();        
+    }
+}

java/core.legacy/src/main/java/base/worker/pool/WorkerPool.java

@@ -1,42 +1,42 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingQueue;
-
-import base.util.ArrayCycle;
-import base.worker.Worker;
-
-public class WorkerPool {
-    protected int poolSize;
-    protected BlockingQueue<Worker> activateQueue;
-    protected BlockingQueue<Worker> deactivateQueue;
-    protected ArrayCycle<Worker> workerCycle;
-    protected ExecutorService executorService;
-
-    public WorkerPool(int poolSize) {
-        this.poolSize = poolSize;
-        activateQueue = new LinkedBlockingQueue<Worker>();
-        deactivateQueue = new LinkedBlockingQueue<Worker>();
-        workerCycle = new ArrayCycle<Worker>();
-        executorService = Executors.newFixedThreadPool(poolSize);
-    }
-
-    public void start() {
-        for (int i = 0; i < poolSize; ++i) {
-            Runnable runnable = new WorkerPoolRunnable(activateQueue, deactivateQueue, workerCycle, i + 1);
-            executorService.execute(runnable);
-        }        
-    }
-
-    public void stop() {
-        // Must be graceful
-        executorService.shutdownNow();
-    }
-
-    public void add(PooledWorker worker) {
-        worker.setActivateQueue(activateQueue);
-        worker.setDeactivateQueue(deactivateQueue);
-    }
-}
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import base.util.ArrayCycle;
+import base.worker.Worker;
+
+public class WorkerPool {
+    protected int poolSize;
+    protected BlockingQueue<Worker> activateQueue;
+    protected BlockingQueue<Worker> deactivateQueue;
+    protected ArrayCycle<Worker> workerCycle;
+    protected ExecutorService executorService;
+
+    public WorkerPool(int poolSize) {
+        this.poolSize = poolSize;
+        activateQueue = new LinkedBlockingQueue<Worker>();
+        deactivateQueue = new LinkedBlockingQueue<Worker>();
+        workerCycle = new ArrayCycle<Worker>();
+        executorService = Executors.newFixedThreadPool(poolSize);
+    }
+
+    public void start() {
+        for (int i = 0; i < poolSize; ++i) {
+            Runnable runnable = new WorkerPoolRunnable(activateQueue, deactivateQueue, workerCycle, i + 1);
+            executorService.execute(runnable);
+        }        
+    }
+
+    public void stop() {
+        // Must be graceful
+        executorService.shutdownNow();
+    }
+
+    public void add(PooledWorker worker) {
+        worker.setActivateQueue(activateQueue);
+        worker.setDeactivateQueue(deactivateQueue);
+    }
+}

java/core.legacy/src/main/java/base/worker/pool/WorkerPoolRunnable.java

@@ -1,41 +1,41 @@
-package base.worker.pool;
-
-import java.util.concurrent.BlockingQueue;
-
-import base.util.ArrayCycle;
-import base.worker.Worker;
-
-public class WorkerPoolRunnable implements Runnable {
-    protected BlockingQueue<Worker> activateQueue;
-    protected BlockingQueue<Worker> deactivateQueue;
-    protected ArrayCycle<Worker> workerCycle;
-    protected int id;
-
-    public WorkerPoolRunnable(BlockingQueue<Worker> activateQueue, BlockingQueue<Worker> deactivateQueue, ArrayCycle<Worker> workerCycle, int id) {
-        this.activateQueue = activateQueue;
-        this.deactivateQueue = deactivateQueue;
-        this.workerCycle = workerCycle;
-        this.id = id;
-    }
-
-    public void run() {
-        while (true) {
-            if (!deactivateQueue.isEmpty()) {
-                try {
-                    Worker worker = deactivateQueue.take();
-                    worker.runDeactivate();
-                    workerCycle.remove(worker);
-                } catch (InterruptedException e) {}
-            } else if (!activateQueue.isEmpty() || workerCycle.isEmpty()) {
-                try {
-                    Worker worker = activateQueue.take();
-                    worker.runActivate();
-                    workerCycle.add(worker);
-                } catch (InterruptedException e) {}            
-            } else {
-                Worker worker = workerCycle.next();
-                worker.runWork();
-            }
-        }
-    }
-}
+package base.worker.pool;
+
+import java.util.concurrent.BlockingQueue;
+
+import base.util.ArrayCycle;
+import base.worker.Worker;
+
+public class WorkerPoolRunnable implements Runnable {
+    protected BlockingQueue<Worker> activateQueue;
+    protected BlockingQueue<Worker> deactivateQueue;
+    protected ArrayCycle<Worker> workerCycle;
+    protected int id;
+
+    public WorkerPoolRunnable(BlockingQueue<Worker> activateQueue, BlockingQueue<Worker> deactivateQueue, ArrayCycle<Worker> workerCycle, int id) {
+        this.activateQueue = activateQueue;
+        this.deactivateQueue = deactivateQueue;
+        this.workerCycle = workerCycle;
+        this.id = id;
+    }
+
+    public void run() {
+        while (true) {
+            if (!deactivateQueue.isEmpty()) {
+                try {
+                    Worker worker = deactivateQueue.take();
+                    worker.runDeactivate();
+                    workerCycle.remove(worker);
+                } catch (InterruptedException e) {}
+            } else if (!activateQueue.isEmpty() || workerCycle.isEmpty()) {
+                try {
+                    Worker worker = activateQueue.take();
+                    worker.runActivate();
+                    workerCycle.add(worker);
+                } catch (InterruptedException e) {}            
+            } else {
+                Worker worker = workerCycle.next();
+                worker.runWork();
+            }
+        }
+    }
+}

java/core.legacy/src/main/java/base/worker/pool/Wrapper.java

@@ -1,16 +1,16 @@
-package base.worker.pool;
-
-
-class Wrapper<E> {
-    protected PooledListener<E> listener;
-    protected E element;
-
-    public Wrapper(PooledListener<E> listener, E element) {
-        this.listener = listener;
-        this.element = element;
-    }
-
-    public void deliver() {
-        listener.input(element);            
-    }
+package base.worker.pool;
+
+
+class Wrapper<E> {
+    protected PooledListener<E> listener;
+    protected E element;
+
+    public Wrapper(PooledListener<E> listener, E element) {
+        this.listener = listener;
+        this.element = element;
+    }
+
+    public void deliver() {
+        listener.input(element);            
+    }
 }

java/core.legacy/src/test/java/junit/TestTcpChannelCommunication.java

@@ -1,94 +1,94 @@
-package junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import base.server.channel.TcpClient;
-import base.server.channel.TcpServer;
-import base.server.channel.TcpServerClient;
-
-public class TestTcpChannelCommunication {
-    protected TestTcpServer server;
-    protected TestTcpClient client;
-
-    @Before
-    public void setUp() throws Exception {
-        server = new TestTcpServer(1234);
-        server.start();
-        client = new TestTcpClient(1234);
-        client.start();
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        client.exit();
-        server.exit();
-
-        // Should add blocking stop and exit to worker
-        while (client.active() || server.active()) {
-            Thread.sleep(100);
-        }        
-    }
-
-    @Test
-    public void testSendClientToServer() throws Exception {
-        String message = "test";
-        client.send(message.getBytes());
-        synchronized (server) {
-            server.wait(2000);
-        }
-        byte[] buffer = server.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    @Test
-    public void testSendServerToClient() throws Exception {
-        // If client can send, connection has been established
-        client.send("init".getBytes());
-
-        String message = "test";
-        server.send(message.getBytes());
-        synchronized (client) {
-            client.wait(2000);
-        }
-        byte[] buffer = client.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    class TestTcpServer extends TcpServer {
-        public byte[] buffer;
-
-        public TestTcpServer(int port) {
-            super(port);
-        }
-
-        public void input(TcpServerClient client, byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }                
-        }
-    }
-
-    class TestTcpClient extends TcpClient {
-        public byte[] buffer;
-
-        public TestTcpClient(int port) {
-            super(port);
-        }
-
-        protected void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }                
-        }
-        
-    }
-}
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.channel.TcpClient;
+import base.server.channel.TcpServer;
+import base.server.channel.TcpServerClient;
+
+public class TestTcpChannelCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }        
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+        
+    }
+}

java/core.legacy/src/test/java/junit/TestTcpSocketCommunication.java

@@ -1,93 +1,93 @@
-package junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import base.server.socket.TcpClient;
-import base.server.socket.TcpServer;
-import base.server.socket.TcpServerClient;
-
-public class TestTcpSocketCommunication {
-    protected TestTcpServer server;
-    protected TestTcpClient client;
-
-    @Before
-    public void setUp() throws Exception {
-        server = new TestTcpServer(1234);
-        server.start();
-        client = new TestTcpClient(1234);
-        client.start();
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        client.exit();
-        server.exit();
-
-        // Should add blocking stop and exit to worker
-        while (client.active() || server.active()) {
-            Thread.sleep(100);
-        }
-    }
-
-    @Test
-    public void testSendClientToServer() throws Exception {
-        String message = "test";
-        client.send(message.getBytes());
-        synchronized (server) {
-            server.wait(2000);
-        }
-        byte[] buffer = server.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    @Test
-    public void testSendServerToClient() throws Exception {
-        // If client can send, connection has been established
-        client.send("init".getBytes());
-
-        String message = "test";
-        server.send(message.getBytes());
-        synchronized (client) {
-            client.wait(2000);
-        }
-        byte[] buffer = client.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    class TestTcpServer extends TcpServer {
-        public byte[] buffer;
-
-        public TestTcpServer(int port) {
-            super(port);
-        }
-
-        public void input(TcpServerClient client, byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }
-        }
-    }
-
-    class TestTcpClient extends TcpClient {
-        public byte[] buffer;
-
-        public TestTcpClient(int port) {
-            super(port);
-        }
-
-        protected void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }
-        }        
-    }
-}
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.socket.TcpClient;
+import base.server.socket.TcpServer;
+import base.server.socket.TcpServerClient;
+
+public class TestTcpSocketCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }        
+    }
+}

java/core.legacy/src/test/java/junit/TestUdpDuplexCommunication.java

@@ -1,96 +1,96 @@
-package junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.net.UnknownHostException;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import base.server.datagram.UdpDuplexAutoClient;
-import base.server.datagram.UdpDuplexServer;
-
-public class TestUdpDuplexCommunication {
-    protected TestUdpDuplexServer server;
-    protected TestUdpDuplexClient client;
-
-    @Before
-    public void setUp() throws Exception {
-        server = new TestUdpDuplexServer(1234, 1235);
-        server.start();
-        client = new TestUdpDuplexClient(1234, 1235);
-        client.start();
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        client.exit();
-        server.exit();
-
-        // Should add blocking stop and exit to worker
-        while (client.active() || server.active()) {
-            Thread.sleep(1000);
-        }
-    }
-
-    @Test
-    public void testServerToClientCommunication() throws Exception {
-        String message = "test";
-        server.send(message.getBytes());
-        System.err.println("send");
-        synchronized (client) {
-            client.wait(2000);
-        }
-        byte[] buffer = client.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    @Test
-    public void testClientToServerCommunication() throws Exception {
-        // Let client discover server address
-        testServerToClientCommunication();
-
-        String message = "test";
-        client.send(message.getBytes());
-        System.err.println("send");
-        synchronized (server) {
-            server.wait(2000);
-        }
-        byte[] buffer = server.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    public class TestUdpDuplexServer extends UdpDuplexServer {
-        public byte[] buffer;
-
-        public TestUdpDuplexServer(int sendPort, int bindPort) {
-            super(sendPort, bindPort);
-        }
-
-        public void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }            
-        }
-    }
-
-    class TestUdpDuplexClient extends UdpDuplexAutoClient {
-        public byte[] buffer;
-
-        public TestUdpDuplexClient(int bindPort, int sendPort) throws UnknownHostException {
-            super(bindPort, sendPort);
-        }
-
-        public void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }            
-        }
-    }
-}
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.net.UnknownHostException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpDuplexAutoClient;
+import base.server.datagram.UdpDuplexServer;
+
+public class TestUdpDuplexCommunication {
+    protected TestUdpDuplexServer server;
+    protected TestUdpDuplexClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestUdpDuplexServer(1234, 1235);
+        server.start();
+        client = new TestUdpDuplexClient(1234, 1235);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    public void testServerToClientCommunication() throws Exception {
+        String message = "test";
+        server.send(message.getBytes());
+        System.err.println("send");
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testClientToServerCommunication() throws Exception {
+        // Let client discover server address
+        testServerToClientCommunication();
+
+        String message = "test";
+        client.send(message.getBytes());
+        System.err.println("send");
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    public class TestUdpDuplexServer extends UdpDuplexServer {
+        public byte[] buffer;
+
+        public TestUdpDuplexServer(int sendPort, int bindPort) {
+            super(sendPort, bindPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+
+    class TestUdpDuplexClient extends UdpDuplexAutoClient {
+        public byte[] buffer;
+
+        public TestUdpDuplexClient(int bindPort, int sendPort) throws UnknownHostException {
+            super(bindPort, sendPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}

java/core.legacy/src/test/java/junit/TestUdpMulticastCommunication.java

@@ -1,63 +1,63 @@
-package junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import base.server.datagram.UdpMulticastClient;
-import base.server.datagram.UdpMulticastServer;
-
-public class TestUdpMulticastCommunication {
-    protected UdpMulticastServer server;
-    protected TestUdpMulticastClient client;
-
-    @Before
-    public void setUp() throws Exception {
-        server = new UdpMulticastServer(1234);
-        server.start();
-        client = new TestUdpMulticastClient(1234);
-        client.start();
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        client.exit();
-        server.exit();
-
-        // Should add blocking stop and exit to worker
-        while (client.active() || server.active()) {
-            Thread.sleep(1000);
-        }
-    }
-
-    @Test
-    public void testServerToClientCommunication() throws Exception {
-        String message = "test";
-        server.send(message.getBytes());
-        System.err.println("send");
-        synchronized (client) {
-            client.wait(2000);
-        }
-        byte[] buffer = client.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    class TestUdpMulticastClient extends UdpMulticastClient {
-        public byte[] buffer;
-
-        public TestUdpMulticastClient(int port) {
-            super(port);
-        }
-
-        public void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }            
-        }
-    }
-}
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpMulticastClient;
+import base.server.datagram.UdpMulticastServer;
+
+public class TestUdpMulticastCommunication {
+    protected UdpMulticastServer server;
+    protected TestUdpMulticastClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new UdpMulticastServer(1234);
+        server.start();
+        client = new TestUdpMulticastClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    public void testServerToClientCommunication() throws Exception {
+        String message = "test";
+        server.send(message.getBytes());
+        System.err.println("send");
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestUdpMulticastClient extends UdpMulticastClient {
+        public byte[] buffer;
+
+        public TestUdpMulticastClient(int port) {
+            super(port);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}

java/core.legacy/src/test/java/junit/TestUdpUnicastCommunication.java

@@ -1,61 +1,61 @@
-package junit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import base.server.datagram.UdpSender;
-import base.server.datagram.UdpServer;
-
-public class TestUdpUnicastCommunication {
-    protected TestUdpServer server;
-    protected UdpSender sender;
-
-    @Before
-    public void setUp() throws Exception {
-        server = new TestUdpServer(1234);
-        server.start();
-        sender = new UdpSender(1234);
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        server.exit();
-
-        // Should add blocking stop and exit to worker
-        while (server.active()) {
-            Thread.sleep(100);
-        }        
-    }
-
-    @Test
-    public void testSendClientToServer() throws Exception {
-        String message = "test";
-        sender.send(message.getBytes());
-        synchronized (server) {
-            server.wait(2000);
-        }
-        byte[] buffer = server.buffer;
-        assertNotNull("Received input", buffer);
-        assertEquals("Message intact", message, new String(buffer).trim());
-    }
-
-    class TestUdpServer extends UdpServer {
-        public byte[] buffer;
-
-        public TestUdpServer(int port) {
-            super(port);
-        }
-
-        @Override
-        protected void input(byte[] buffer) {
-            this.buffer = buffer;
-            synchronized (this) {
-                notifyAll();
-            }            
-        }
-    }
-}
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpSender;
+import base.server.datagram.UdpServer;
+
+public class TestUdpUnicastCommunication {
+    protected TestUdpServer server;
+    protected UdpSender sender;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestUdpServer(1234);
+        server.start();
+        sender = new UdpSender(1234);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (server.active()) {
+            Thread.sleep(100);
+        }        
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        sender.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestUdpServer extends UdpServer {
+        public byte[] buffer;
+
+        public TestUdpServer(int port) {
+            super(port);
+        }
+
+        @Override
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}

java/core.legacy/src/test/java/test/Test.java

@@ -1,54 +1,54 @@
-package test;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-
-public class Test {
-    public static void main(String[] args) {
-        try {
-            new Test().start();
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void start() throws Throwable {
-        input((Object) new A());
-        input((Object) new B());
-        input((Object) new String[] {"a", "b"});
-    }
-
-    public void input(Object object) throws Throwable {
-        System.out.println("Object");
-        MethodType methodType = MethodType.methodType(void.class, object.getClass());
-        MethodHandles.Lookup lookup = MethodHandles.lookup();
-        MethodHandle methodHandle = lookup.findVirtual(getClass(), "input", methodType);
-        try {
-            methodHandle.invoke(this, object);
-        } catch (NoSuchMethodException e) {
-            e.printStackTrace();
-            System.exit(1);
-        }
-    }
-
-    public void input(A object) {
-        System.out.println("A");
-    }
-
-    public void input(B object) {
-        System.out.println("B");
-    }
-
-    public void input(String[] object) {
-        System.out.println("String[]");
-    }
-
-    public class A {
-        
-    }
-
-    public class B {
-        
-    }
-}
+package test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+public class Test {
+    public static void main(String[] args) {
+        try {
+            new Test().start();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void start() throws Throwable {
+        input((Object) new A());
+        input((Object) new B());
+        input((Object) new String[] {"a", "b"});
+    }
+
+    public void input(Object object) throws Throwable {
+        System.out.println("Object");
+        MethodType methodType = MethodType.methodType(void.class, object.getClass());
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        MethodHandle methodHandle = lookup.findVirtual(getClass(), "input", methodType);
+        try {
+            methodHandle.invoke(this, object);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    public void input(A object) {
+        System.out.println("A");
+    }
+
+    public void input(B object) {
+        System.out.println("B");
+    }
+
+    public void input(String[] object) {
+        System.out.println("String[]");
+    }
+
+    public class A {
+        
+    }
+
+    public class B {
+        
+    }
+}

java/core.legacy/src/test/java/worker/TestDirectWork.java

@@ -1,15 +1,15 @@
-package worker;
-
-import worker.dummy.DummyWork;
-
-
-public class TestDirectWork {
-    public static void main(String[] args) {
-        DummyWork work = new DummyWork(1);
-        work.setWork(100);
-        work.start();
-        try {
-            Thread.sleep(10000);
-        } catch (InterruptedException e) {}
-    }
-}
+package worker;
+
+import worker.dummy.DummyWork;
+
+
+public class TestDirectWork {
+    public static void main(String[] args) {
+        DummyWork work = new DummyWork(1);
+        work.setWork(100);
+        work.start();
+        try {
+            Thread.sleep(10000);
+        } catch (InterruptedException e) {}
+    }
+}

java/core.legacy/src/test/java/worker/TestIntervalWork.java

@@ -1,18 +1,18 @@
-package worker;
-
-import worker.dummy.DummyIntervalWork;
-import base.work.Work;
-
-public class TestIntervalWork {
-    public static void main(String[] args) {
-        Work work = new DummyIntervalWork(500);
-        for (int i = 0; i < 10; ++i) {
-            work.start();
-            System.out.println("--");
-            try {
-                Thread.sleep(1000);
-            } catch (InterruptedException e) {}
-            work.stop();
-        }
-    }
-}
+package worker;
+
+import worker.dummy.DummyIntervalWork;
+import base.work.Work;
+
+public class TestIntervalWork {
+    public static void main(String[] args) {
+        Work work = new DummyIntervalWork(500);
+        for (int i = 0; i < 10; ++i) {
+            work.start();
+            System.out.println("--");
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {}
+            work.stop();
+        }
+    }
+}

java/core.legacy/src/test/java/worker/TestListen.java

@@ -1,19 +1,19 @@
-package worker;
-
-import worker.dummy.DummyListen;
-
-public class TestListen {
-    public static void main(String[] args) {
-        DummyListen<Integer> listen = new DummyListen<Integer>(0);
-        listen.start();
-        for (int i = 0; i < 10; ++i) {
-            listen.add(i);
-            try {
-                Thread.sleep(1000);
-            } catch (InterruptedException e) {}
-        }
-        try {
-            Thread.sleep(10000);
-        } catch (InterruptedException e) {}
-    }
-}
+package worker;
+
+import worker.dummy.DummyListen;
+
+public class TestListen {
+    public static void main(String[] args) {
+        DummyListen<Integer> listen = new DummyListen<Integer>(0);
+        listen.start();
+        for (int i = 0; i < 10; ++i) {
+            listen.add(i);
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {}
+        }
+        try {
+            Thread.sleep(10000);
+        } catch (InterruptedException e) {}
+    }
+}

java/core.legacy/src/test/java/worker/TestPooledListen.java

@@ -1,38 +1,38 @@
-package worker;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import worker.dummy.DummyListen;
-import base.worker.pool.ListenerPool;
-
-public class TestPooledListen {
-    protected int id;
-
-    public TestPooledListen(int id) {        
-        this.id = id;
-    }
-
-    public void input(Integer element) {
-        System.out.println("#" + id + ": " + element);                
-    }
-
-    public static void main(String[] args) {
-        ListenerPool<Integer> listenerPool = new ListenerPool<Integer>(5);    
-        List<DummyListen<Integer>> listenList = new ArrayList<DummyListen<Integer>>();
-        for (int i = 0; i < 20; ++i) {
-            DummyListen<Integer> listen = new DummyListen<Integer>(listenerPool, i + 1);
-            listenList.add(listen);
-        }
-        listenerPool.start();
-
-        System.out.println("Starting to give out elements!");
-        for (int i = 0; i < 100; ++i) {
-            DummyListen<Integer> randomListen = listenList.get((new Random()).nextInt(listenList.size()));
-            randomListen.add(i);
-        }
-
-        //listenerPool.await();
-    }
-}
+package worker;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import worker.dummy.DummyListen;
+import base.worker.pool.ListenerPool;
+
+public class TestPooledListen {
+    protected int id;
+
+    public TestPooledListen(int id) {        
+        this.id = id;
+    }
+
+    public void input(Integer element) {
+        System.out.println("#" + id + ": " + element);                
+    }
+
+    public static void main(String[] args) {
+        ListenerPool<Integer> listenerPool = new ListenerPool<Integer>(5);    
+        List<DummyListen<Integer>> listenList = new ArrayList<DummyListen<Integer>>();
+        for (int i = 0; i < 20; ++i) {
+            DummyListen<Integer> listen = new DummyListen<Integer>(listenerPool, i + 1);
+            listenList.add(listen);
+        }
+        listenerPool.start();
+
+        System.out.println("Starting to give out elements!");
+        for (int i = 0; i < 100; ++i) {
+            DummyListen<Integer> randomListen = listenList.get((new Random()).nextInt(listenList.size()));
+            randomListen.add(i);
+        }
+
+        //listenerPool.await();
+    }
+}

java/core.legacy/src/test/java/worker/TestPooledWork.java

@@ -1,45 +1,45 @@
-package worker;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import worker.dummy.DummyWork;
-import base.work.Work;
-import base.worker.pool.WorkerPool;
-
-public class TestPooledWork {
-    public static void main(String[] args) {
-        WorkerPool workerPool = new WorkerPool(3);
-
-        List<DummyWork> workList = new ArrayList<DummyWork>();
-        for (int i = 0; i < 10; ++i) {
-            DummyWork work = new DummyWork(workerPool, i + 1);
-            workList.add(work);
-        }
-        workerPool.start();
-
-        System.out.println("Starting work!");
-        ArrayList<Work> activeWorkList = new ArrayList<Work>();
-        for (int i = 0; i < 8; ++i) {
-            DummyWork work = workList.get((new Random()).nextInt(workList.size()));
-            work.setWork(1000);
-            work.start();
-            activeWorkList.add(work);
-        }
-        try {
-            Thread.sleep(2000);
-        } catch (InterruptedException e) {}
-        int i = 0;
-        for (Work work : activeWorkList) {
-            if (++i > 5) {
-                break;
-            }
-            work.stop();
-        }
-        try {
-            Thread.sleep(100000);
-        } catch (InterruptedException e) {}
-        System.exit(0);
-    }
-}
+package worker;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import worker.dummy.DummyWork;
+import base.work.Work;
+import base.worker.pool.WorkerPool;
+
+public class TestPooledWork {
+    public static void main(String[] args) {
+        WorkerPool workerPool = new WorkerPool(3);
+
+        List<DummyWork> workList = new ArrayList<DummyWork>();
+        for (int i = 0; i < 10; ++i) {
+            DummyWork work = new DummyWork(workerPool, i + 1);
+            workList.add(work);
+        }
+        workerPool.start();
+
+        System.out.println("Starting work!");
+        ArrayList<Work> activeWorkList = new ArrayList<Work>();
+        for (int i = 0; i < 8; ++i) {
+            DummyWork work = workList.get((new Random()).nextInt(workList.size()));
+            work.setWork(1000);
+            work.start();
+            activeWorkList.add(work);
+        }
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {}
+        int i = 0;
+        for (Work work : activeWorkList) {
+            if (++i > 5) {
+                break;
+            }
+            work.stop();
+        }
+        try {
+            Thread.sleep(100000);
+        } catch (InterruptedException e) {}
+        System.exit(0);
+    }
+}

java/core.legacy/src/test/java/worker/dummy/DummyIntervalWork.java

@@ -1,13 +1,13 @@
-package worker.dummy;
-
-import base.worker.IntervalWork;
-
-public class DummyIntervalWork extends IntervalWork {
-    public DummyIntervalWork(int interval) {
-        super(interval);
-    }
-
-    public void work() {
-        System.out.println(":-)");        
-    }
+package worker.dummy;
+
+import base.worker.IntervalWork;
+
+public class DummyIntervalWork extends IntervalWork {
+    public DummyIntervalWork(int interval) {
+        super(interval);
+    }
+
+    public void work() {
+        System.out.println(":-)");        
+    }
 }

java/core.legacy/src/test/java/worker/dummy/DummyListen.java

@@ -1,26 +1,26 @@
-package worker.dummy;
-
-import base.work.Listen;
-import base.worker.pool.ListenerPool;
-
-public class DummyListen<T> extends Listen<T> {
-    protected int id;
-
-    public DummyListen(ListenerPool<T> listenerPool, int id) {
-        super(listenerPool);
-        this.id = id;
-    }
-
-    public DummyListen(int id) {
-        super();
-        this.id = id;
-    }
-
-    public void input(Integer input) {
-        System.out.println("#" + id + ", input = " + input);
-    }
-
-    public void input(byte[] input) {
-        System.out.println("#" + id + ", input = " + new String(input).trim());
-    }
-}
+package worker.dummy;
+
+import base.work.Listen;
+import base.worker.pool.ListenerPool;
+
+public class DummyListen<T> extends Listen<T> {
+    protected int id;
+
+    public DummyListen(ListenerPool<T> listenerPool, int id) {
+        super(listenerPool);
+        this.id = id;
+    }
+
+    public DummyListen(int id) {
+        super();
+        this.id = id;
+    }
+
+    public void input(Integer input) {
+        System.out.println("#" + id + ", input = " + input);
+    }
+
+    public void input(byte[] input) {
+        System.out.println("#" + id + ", input = " + new String(input).trim());
+    }
+}

java/core.legacy/src/test/java/worker/dummy/DummyWork.java

@@ -1,42 +1,42 @@
-package worker.dummy;
-
-import base.exception.worker.ActivateException;
-import base.exception.worker.DeactivateException;
-import base.work.Work;
-import base.worker.pool.WorkerPool;
-
-public class DummyWork extends Work {
-    protected int id;
-    protected volatile int work;
-
-    public DummyWork(int id) {
-        super();
-        this.id = id;
-    }
-
-    public DummyWork(WorkerPool workerPool, int id) {
-        super(workerPool);
-        this.id = id;
-    }
-
-    public void setWork(int work) {
-        System.out.println("#" + id + ", set work @ " + work);
-        this.work = work;
-    }
-
-    public void work() {
-        System.out.println("#" + id + ", work = " + work);
-        if (--work < 1) {
-            stop();
-        }
-        sleep(300);
-    }
-
-    public void activate() throws ActivateException {
-        System.out.println("#" + id + ", activating...");
-    }
-
-    public void deactivate() throws DeactivateException {
-        System.out.println("#" + id + ", deactivating...");
-    }
-}
+package worker.dummy;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+import base.worker.pool.WorkerPool;
+
+public class DummyWork extends Work {
+    protected int id;
+    protected volatile int work;
+
+    public DummyWork(int id) {
+        super();
+        this.id = id;
+    }
+
+    public DummyWork(WorkerPool workerPool, int id) {
+        super(workerPool);
+        this.id = id;
+    }
+
+    public void setWork(int work) {
+        System.out.println("#" + id + ", set work @ " + work);
+        this.work = work;
+    }
+
+    public void work() {
+        System.out.println("#" + id + ", work = " + work);
+        if (--work < 1) {
+            stop();
+        }
+        sleep(300);
+    }
+
+    public void activate() throws ActivateException {
+        System.out.println("#" + id + ", activating...");
+    }
+
+    public void deactivate() throws DeactivateException {
+        System.out.println("#" + id + ", deactivating...");
+    }
+}

java/exec.connected/.gitignore

@@ -1,6 +0,0 @@
-/.gradle
-/.settings
-/.classpath
-/.project
-/bin
-/build

java/exec.mimis/build.gradle

@@ -1,14 +1,5 @@
-apply plugin: 'java'
-apply plugin: 'maven'
-apply plugin: 'eclipse'
-apply plugin: 'license'
-
-task wrapper(type: Wrapper) {
-	gradleVersion = '2.2'
-}
-
 dependencies {
-	compile project(':base')
+	compile project(':core.legacy')
 
 	compile 'com.github.boukefalos:jlibmimis:0.1'
 	compile 'com.github.boukefalos:jlibitunes:0.3'
@@ -31,19 +22,6 @@ buildscript {
 	}
 }
 
-license {
-	header rootProject.file('HEADER.txt')
-	strictCheck true
-
-	skipExistingHeaders false
-	ext.year = Calendar.getInstance().get(Calendar.YEAR)
-	ext.name = 'Rik Veenboer'
-	ext.email = 'rik.veenboer@gmail.com'
-	ext.project = 'this program'
-	ext.Project = 'This program'
-	include "**/*.java"
-}
-
 jar {
 	from sourceSets.main.allSource
 	manifest {