Changeset 78b9d9 for molecuilder/src/Actions

Timestamp:

Mar 3, 2010, 1:57:41 PM (16 years ago)

Author:

Tillmann Crueger <crueger@…>

Children:

14d898

Parents:

dc5413

Message:

Improved Doxygen documentation

Location:

molecuilder/src/Actions

Files:

• Calculation.hpp (modified) (2 diffs)
• Process.cpp (modified) (2 diffs)
• Process.hpp (modified) (1 diff)

molecuilder/src/Actions/Calculation.hpp

@@ -11 +11 @@
 #include "Actions/Process.hpp"
 
+/**
+ * A calculation is a Process that has some kind of result.
+ *
+ * This class can be used in the same way as any other Action or Process, but has some special methods
+ * for inspecting the result of the calculation.
+ */
 template<typename T>
 class Calculation : public Process
@@ -18 +24 @@
   virtual ~Calculation();
 
+  /**
+   * Reimplemented call method for Action Base class.
+   * Resets the result and then redoes the calculation. Can be used to retrigger calculations
+   * from menu Items or other places.
+   */
   virtual void call();
   virtual void undo();
   virtual bool canUndo();
 
+  /**
+   * Does the actual calculation and returns the result.
+   * When the calculation has been done before it is not redone, but the previous cached result is returned.
+   * Call reset to delete the cached value.
+   */
   virtual T operator()();
+
+  /**
+   * Check if a cached result is available.
+   */
   virtual bool hasResult();
+
+  /**
+   * Get the cached result.
+   * Fails if there is no cached result.
+   */
   virtual T getResult();
+
+  /**
+   * Delete a previously calculated result from the cache.
+   */
   virtual void reset();
 
 protected:
   T* result;
+
+  /**
+   * Pure virtual method for implementation of the actual calculation procedure.
+   */
   virtual T* doCalc()=0;
 private:

molecuilder/src/Actions/Process.cpp

@@ -73 +73 @@
   {
     OBSERVE;
-    active = true;
     currStep=0;
   }
   starts = false;
+  active = true;
 }
 
@@ -85 +85 @@
 
 void Process::stop(){
+  active=false;
   stops = true;
   {
     OBSERVE;
     currStep=0;
-    active=false;
   }
   {

molecuilder/src/Actions/Process.hpp

@@ -19 +19 @@
 #include "Actions/Action.hpp"
 
+/**
+ * A Process is an Action that might take some time and therefore has special
+ * methods to allow communication with progress indicators. Indicators
+ * can sign on at a global place and will be notified when any process is doing
+ * a calculation.
+ *
+ * A Process has four states:
+ *  - starting: It is in the process of setting itself up, and wants everybody to know that it will start
+ *              the calculation soon. Indicators should set up anything they need for displaying the progress
+ *              when they are notified by a process in this state.
+ *  - active:   The process is currently doing it's thing and wants any indicator to know it's status, i.e.
+ *              the percentage done.
+ *  - stopping: The process has fullfilled it's purpose and is shutting down. Indicators recieving this status
+ *              should also use it to shut down their indication mechanism and delete any objects allocated for
+ *              this Process
+ *  - inactive: This Process is currently sleeping. If a Process is sending out any signals in this state, there
+ *              is something seriously wrong.
+ */
 class Process : public Action, public Observable
 {