Changeset 1186 for trunk/sources/HeuristicLab.ThreadParallelEngine

Timestamp:

01/29/09 14:03:34 (16 years ago)

Author:

vdorfer

Message:

Created API documentation for HeuristicLab.ThreadParallelEngine namespace (#331)

Location:

trunk/sources/HeuristicLab.ThreadParallelEngine

Files:

• HeuristicLabThreadParallelEnginePlugin.cs (modified) (1 diff)
• ThreadParallelEngine.cs (modified) (9 diffs)
• ThreadParallelEngineEditor.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.ThreadParallelEngine/HeuristicLabThreadParallelEnginePlugin.cs

@@ -26 +26 @@
 
 namespace HeuristicLab.ThreadParallelEngine {
+  /// <summary>
+  /// Plugin class for HeuristicLab.ThreadParallelEngine plugin.
+  /// </summary>
   [ClassInfo(Name = "HeuristicLab.ThreadParallelEngine-3.2")]
   [PluginFile(Filename = "HeuristicLab.ThreadParallelEngine-3.2.dll", Filetype = PluginFileType.Assembly)]

trunk/sources/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs

@@ -28 +28 @@
 
 namespace HeuristicLab.ThreadParallelEngine {
+  /// <summary>
+  /// Implementation of an engine being able to run in parallel with threads.
+  /// </summary>
   public class ThreadParallelEngine : EngineBase, IEditable {
     #region Inner Class Task
@@ -42 +45 @@
 
     private int myWorkers;
+    /// <summary>
+    /// Gets or sets the number of worker threads of the current engine.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnWorkersChanged"/> in the setter.</remarks>
     public int Workers {
       get { return myWorkers; }
@@ -52 +59 @@
     }
 
-
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThreadParallelEngine"/> with the number of processors
+    /// as number of worker threads.
+    /// </summary>
     public ThreadParallelEngine() {
       myWorkers = Environment.ProcessorCount;
@@ -59 +69 @@
 
 
+    /// <inheritdoc/>
+    /// <returns>The cloned object as <see cref="ThreadParallelEngine"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       ThreadParallelEngine clone = (ThreadParallelEngine)base.Clone(clonedObjects);
@@ -65 +77 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="ThreadParallelEngineEditor"/> to display the current 
+    /// instance.
+    /// </summary>
+    /// <returns>The created instance as <see cref="ThreadParallelEngineEditor"/>.</returns>
     public override IView CreateView() {
       return new ThreadParallelEngineEditor(this);
     }
+    /// <summary>
+    /// Creates a new instance of <see cref="ThreadParallelEngineEditor"/>.
+    /// </summary>
+    /// <returns>The created instance as <see cref="ThreadParallelEngineEditor"/>.</returns>
     public virtual IEditor CreateEditor() {
       return new ThreadParallelEngineEditor(this);
     }
 
+    /// <summary>
+    /// This execution method is not supported by ThreadParallelEngines.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown because the current instance of an engine
+    /// does not support stepwise execution.</exception>
+    /// <param name="steps">The number of steps to execute.</param>
     public override void ExecuteSteps(int steps) {
       throw new InvalidOperationException("ThreadParallelEngine doesn't support stepwise execution");
     }
 
+    /// <inheritdoc/>
     public override void Abort() {
       base.Abort();
@@ -83 +111 @@
       }
     }
-
+    /// <summary>
+    /// Processes the next operation (if it is a compositeOperation and it can be executed in parallel it is 
+    /// done).
+    /// </summary>
     protected override void ProcessNextOperation() {
       operatorIndex = 1;
@@ -169 +200 @@
     }
 
+    /// <summary>
+    /// Occurs when the number of workers has been changed.
+    /// </summary>
     public event EventHandler WorkersChanged;
+    /// <summary>
+    /// Fires a new <c>WorkersChanged</c> event.
+    /// </summary>
     protected virtual void OnWorkersChanged() {
       if (WorkersChanged != null)
@@ -176 +213 @@
 
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The number of workers is saved as <see cref="XmlAttribute"/> with attribute name 
+    /// <c>Workers</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -183 +230 @@
       return node;
     }
+    /// <summary>
+    /// Loads the persisted engine from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The number of workers must be saved in a specific way, see <see cref="GetXmlNode"/>
+    /// for further information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.ThreadParallelEngine/ThreadParallelEngineEditor.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.ThreadParallelEngine {
+  /// <summary>
+  /// Visual representation of a <see cref="ThreadParallelEngine"/>.
+  /// </summary>
   public partial class ThreadParallelEngineEditor : EngineBaseEditor {
+    /// <summary>
+    /// Gets or sets the ThreadParallelEngine to display.
+    /// </summary>
+    /// <remarks>Uses property <see cref="EngineBaseEditor.Engine"/> of base class 
+    /// <see cref="EngineBaseEditor"/>. No own data storage present.</remarks>
     public ThreadParallelEngine ThreadParallelEngine {
       get { return (ThreadParallelEngine)Engine; }
@@ -36 +44 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThreadParallelEngineEditor"/>.
+    /// </summary>
     public ThreadParallelEngineEditor() {
       InitializeComponent();
     }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThreadParallelEngineEditor"/> with the given
+    /// <paramref name="threadParallelEngine"/> to display.
+    /// </summary>
+    /// <param name="threadParallelEngine">The engine to represent visually.</param>
     public ThreadParallelEngineEditor(ThreadParallelEngine threadParallelEngine)
       : this() {
@@ -44 +60 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="ThreadParallelEngine"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="EngineBaseEditor.RemoveItemEvents"/> of base class 
+    /// <see cref="EngineBaseEditor"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       ThreadParallelEngine.WorkersChanged -= new EventHandler(ThreadParallelEngine_WorkersChanged);
@@ -49 +71 @@
     }
 
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="ThreadParallelEngine"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="EngineBaseEditor.AddItemEvents"/> of base class 
+    /// <see cref="EngineBaseEditor"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -54 +82 @@
     }
 
+    /// <summary>
+    /// Updates the controls with the latest data.
+    /// </summary>
+    /// <remarks>Calls <see cref="EngineBaseEditor.UpdateControls"/> of base class 
+    /// <see cref="EngineBaseEditor"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();