Complete implementation of timestamp event classes

- Add language strings for all timestamp events and demo protocol in VSDefaultPrefs
- Register new timestamp events and protocol in VSRegisteredEvents:
  - VSLamportTimestampEvent
  - VSVectorTimestampEvent
  - VSTimestampMonitorEvent
  - VSTimestampTriggeredEvent
  - VSTimestampDemoProtocol
- Integrate VSVectorClockMonitor into VSInternalProcess:
  - Add vectorClockMonitor field
  - Override increaseVectorTime() and updateVectorTime() to trigger monitor
  - Clear monitor events on reset
  - Add getVectorClockMonitor() accessor
- Add serialization support to VSTimestampTriggeredEvent for persistence
- Fix VSTimestampDemoProtocol to use process's vector clock monitor
- All 132 unit tests pass

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

5 files changed, 121 insertions, 9 deletions

diff --git a/src/main/java/core/VSInternalProcess.java b/src/main/java/core/VSInternalProcess.java
index 8116471..5442cd1 100644
--- a/src/main/java/core/VSInternalProcess.java
+++ b/src/main/java/core/VSInternalProcess.java
@@ -6,6 +6,7 @@ import core.time.VSVectorTime;
 import events.VSAbstractEvent;
 import events.VSRegisteredEvents;
 import events.implementations.VSProcessCrashEvent;
+import events.implementations.VSVectorClockMonitor;
 import prefs.VSPrefs;
 import protocols.VSAbstractProtocol;
 import simulator.VSLogging;
@@ -19,6 +20,9 @@ import utils.VSPriorityQueue;
  * @author Paul C. Buetow
  */
 public class VSInternalProcess extends VSAbstractProcess {
+    /** The vector clock monitor for timestamp-triggered events */
+    private VSVectorClockMonitor vectorClockMonitor;
+    
     /**
      * Instantiates a new process.
      *
@@ -31,6 +35,7 @@ public class VSInternalProcess extends VSAbstractProcess {
                              VSSimulatorVisualization simulatorVisualization,
                              VSLogging loging) {
         super(prefs, processNum, simulatorVisualization, loging);
+        vectorClockMonitor = new VSVectorClockMonitor(this);
     }
 
     /**
@@ -116,6 +121,11 @@ public class VSInternalProcess extends VSAbstractProcess {
 
         setCurrentColor(getColor("col.process.default"));
         resetTimeFormats();
+        
+        // Clear any vector clock monitor events
+        if (vectorClockMonitor != null) {
+            vectorClockMonitor.clearVectorEvents();
+        }
     }
 
     /**
@@ -432,4 +442,33 @@ public class VSInternalProcess extends VSAbstractProcess {
     protected VSAbstractProtocol getProtocolObject_(String protocolClassname) {
         return getProtocolObject(protocolClassname);
     }
+    
+    /**
+     * Override to trigger vector clock monitor when vector time is increased
+     */
+    @Override
+    public synchronized void increaseVectorTime() {
+        super.increaseVectorTime();
+        if (vectorClockMonitor != null) {
+            vectorClockMonitor.checkVectorEvents();
+        }
+    }
+    
+    /**
+     * Override to trigger vector clock monitor when vector time is updated
+     */
+    @Override
+    public synchronized void updateVectorTime(VSVectorTime vectorTimeUpdate) {
+        super.updateVectorTime(vectorTimeUpdate);
+        if (vectorClockMonitor != null) {
+            vectorClockMonitor.checkVectorEvents();
+        }
+    }
+    
+    /**
+     * Get the vector clock monitor for adding timestamp events
+     */
+    public VSVectorClockMonitor getVectorClockMonitor() {
+        return vectorClockMonitor;
+    }
 }
diff --git a/src/main/java/events/VSRegisteredEvents.java b/src/main/java/events/VSRegisteredEvents.java
index 6d50ae5..d2cc758 100644
--- a/src/main/java/events/VSRegisteredEvents.java
+++ b/src/main/java/events/VSRegisteredEvents.java
@@ -60,6 +60,10 @@ public final class VSRegisteredEvents {
         prefs = prefs_;
         registerEvent("events.implementations.VSProcessCrashEvent");
         registerEvent("events.implementations.VSProcessRecoverEvent");
+        registerEvent("events.implementations.VSLamportTimestampEvent");
+        registerEvent("events.implementations.VSVectorTimestampEvent");
+        registerEvent("events.implementations.VSTimestampMonitorEvent");
+        registerEvent("events.implementations.VSTimestampTriggeredEvent");
         registerEvent("protocols.implementations.VSBasicMulticastProtocol");
         registerEvent("protocols.implementations.VSBerkelyTimeProtocol");
         registerEvent("protocols.implementations.VSBroadcastProtocol");
@@ -70,6 +74,7 @@ public final class VSRegisteredEvents {
         registerEvent("protocols.implementations.VSPingPongProtocol");
         registerEvent("protocols.implementations.VSReliableMulticastProtocol");
         registerEvent("protocols.implementations.VSTwoPhaseCommitProtocol");
+        registerEvent("protocols.implementations.VSTimestampDemoProtocol");
 
         /* Make dummy objects of each protocol, to see if they contain VSPrefs
            values to edit */
diff --git a/src/main/java/events/implementations/VSTimestampTriggeredEvent.java b/src/main/java/events/implementations/VSTimestampTriggeredEvent.java
index 16d552d..ef99104 100644
--- a/src/main/java/events/implementations/VSTimestampTriggeredEvent.java
+++ b/src/main/java/events/implementations/VSTimestampTriggeredEvent.java
@@ -1,10 +1,15 @@
 package events.implementations;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
 import core.VSInternalProcess;
 import core.time.VSLamportTime;
 import core.time.VSVectorTime;
 import events.VSAbstractEvent;
 import events.VSCopyableEvent;
+import serialize.VSSerialize;
 
 /**
  * Abstract base class for timestamp-triggered events that fire when specific
@@ -261,4 +266,59 @@ public abstract class VSTimestampTriggeredEvent extends VSAbstractEvent implemen
     public void reset() {
         hasTriggered = false;
     }
+    
+    @Override
+    public synchronized void serialize(VSSerialize serialize,
+                                     ObjectOutputStream objectOutputStream)
+    throws IOException {
+        super.serialize(serialize, objectOutputStream);
+        
+        if (VSSerialize.DEBUG)
+            System.out.println("Serializing: VSTimestampTriggeredEvent; id="+getID());
+        
+        /** For later backwards compatibility, to add more stuff */
+        objectOutputStream.writeObject(Boolean.valueOf(false));
+        
+        objectOutputStream.writeObject(timestampType);
+        objectOutputStream.writeObject(operator);
+        objectOutputStream.writeObject(Long.valueOf(targetLamportTime));
+        objectOutputStream.writeObject(Boolean.valueOf(hasTriggered));
+        
+        // Serialize vector time if present
+        boolean hasVectorTime = (targetVectorTime != null);
+        objectOutputStream.writeObject(Boolean.valueOf(hasVectorTime));
+        if (hasVectorTime) {
+            objectOutputStream.writeObject(targetVectorTime);
+        }
+        
+        /** For later backwards compatibility, to add more stuff */
+        objectOutputStream.writeObject(Boolean.valueOf(false));
+    }
+    
+    @Override
+    public synchronized void deserialize(VSSerialize serialize,
+                                       ObjectInputStream objectInputStream)
+    throws IOException, ClassNotFoundException {
+        super.deserialize(serialize, objectInputStream);
+        
+        if (VSSerialize.DEBUG)
+            System.out.print("Deserializing: VSTimestampTriggeredEvent ");
+        
+        /** For later backwards compatibility, to add more stuff */
+        objectInputStream.readObject();
+        
+        timestampType = (TimestampType) objectInputStream.readObject();
+        operator = (ComparisonOperator) objectInputStream.readObject();
+        targetLamportTime = ((Long) objectInputStream.readObject()).longValue();
+        hasTriggered = ((Boolean) objectInputStream.readObject()).booleanValue();
+        
+        // Deserialize vector time if present
+        boolean hasVectorTime = ((Boolean) objectInputStream.readObject()).booleanValue();
+        if (hasVectorTime) {
+            targetVectorTime = (VSVectorTime) objectInputStream.readObject();
+        }
+        
+        /** For later backwards compatibility, to add more stuff */
+        objectInputStream.readObject();
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/prefs/VSDefaultPrefs.java b/src/main/java/prefs/VSDefaultPrefs.java
index 9a5d966..b8d9bd4 100644
--- a/src/main/java/prefs/VSDefaultPrefs.java
+++ b/src/main/java/prefs/VSDefaultPrefs.java
@@ -179,6 +179,18 @@ public class VSDefaultPrefs extends VSSerializablePrefs {
         initString("lang.protocols.implementations.VSReliableMulticastProtocol.short", "Reliable Multicast");
         initString("lang.protocols.implementations.VSTwoPhaseCommitProtocol", "Two-Phase Commit");
         initString("lang.protocols.implementations.VSTwoPhaseCommitProtocol.short", "2-Phase Commit");
+        
+        /* Timestamp event names */
+        initString("lang.events.implementations.VSLamportTimestampEvent", "Lamport Timestamp Event");
+        initString("lang.events.implementations.VSLamportTimestampEvent.short", "Lamport Trigger");
+        initString("lang.events.implementations.VSVectorTimestampEvent", "Vector Timestamp Event");
+        initString("lang.events.implementations.VSVectorTimestampEvent.short", "Vector Trigger");
+        initString("lang.events.implementations.VSTimestampMonitorEvent", "Timestamp Monitor Event");
+        initString("lang.events.implementations.VSTimestampMonitorEvent.short", "Timestamp Monitor");
+        initString("lang.events.implementations.VSTimestampTriggeredEvent", "Timestamp Triggered Event");
+        initString("lang.events.implementations.VSTimestampTriggeredEvent.short", "Timestamp Trigger");
+        initString("lang.protocols.implementations.VSTimestampDemoProtocol", "Timestamp Demo Protocol");
+        initString("lang.protocols.implementations.VSTimestampDemoProtocol.short", "Timestamp Demo");
     }
 
     /**
diff --git a/src/main/java/protocols/implementations/VSTimestampDemoProtocol.java b/src/main/java/protocols/implementations/VSTimestampDemoProtocol.java
index 70f252c..b3e9945 100644
--- a/src/main/java/protocols/implementations/VSTimestampDemoProtocol.java
+++ b/src/main/java/protocols/implementations/VSTimestampDemoProtocol.java
@@ -9,7 +9,6 @@ import events.implementations.VSLamportTimestampEvent;
 import events.implementations.VSTimestampMonitorEvent;
 import events.implementations.VSTimestampTriggeredEvent;
 import events.implementations.VSVectorTimestampEvent;
-import events.implementations.VSVectorClockMonitor;
 import protocols.VSAbstractProtocol;
 
 /**
@@ -30,7 +29,6 @@ public class VSTimestampDemoProtocol extends VSAbstractProtocol {
     }
     
     private VSTimestampMonitorEvent lamportMonitor;
-    private VSVectorClockMonitor vectorMonitor;
     
     @Override
     public void onServerInit() {
@@ -80,8 +78,6 @@ public class VSTimestampDemoProtocol extends VSAbstractProtocol {
         lamportMonitor = new VSTimestampMonitorEvent(1); // Check every time unit
         lamportMonitor.init(internalProcess);
         
-        vectorMonitor = new VSVectorClockMonitor(internalProcess);
-        
         // Set up Lamport timestamp event
         setupLamportEvent();
         
@@ -155,7 +151,7 @@ public class VSTimestampDemoProtocol extends VSAbstractProtocol {
             }
         );
         
-        vectorMonitor.addVectorEvent(vectorEvent);
+        ((VSInternalProcess) process).getVectorClockMonitor().addVectorEvent(vectorEvent);
     }
     
     @Override
@@ -184,8 +180,8 @@ public class VSTimestampDemoProtocol extends VSAbstractProtocol {
         if (lamportMonitor != null) {
             lamportMonitor.stopMonitoring();
         }
-        if (vectorMonitor != null) {
-            vectorMonitor.clearVectorEvents();
+        if (process instanceof VSInternalProcess) {
+            ((VSInternalProcess) process).getVectorClockMonitor().clearVectorEvents();
         }
     }
     
@@ -194,8 +190,8 @@ public class VSTimestampDemoProtocol extends VSAbstractProtocol {
         if (lamportMonitor != null) {
             lamportMonitor.stopMonitoring();
         }
-        if (vectorMonitor != null) {
-            vectorMonitor.clearVectorEvents();
+        if (process instanceof VSInternalProcess) {
+            ((VSInternalProcess) process).getVectorClockMonitor().clearVectorEvents();
         }
     }