JAutoDoc :)

1 files changed, 338 insertions, 5 deletions

diff --git a/sources/core/VSProcess.java b/sources/core/VSProcess.java
index 3773bd6..e4c7561 100644
--- a/sources/core/VSProcess.java
+++ b/sources/core/VSProcess.java
@@ -1,3 +1,7 @@
+/*
+ * VS is (c) 2008 by Paul C. Buetow
+ * vs@dev.buetow.org
+ */
 package core;
 
 import java.awt.*;
@@ -11,39 +15,97 @@ import protocols.*;
 import simulator.*;
 import utils.*;
 
+/**
+ * The Class VSProcess. A object of this class represents a process of a simulation.
+ */
 public class VSProcess extends VSPrefs {
+    
+    /** The protocols to reset if the simulation is over or the reset button has been pressed. */
     private ArrayList<VSProtocol> protocolsToReset;
+    
+    /** The crash history. represents all crashes of the process using the global simulation time. */
     private ArrayList<Long> crashHistory;
+    
+    /** The lamport time history. */
     private ArrayList<VSLamportTime> lamportTimeHistory;
+    
+    /** The vector time history. */
     private ArrayList<VSVectorTime> vectorTimeHistory;
+    
+    /** The crashed color. */
     private Color crashedColor;;
+    
+    /** The current color. */
     private Color currentColor;
+    
+    /** The tmp color. For internal usage. */
     private Color tmpColor;
+    
+    /** The logging object. */
     private VSLogging logging;
+    
+    /** The simulation's default prefs. */
     private VSPrefs prefs;
+    
+    /** The random generator of the process. */
     private VSRandom random;
+    
+    /** The simulation canvas. */
     private VSSimulatorCanvas simulationCanvas;
+    
+    /** The random crash task. May be null if there is no such random task. */
     private VSTask randomCrashTask;
+    
+    /** The vector time. */
     private VSVectorTime vectorTime;
+    
+    /** The process has crashed. But may be working again. */
     private boolean hasCrashed;
+    
+    /** The process has started. But may be paused or crashed.. */
     private boolean hasStarted;
+    
+    /** The process is crashed. */
     private boolean isCrashed;
+    
+    /** The process is highlighted. */
     private boolean isHighlighted;
+    
+    /** The process is paused. */
     private boolean isPaused;
+    
+    /** The time has been modified in a task. Needed by the task manager to calculate correct offsets. */
     private boolean timeModified;
+    
+    /** The clock offset. Used by the task manager and also by the process' clock variance. */
     private double clockOffset;
+    
+    /** The clock variance. */
     private float clockVariance;
+    
+    /** The process id. */
     private int processID; // Represents the PID of a process
+    
+    /** The process num. It is different to the process id. It represents the array index of the process. */
     private int processNum; // Represents the array index of the process, for internal usage
+    
+    /** The global time. */
     private long globalTime;
+    
+    /** The lamport time. */
     private long lamportTime;
+    
+    /** The local time. */
     private long localTime;
+    
+    /** The process counter. Needed for the unique process id's. */
     private static int processCounter;
 
     /* This array contains all Integer prefs of the process which should show
      * up in the prefs menu! All keys which dont start with "sim." only show
      * up in the extended prefs menu!
      */
+    /** The Constant DEFAULT_INTEGER_VALUE_KEYS. */
     private static final String DEFAULT_INTEGER_VALUE_KEYS[] = {
         "process.prob.crash",
         "message.prob.outage",
@@ -53,12 +115,14 @@ public class VSProcess extends VSPrefs {
      * up in the prefs menu! All keys which dont start with "sim." only show
      * up in the extended prefs menu!
      */
+    /** The Constant DEFAULT_LONG_VALUE_KEYS. */
     private static final String DEFAULT_LONG_VALUE_KEYS[] = {
         "message.sendingtime.min",
         "message.sendingtime.max",
     };
 
-    /* This array contains all Float prefs of the process which should show
+    /** The Constant DEFAULT_FLOAT_VALUE_KEYS. */
+    /** This array contains all Float prefs of the process which should show
      * up in the prefs menu! All keys which dont start with "sim." only show
      * up in the extended prefs menu!
      */
@@ -66,7 +130,8 @@ public class VSProcess extends VSPrefs {
         "process.clock.variance",
     };
 
-    /* This array contains all Color prefs of the process which should show
+    /** The Constant DEFAULT_COLOR_VALUE_KEYS. */
+    /** This array contains all Color prefs of the process which should show
      * up in the prefs menu! All keys which dont start with "sim." only show
      * up in the extended prefs menu!
      */
@@ -78,13 +143,22 @@ public class VSProcess extends VSPrefs {
         "col.process.crashed",
     };
 
-    /* This array contains all String prefs of the process which should show
+    /** The Constant DEFAULT_STRING_VALUE_KEYS. */
+    /** This array contains all String prefs of the process which should show
      * up in the prefs menu! All keys which dont start with "sim." only show
      * up in the extended prefs menu!
      */
     private static final String DEFAULT_STRING_VALUE_KEYS[] = {
     };
 
+    /**
+     * Instantiates a new process.
+     * 
+     * @param prefs the simulation's default prefs
+     * @param processNum the process num
+     * @param simulationCanvas the simulation canvas
+     * @param logging the logging object
+     */
     public VSProcess(VSPrefs prefs, int processNum, VSSimulatorCanvas simulationCanvas, VSLogging logging) {
         this.protocolsToReset = new ArrayList<VSProtocol>();
         this.processNum = processNum;
@@ -112,6 +186,9 @@ public class VSProcess extends VSPrefs {
         createRandomCrashTask();
     }
 
+    /**
+     * Inits the time formats.
+     */
     private void initTimeFormats() {
         lamportTime = 0;
         lamportTimeHistory = new ArrayList<VSLamportTime>();
@@ -125,6 +202,9 @@ public class VSProcess extends VSPrefs {
             vectorTime.add(new Long(0));
     }
 
+    /**
+     * Reset time formats.
+     */
     private void resetTimeFormats() {
         lamportTime = 0;
         lamportTimeHistory.clear();
@@ -140,7 +220,7 @@ public class VSProcess extends VSPrefs {
 
 
     /**
-     * Called from the VSProcessEditor, after finishing editing!
+     * Called from the VSProcessEditor, after finishing editing!.
      */
     public synchronized void updateFromVSPrefs() {
         setClockVariance(getFloat("process.clock.variance"));
@@ -151,13 +231,18 @@ public class VSProcess extends VSPrefs {
     }
 
     /**
-     * Called from the VSProcessEditor, before starting editing!
+     * Called from the VSProcessEditor, before starting editing!.
      */
     public synchronized void updatePrefs() {
         setFloat("process.clock.variance", getClockVariance());
         setLong("process.localtime", getTime());
     }
 
+    /**
+     * Sync time. Using the clockOffset and clockVariance.
+     * 
+     * @param globalTime the global time
+     */
     public synchronized void syncTime(final long globalTime) {
         final long currentGlobalTimestep = globalTime - this.globalTime;
         this.globalTime = globalTime;
@@ -179,6 +264,11 @@ public class VSProcess extends VSPrefs {
             localTime = 0;
     }
 
+    /**
+     * Sets the current color.
+     * 
+     * @param newColor the new current color
+     */
     private void setCurrentColor(Color newColor) {
         if (isHighlighted)
             tmpColor = newColor;
@@ -186,17 +276,26 @@ public class VSProcess extends VSPrefs {
             currentColor = newColor;
     }
 
+    /**
+     * Highlights the process.
+     */
     public synchronized void highlightOn() {
         tmpColor = currentColor;
         currentColor = getColor("col.process.highlight");
         isHighlighted = true;
     }
 
+    /**
+     * Unhighlights the process.
+     */
     public synchronized void highlightOff() {
         currentColor = tmpColor;
         isHighlighted = false;
     }
 
+    /**
+     * Resets the process.
+     */
     public synchronized void reset() {
         isPaused = true;
         isCrashed = false;
@@ -212,6 +311,9 @@ public class VSProcess extends VSPrefs {
         resetTimeFormats();
     }
 
+    /**
+     * Creates the random crash task.
+     */
     public void createRandomCrashTask() {
         if (!isCrashed) {
             VSTaskManager taskManager = simulationCanvas.getTaskManager();
@@ -236,41 +338,80 @@ public class VSProcess extends VSPrefs {
         }
     }
 
+    /**
+     * Adds the clock offset. This method is used by the task manager.
+     * 
+     * @param add the clock offset to add.
+     */
     public synchronized void addClockOffset(long add) {
         this.clockOffset += add;
     }
 
+    /**
+     * Play. Called by the simulation canvas.
+     */
     public synchronized void play() {
         isPaused = false;
         setCurrentColor(getColor("col.process.running"));
     }
 
+    /**
+     * Pause. Called by the simulation canvas.
+     */
     public synchronized void pause() {
         isPaused = true;
         setCurrentColor(getColor("col.process.stopped"));
     }
 
+    /**
+     * Finish. Called by the simulation canvas.
+     */
     public synchronized void finish() {
         isPaused = true;
         setCurrentColor(getColor("col.process.default"));
     }
 
+    /**
+     * Gets the process id.
+     * 
+     * @return the process id
+     */
     public synchronized int getProcessID() {
         return processID;
     }
 
+    /**
+     * Gets the process num.
+     * 
+     * @return the process num
+     */
     public synchronized int getProcessNum() {
         return processNum;
     }
 
+    /**
+     * Sets the process id.
+     * 
+     * @param processID the new process id
+     */
     public synchronized void setProcessID(int processID) {
         this.processID = processID;
     }
 
+    /**
+     * Gets the current process' color.
+     * 
+     * @return the current color of the process.
+     */
     public synchronized Color getColor() {
         return currentColor;
     }
 
+    /**
+     * Sets the local time.
+     * 
+     * @param localTime the new local time.
+     */
     public synchronized void setLocalTime(final long localTime) {
         if (localTime >= 0)
             this.localTime = localTime;
@@ -278,10 +419,20 @@ public class VSProcess extends VSPrefs {
             this.localTime = 0;
     }
 
+    /**
+     * Gets the process' local time.
+     * 
+     * @return the process' local time
+     */
     public synchronized long getTime() {
         return localTime;
     }
 
+    /**
+     * Sets the process' local time.
+     * 
+     * @param time the new local time of the process.
+     */
     public synchronized void setTime(final long time) {
         if (time >= 0)
             this.localTime = time;
@@ -291,10 +442,20 @@ public class VSProcess extends VSPrefs {
         this.timeModified = true;
     }
 
+    /**
+     * Checks if the process is crashed.
+     * 
+     * @return true, if is crashed
+     */
     public synchronized boolean isCrashed() {
         return isCrashed;
     }
 
+    /**
+     * Sets if the process is crashed. 
+     * 
+     * @param isCrashed true if the process is crashed.
+     */
     public synchronized void isCrashed(boolean isCrashed) {
         this.isCrashed = isCrashed;
         crashHistory.add(new Long(globalTime));
@@ -302,34 +463,76 @@ public class VSProcess extends VSPrefs {
             hasCrashed = true;
     }
 
+    /**
+     * Checks if the process has crashed at least once during the current
+     * simulation.
+     * 
+     * @return true, if yes
+     */
     public synchronized boolean hasCrashed() {
         return hasCrashed;
     }
 
+    /**
+     * Gets the crashed color.
+     * 
+     * @return the crashed color
+     */
     public synchronized Color getCrashedColor() {
         return crashedColor;
     }
 
+    /**
+     * Checks if the time has been modified. by a task. 
+     * This mehod is needed by the task manager.
+     * 
+     * @return true, if yes
+     */
     public synchronized boolean timeModified() {
         return timeModified;
     }
 
+    /**
+     * Sets if the time has been modified by a task.
+     * 
+     * @param timeModified true, if it has been modified.
+     */
     public synchronized void timeModified(boolean timeModified) {
         this.timeModified = timeModified;
     }
 
+    /**
+     * Gets the global time.
+     * 
+     * @return the global time
+     */
     public synchronized long getGlobalTime() {
         return globalTime;
     }
 
+    /**
+     * Sets the global time.
+     * 
+     * @param globalTime the new global time
+     */
     public synchronized void setGlobalTime(final long globalTime) {
         this.globalTime = globalTime >= 0 ? globalTime : 0;
     }
 
+    /**
+     * Gets the clock variance.
+     * 
+     * @return the clock variance
+     */
     public synchronized float getClockVariance() {
         return clockVariance;
     }
 
+    /**
+     * Sets the clock variance.
+     * 
+     * @param clockVariance the new clock variance
+     */
     public synchronized void setClockVariance(float clockVariance) {
         /* If negative, only allow < 1 prefs */
         if (clockVariance < 0) {
@@ -343,6 +546,11 @@ public class VSProcess extends VSPrefs {
         this.clockVariance = clockVariance;
     }
 
+    /**
+     * Gets the duration time.
+     * 
+     * @return the duration time
+     */
     public synchronized long getDurationTime() {
         final long maxDurationTime = getLong("message.sendingtime.max");
         final long minDurationTime = getLong("message.sendingtime.min");
@@ -359,6 +567,13 @@ public class VSProcess extends VSPrefs {
         return minDurationTime + random.nextInt(diff+1);
     }
 
+    /**
+     * Gets the a random message outage time.
+     * 
+     * @param durationTime the duration time
+     * 
+     * @return the a random message outage time
+     */
     public synchronized long getARandomMessageOutageTime(final long durationTime) {
         /* Check if the message will have an outage or not */
         if (random.nextInt(100) < getInteger("message.prob.outage")) {
@@ -371,6 +586,11 @@ public class VSProcess extends VSPrefs {
         return -1;
     }
 
+    /**
+     * Gets the a random crash time.
+     * 
+     * @return the a random crash time
+     */
     private long getARandomCrashTime() {
         /* Check if the process will crash or not */
         if (random.nextInt(100) <= getInteger("process.prob.crash")) {
@@ -383,18 +603,36 @@ public class VSProcess extends VSPrefs {
         return -1;
     }
 
+    /**
+     * Gets the random crash task.
+     * 
+     * @return the random crash task
+     */
     public synchronized VSTask getCrashTask() {
         return randomCrashTask;
     }
 
+    /**
+     * Checks if is paused.
+     * 
+     * @return true, if is paused
+     */
     public synchronized boolean isPaused() {
         return isPaused;
     }
 
+    /**
+     * Increases the lamport time.
+     */
     public void increaseLamportTime() {
         setLamportTime(getLamportTime()+1);
     }
 
+    /**
+     * Updates the lamport time.
+     * 
+     * @param time the lamport time
+     */
     public void updateLamportTime(long time) {
         final long lamportTime = getLamportTime() + 1;
 
@@ -404,15 +642,30 @@ public class VSProcess extends VSPrefs {
             setLamportTime(lamportTime);
     }
 
+    /**
+     * Gets the lamport time.
+     * 
+     * @return the lamport time.
+     */
     public synchronized long getLamportTime() {
         return lamportTime;
     }
 
+    /**
+     * Sets the lamport time.
+     * 
+     * @param lamportTime the new lamport time
+     */
     public synchronized void setLamportTime(long lamportTime) {
         this.lamportTime = lamportTime;
         lamportTimeHistory.add(new VSLamportTime(globalTime, lamportTime));
     }
 
+    /**
+     * Gets the lamport time history as an array.
+     * 
+     * @return the lamport time history array
+     */
     public synchronized VSTime[] getLamportTimeArray() {
         final int size = lamportTimeHistory.size();
         final VSTime[] arr = new VSLamportTime[size];
@@ -423,12 +676,20 @@ public class VSProcess extends VSPrefs {
         return arr;
     }
 
+    /**
+     * Increases the vector time.
+     */
     public synchronized void increaseVectorTime() {
         vectorTime.set(processNum, new Long(vectorTime.get(processNum).longValue()+1));
         vectorTime.setGlobalTime(globalTime);
         vectorTimeHistory.add(vectorTime.getCopy());
     }
 
+    /**
+     * Updates the vector time.
+     * 
+     * @param vectorTimeUpdate the vector time of the other process to use for the update
+     */
     public synchronized void updateVectorTime(VSVectorTime vectorTimeUpdate) {
         final int size = vectorTime.size();
 
@@ -443,10 +704,20 @@ public class VSProcess extends VSPrefs {
         vectorTimeHistory.add(vectorTime.getCopy());
     }
 
+    /**
+     * Gets the vector time.
+     * 
+     * @return the vector time
+     */
     public synchronized VSVectorTime getVectorTime() {
         return vectorTime;
     }
 
+    /**
+     * Gets the vector time history as an array.
+     * 
+     * @return the vector time history array
+     */
     public synchronized VSTime[] getVectorTimeArray() {
         final int size = vectorTimeHistory.size();
         final VSTime[] arr = new VSTime[size];
@@ -457,6 +728,11 @@ public class VSProcess extends VSPrefs {
         return arr;
     }
 
+    /**
+     * Gets the crash history array.
+     * 
+     * @return the crash history array
+     */
     public synchronized Long[] getCrashHistoryArray() {
         final int size = crashHistory.size();
         final Long[] arr = new Long[size];
@@ -467,6 +743,11 @@ public class VSProcess extends VSPrefs {
         return arr;
     }
 
+    /**
+     * Called by a task if the process sends a message.
+     * 
+     * @param message the message to send.
+     */
     public void sendMessage(VSMessage message) {
         StringBuffer buffer = new StringBuffer();
         buffer.append(prefs.getString("lang.message.sent"));
@@ -476,10 +757,18 @@ public class VSProcess extends VSPrefs {
         simulationCanvas.sendMessage(message);
     }
 
+    /**
+     * Logg a message to the logging area.
+     * 
+     * @param message the message to logg
+     */
     public void logg(String message) {
         logging.logg(toString() + "; " + message, globalTime);
     }
 
+    /* (non-Javadoc)
+     * @see prefs.VSPrefs#fillWithDefaults()
+     */
     public void fillWithDefaults() {
         prefs.copyIntegers(this, DEFAULT_INTEGER_VALUE_KEYS);
         prefs.copyLongs(this, DEFAULT_LONG_VALUE_KEYS);
@@ -488,6 +777,9 @@ public class VSProcess extends VSPrefs {
         prefs.copyStrings(this, DEFAULT_STRING_VALUE_KEYS);
     }
 
+    /* (non-Javadoc)
+     * @see prefs.VSPrefs#toString()
+     */
     public String toString() {
         StringBuffer buffer = new StringBuffer();
         buffer.append(prefs.getString("lang.process.id"));
@@ -508,6 +800,11 @@ public class VSProcess extends VSPrefs {
         return buffer.toString();
     }
 
+    /**
+     * The extended string representation of the process object.
+     * 
+     * @return the extended string representation
+     */
     public String toStringFull() {
         StringBuffer buffer = new StringBuffer();
         buffer.append(toString());
@@ -520,22 +817,48 @@ public class VSProcess extends VSPrefs {
         return buffer.toString();
     }
 
+    /**
+     * Equals. Checks, if both processes have the same process id.
+     * 
+     * @param process the process to compare to
+     * 
+     * @return true, if both processes are the same.
+     */
     public boolean equals(VSProcess process) {
         return process.getProcessID() == processID;
     }
 
+    /**
+     * Gets the simulation canvas.
+     * 
+     * @return the simulation canvas
+     */
     public VSSimulatorCanvas getSimulationCanvas() {
         return simulationCanvas;
     }
 
+    /**
+     * Gets the simulation's default prefs.
+     * 
+     * @return the default prefs
+     */
     public VSPrefs getPrefs() {
         return prefs;
     }
 
+    /**
+     * Resets the process counter.
+     */
     public static void resetProcessCounter() {
         processCounter = 0;
     }
 
+    /**
+     * Removes the process at the specified index.
+     * Needed in order to update the vector time and the local processNum.
+     * 
+     * @param index the index the process has to get removed.
+     */
     public void removeProcessAtIndex(int index) {
         if (index < processNum)
             --processNum;
@@ -545,12 +868,22 @@ public class VSProcess extends VSPrefs {
             vectorTime.remove(index);
     }
 
+    /**
+     * Added a process. Needed in order to update the vector time's size.
+     */
     public void addedAProcess() {
         vectorTime.add(new Long(0));
         for (VSVectorTime vectorTime : vectorTimeHistory)
             vectorTime.add(new Long(0));
     }
 
+    /**
+     * Gets the protocol object.
+     * 
+     * @param protocolClassname the protocol classname
+     * 
+     * @return the protocol object
+     */
     public VSProtocol getProtocolObject(String protocolClassname) {
         VSProtocol protocol = null;