The TaskManager works partly.

6 files changed, 185 insertions, 43 deletions

diff --git a/sources/events/VSEvent.java b/sources/events/VSEvent.java
index 2223d22..e84e3aa 100644
--- a/sources/events/VSEvent.java
+++ b/sources/events/VSEvent.java
@@ -1,8 +1,49 @@
 package events;
 
 import core.VSProcess;
+import prefs.VSPrefs;
 
-public interface VSEvent {
-    public void init(VSProcess process);
-    public void logg(String message);
+abstract public class VSEvent extends VSPrefs {
+    protected VSPrefs prefs;
+    protected VSProcess process;
+    private String eventClassname;
+
+    public void init(VSProcess process) {
+        this.process = process;
+        this.prefs = process.getPrefs();
+    }
+
+    protected final void setClassname(String eventClassname) {
+        if (eventClassname.startsWith("class "))
+            eventClassname = eventClassname.substring(6);
+
+        this.eventClassname = eventClassname;
+    }
+
+    public final String getClassname() {
+        return eventClassname;
+    }
+
+    public String getName() {
+        return VSRegisteredEvents.getName(eventClassname);
+    }
+
+    public final String getShortname() {
+        return VSRegisteredEvents.getShortname(eventClassname);
+    }
+
+    public final VSProcess getProcess() {
+        return process;
+    }
+
+    public void logg(String message) {
+        process.logg(toString() + "; " + message);
+    }
+
+    public boolean equals(VSEvent event) {
+        return super.getID() == event.getID();
+    }
+
+    abstract protected void onInit();
+    abstract public void onStart();
 }
diff --git a/sources/events/VSProcessEvent.java b/sources/events/VSProcessEvent.java
deleted file mode 100644
index dcffa5e..0000000
--- a/sources/events/VSProcessEvent.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package events;
-
-import core.VSProcess;
-import prefs.VSPrefs;
-
-abstract public class VSProcessEvent implements VSEvent {
-    protected VSProcess process;
-    protected VSPrefs prefs;
-
-    public void init(VSProcess process) {
-        this.process = process;
-        this.prefs = process.getPrefs();
-    }
-
-    public void logg(String message) {
-        process.logg(message);
-    }
-
-    abstract public void onStart();
-}
diff --git a/sources/events/VSRegisteredEvents.java b/sources/events/VSRegisteredEvents.java
index 38676ca..5f73fea 100644
--- a/sources/events/VSRegisteredEvents.java
+++ b/sources/events/VSRegisteredEvents.java
@@ -7,4 +7,114 @@ import core.*;
 import utils.*;
 
 public final class VSRegisteredEvents {
+    private static HashMap<String,String> eventClassnames;
+    private static HashMap<String,String> eventShortnames;
+    private static HashMap<String,String> eventNames;
+    private static VSPrefs prefs;
+
+    public static void init(VSPrefs prefs_) {
+        prefs = prefs_;
+        eventNames = new HashMap<String, String>();
+        eventShortnames = new HashMap<String, String>();
+        eventClassnames = new HashMap<String, String>();
+
+        registerEvent("events.implementations.ProcessCrashEvent", "Prozessabsturz", null);
+        registerEvent("events.implementations.ProcessRecoverEvent", "Prozesswiederbelebung", null);
+        registerEvent("protocols.implementations.BerkelyTimeProtocol", "Berkeley Algorithmus zur internen Sync.", "Berkeley");
+        registerEvent("protocols.implementations.BroadcastSturmProtocol", "Broadcaststurm", null);
+        registerEvent("protocols.implementations.DummyProtocol", "Beispiel/Dummy", null);
+        registerEvent("protocols.implementations.ExternalTimeSyncProtocol", "Christians Methode zur externen Sync.", "Christians");
+        registerEvent("protocols.implementations.InternalTimeSyncProtocol", "Interne Synchronisation", "Interne Sync.");
+        registerEvent("protocols.implementations.PingPongProtocol", "Ping Pong", null);
+    }
+
+    public static Vector<String> getProtocolNames() {
+        Set<String> set =  eventClassnames.keySet();
+        Vector<String> vector = new Vector<String>();
+
+        for (String eventName : set)
+            if (getClassname(eventName).startsWith("protocols"))
+                vector.add(eventName);
+
+        Collections.sort(vector);
+
+        return vector;
+    }
+
+    public static Vector<String> getProtocolClassnames() {
+        Set<String> set =  eventNames.keySet();
+        Vector<String> vector = new Vector<String>();
+
+        for (String eventClassname : set)
+            if (eventClassname.startsWith("protocols"))
+                vector.add(eventClassname);
+
+        Collections.sort(vector);
+
+        return vector;
+    }
+
+    public static Vector<String> getNonProtocolNames() {
+        Set<String> set =  eventClassnames.keySet();
+        Vector<String> vector = new Vector<String>();
+
+        for (String eventName : set)
+            if (!getClassname(eventName).startsWith("protocols"))
+                vector.add(eventName);
+
+        Collections.sort(vector);
+
+        return vector;
+    }
+
+    public static Vector<String> getNonProtocolClassnames() {
+        Set<String> set =  eventNames.keySet();
+        Vector<String> vector = new Vector<String>();
+
+        for (String eventClassname : set)
+            if (!eventClassname.startsWith("protocols"))
+                vector.add(eventClassname);
+
+        Collections.sort(vector);
+
+        return vector;
+    }
+
+    public static String getClassname(String eventName) {
+        return eventClassnames.get(eventName);
+    }
+
+    public static String getName(String eventClassname) {
+        return eventNames.get(eventClassname);
+    }
+
+    public static String getShortname(String eventClassname) {
+        return eventShortnames.get(eventClassname);
+    }
+
+    public static VSEvent createEventInstanceByClassname(String eventClassname, VSProcess process) {
+        return createEventInstanceByName(getName(eventClassname), process);
+    }
+
+    public static VSEvent createEventInstanceByName(String eventName, VSProcess process) {
+        final String eventClassname = eventClassnames.get(eventName);
+        final Object protocolObj = new VSClassLoader().newInstance(eventClassname);
+
+        if (protocolObj instanceof VSEvent) {
+            VSEvent event = (VSEvent) protocolObj;
+            event.init(process);
+            return event;
+        }
+
+        return null;
+    }
+
+    private static void registerEvent(String eventClassname, String eventName, String eventShortname) {
+        if (eventShortname == null)
+            eventShortname = eventName;
+
+        eventNames.put(eventClassname, eventName);
+        eventShortnames.put(eventClassname, eventShortname);
+        eventClassnames.put(eventName, eventClassname);
+    }
 }
diff --git a/sources/events/implementations/ProcessCrashEvent.java b/sources/events/implementations/ProcessCrashEvent.java
index c82fdb4..d675091 100644
--- a/sources/events/implementations/ProcessCrashEvent.java
+++ b/sources/events/implementations/ProcessCrashEvent.java
@@ -1,11 +1,17 @@
 package events.implementations;
 
 import core.VSProcess;
-import events.VSProcessEvent;
+import events.VSEvent;
+
+public class ProcessCrashEvent extends VSEvent {
+    protected void onInit() {
+        setClassname(getClass().toString());
+    }
 
-public class ProcessCrashEvent extends VSProcessEvent {
     public void onStart() {
-        process.isCrashed(true);
-        logg(prefs.getString("lang.crashed"));
+        if (!process.isCrashed()) {
+            process.isCrashed(true);
+            logg(prefs.getString("lang.crashed"));
+        }
     }
 }
diff --git a/sources/events/implementations/ProcessRecoverEvent.java b/sources/events/implementations/ProcessRecoverEvent.java
index f0b54d4..231847c 100644
--- a/sources/events/implementations/ProcessRecoverEvent.java
+++ b/sources/events/implementations/ProcessRecoverEvent.java
@@ -1,11 +1,17 @@
 package events.implementations;
 
 import core.VSProcess;
-import events.VSProcessEvent;
+import events.VSEvent;
+
+public class ProcessRecoverEvent extends VSEvent {
+    protected void onInit() {
+        setClassname(getClass().toString());
+    }
 
-public class ProcessRecoverEvent extends VSProcessEvent {
     public void onStart() {
-        process.isCrashed(false);
-        logg(prefs.getString("lang.recovered"));
+        if (process.isCrashed()) {
+            process.isCrashed(false);
+            logg(prefs.getString("lang.recovered"));
+        }
     }
 }
diff --git a/sources/events/implementations/ProtocolEvent.java b/sources/events/implementations/ProtocolEvent.java
index 442407d..096e9b6 100644
--- a/sources/events/implementations/ProtocolEvent.java
+++ b/sources/events/implementations/ProtocolEvent.java
@@ -1,20 +1,15 @@
 package events.implementations;
 
 import core.VSProcess;
-import events.VSProcessEvent;
-import protocols.VSRegisteredProtocols;
+import events.*;
 
-public class ProtocolEvent extends VSProcessEvent {
-    private String protocolClassname;
+public class ProtocolEvent extends VSEvent {
+    private String eventClassname;
     private boolean isClientProtocol; /* true = client, false = server */
     private boolean isProtocolActivation; /* true = activate, false = deactivate */
 
-    public void setProtocolClassname(String protocolClassname) {
-        this.protocolClassname = protocolClassname;
-    }
-
-    public String getProtocolClassname() {
-        return protocolClassname;
+    protected void onInit() {
+        setClassname(getClass().toString());
     }
 
     public void isClientProtocol(boolean isClientProtocol) {
@@ -33,13 +28,17 @@ public class ProtocolEvent extends VSProcessEvent {
         return isProtocolActivation;
     }
 
+    public void setEventClassname(String eventClassname) {
+        this.eventClassname = eventClassname;
+    }
+
     public void onStart() {
         String type = isClientProtocol ? "client" : "server";
-        String name = VSRegisteredProtocols.getProtocolName(protocolClassname);
+        String name = VSRegisteredEvents.getName(eventClassname);
         process.setBoolean("sim."+name.toLowerCase()+"."+type+".enabled!", isProtocolActivation);
 
         StringBuffer buffer = new StringBuffer();
-        buffer.append(VSRegisteredProtocols.getProtocolShortname(protocolClassname));
+        buffer.append(VSRegisteredEvents.getShortname(eventClassname));
         buffer.append(" ");
         buffer.append(isClientProtocol
                       ? prefs.getString("lang.client") : prefs.getString("lang.server"));