Changeset 5300 for trunk/sources/HeuristicLab.Optimization/3.3/BatchRun.cs

Timestamp:

01/15/11 02:34:08 (14 years ago)

Author:

swagner

Message:

Enabled batch runs to deal with optimizers (#1378)

File:

• trunk/sources/HeuristicLab.Optimization/3.3/BatchRun.cs (modified) (13 diffs)

trunk/sources/HeuristicLab.Optimization/3.3/BatchRun.cs

@@ -31 +31 @@
 namespace HeuristicLab.Optimization {
   /// <summary>
-  /// A run in which an algorithm is executed a given number of times.
+  /// A run in which an optimizer is executed a given number of times.
   /// </summary>
-  [Item("Batch Run", "A run in which an algorithm is executed a given number of times.")]
+  [Item("Batch Run", "A run in which an optimizer is executed a given number of times.")]
   [Creatable("Testing & Analysis")]
   [StorableClass]
@@ -66 +66 @@
     public TimeSpan ExecutionTime {
       get {
-        if ((Algorithm != null) && (Algorithm.ExecutionState != ExecutionState.Stopped))
-          return executionTime + Algorithm.ExecutionTime;
+        if ((Optimizer != null) && (Optimizer.ExecutionState != ExecutionState.Stopped))
+          return executionTime + Optimizer.ExecutionTime;
         else
           return executionTime;
@@ -78 +78 @@
 
     [Storable]
-    private IAlgorithm algorithm;
-    public IAlgorithm Algorithm {
-      get { return algorithm; }
+    private IOptimizer optimizer;
+    public IOptimizer Optimizer {
+      get { return optimizer; }
       set {
-        if (algorithm != value) {
-          if (algorithm != null) {
-            DeregisterAlgorithmEvents();
-            IEnumerable<IRun> runs = algorithm.Runs;
-            algorithm = null; //necessary to avoid removing the runs from the old algorithm
+        if (optimizer != value) {
+          if (optimizer != null) {
+            DeregisterOptimizerEvents();
+            IEnumerable<IRun> runs = optimizer.Runs;
+            optimizer = null; //necessary to avoid removing the runs from the old optimizer
             Runs.RemoveRange(runs);
           }
-          algorithm = value;
-          if (algorithm != null) {
-            RegisterAlgorithmEvents();
-            Runs.AddRange(algorithm.Runs);
+          optimizer = value;
+          if (optimizer != null) {
+            RegisterOptimizerEvents();
+            Runs.AddRange(optimizer.Runs);
           }
-          OnAlgorithmChanged();
+          OnOptimizerChanged();
           Prepare();
         }
       }
     }
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code (remove with 3.4)
+    [Storable]
+    private IAlgorithm algorithm {
+      get { return null; }
+      set { optimizer = value; }
+    }
+    #endregion
 
     [Storable]
@@ -108 +116 @@
           repetitions = value;
           OnRepetitionsChanged();
-          if ((Algorithm != null) && (Algorithm.ExecutionState == ExecutionState.Stopped))
+          if ((Optimizer != null) && (Optimizer.ExecutionState == ExecutionState.Stopped))
             Prepare();
         }
@@ -176 +184 @@
       executionState = original.executionState;
       executionTime = original.executionTime;
-      algorithm = cloner.Clone(original.algorithm);
+      optimizer = cloner.Clone(original.optimizer);
       repetitions = original.repetitions;
       repetitionsCounter = original.repetitionsCounter;
@@ -189 +197 @@
 
     private void Initialize() {
-      if (algorithm != null) RegisterAlgorithmEvents();
+      if (optimizer != null) RegisterOptimizerEvents();
       if (runs != null) RegisterRunsEvents();
     }
@@ -199 +207 @@
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
         throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
-      if (Algorithm != null) {
+      if (Optimizer != null) {
         repetitionsCounter = 0;
         if (clearRuns) runs.Clear();
-        Algorithm.Prepare(clearRuns);
+        Optimizer.Prepare(clearRuns);
       }
     }
@@ -208 +216 @@
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-      if (Algorithm != null) Algorithm.Start();
+      if (Optimizer != null) Optimizer.Start();
     }
     public void Pause() {
       if (ExecutionState != ExecutionState.Started)
         throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
-      if ((Algorithm != null) && (Algorithm.ExecutionState == ExecutionState.Started))
-        Algorithm.Pause();
+      if ((Optimizer != null) && (Optimizer.ExecutionState == ExecutionState.Started))
+        Optimizer.Pause();
     }
     public void Stop() {
@@ -220 +228 @@
         throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
       stopPending = true;
-      if ((Algorithm != null) &&
-          ((Algorithm.ExecutionState == ExecutionState.Started) || (Algorithm.ExecutionState == ExecutionState.Paused)))
-        Algorithm.Stop();
+      if ((Optimizer != null) &&
+          ((Optimizer.ExecutionState == ExecutionState.Started) || (Optimizer.ExecutionState == ExecutionState.Paused)))
+        Optimizer.Stop();
     }
 
@@ -236 +244 @@
       if (handler != null) handler(this, EventArgs.Empty);
     }
-    public event EventHandler AlgorithmChanged;
-    private void OnAlgorithmChanged() {
-      EventHandler handler = AlgorithmChanged;
+    public event EventHandler OptimizerChanged;
+    private void OnOptimizerChanged() {
+      EventHandler handler = OptimizerChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -276 +284 @@
     }
 
-    private void RegisterAlgorithmEvents() {
-      algorithm.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
-      algorithm.ExecutionTimeChanged += new EventHandler(Algorithm_ExecutionTimeChanged);
-      algorithm.Paused += new EventHandler(Algorithm_Paused);
-      algorithm.Prepared += new EventHandler(Algorithm_Prepared);
-      algorithm.Started += new EventHandler(Algorithm_Started);
-      algorithm.Stopped += new EventHandler(Algorithm_Stopped);
-      algorithm.Runs.CollectionReset += new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_CollectionReset);
-      algorithm.Runs.ItemsAdded += new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_ItemsAdded);
-      algorithm.Runs.ItemsRemoved += new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_ItemsRemoved);
-    }
-    private void DeregisterAlgorithmEvents() {
-      algorithm.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
-      algorithm.ExecutionTimeChanged -= new EventHandler(Algorithm_ExecutionTimeChanged);
-      algorithm.Paused -= new EventHandler(Algorithm_Paused);
-      algorithm.Prepared -= new EventHandler(Algorithm_Prepared);
-      algorithm.Started -= new EventHandler(Algorithm_Started);
-      algorithm.Stopped -= new EventHandler(Algorithm_Stopped);
-      algorithm.Runs.CollectionReset -= new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_CollectionReset);
-      algorithm.Runs.ItemsAdded -= new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_ItemsAdded);
-      algorithm.Runs.ItemsRemoved -= new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_ItemsRemoved);
-    }
-    private void Algorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+    private void RegisterOptimizerEvents() {
+      optimizer.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(Optimizer_ExceptionOccurred);
+      optimizer.ExecutionTimeChanged += new EventHandler(Optimizer_ExecutionTimeChanged);
+      optimizer.Paused += new EventHandler(Optimizer_Paused);
+      optimizer.Prepared += new EventHandler(Optimizer_Prepared);
+      optimizer.Started += new EventHandler(Optimizer_Started);
+      optimizer.Stopped += new EventHandler(Optimizer_Stopped);
+      optimizer.Runs.CollectionReset += new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_CollectionReset);
+      optimizer.Runs.ItemsAdded += new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_ItemsAdded);
+      optimizer.Runs.ItemsRemoved += new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_ItemsRemoved);
+    }
+    private void DeregisterOptimizerEvents() {
+      optimizer.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(Optimizer_ExceptionOccurred);
+      optimizer.ExecutionTimeChanged -= new EventHandler(Optimizer_ExecutionTimeChanged);
+      optimizer.Paused -= new EventHandler(Optimizer_Paused);
+      optimizer.Prepared -= new EventHandler(Optimizer_Prepared);
+      optimizer.Started -= new EventHandler(Optimizer_Started);
+      optimizer.Stopped -= new EventHandler(Optimizer_Stopped);
+      optimizer.Runs.CollectionReset -= new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_CollectionReset);
+      optimizer.Runs.ItemsAdded -= new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_ItemsAdded);
+      optimizer.Runs.ItemsRemoved -= new CollectionItemsChangedEventHandler<IRun>(Optimizer_Runs_ItemsRemoved);
+    }
+    private void Optimizer_ExceptionOccurred(object sender, EventArgs<Exception> e) {
       OnExceptionOccurred(e.Value);
     }
-    private void Algorithm_ExecutionTimeChanged(object sender, EventArgs e) {
+    private void Optimizer_ExecutionTimeChanged(object sender, EventArgs e) {
       OnExecutionTimeChanged();
     }
-    private void Algorithm_Paused(object sender, EventArgs e) {
+    private void Optimizer_Paused(object sender, EventArgs e) {
       OnPaused();
     }
-    private void Algorithm_Prepared(object sender, EventArgs e) {
+    private void Optimizer_Prepared(object sender, EventArgs e) {
       if ((ExecutionState == ExecutionState.Paused) || (ExecutionState == ExecutionState.Stopped))
         OnPrepared();
     }
-    private void Algorithm_Started(object sender, EventArgs e) {
+    private void Optimizer_Started(object sender, EventArgs e) {
       stopPending = false;
       if (ExecutionState != ExecutionState.Started)
         OnStarted();
     }
-    private void Algorithm_Stopped(object sender, EventArgs e) {
+    private void Optimizer_Stopped(object sender, EventArgs e) {
       repetitionsCounter++;
 
       if (!stopPending && (repetitionsCounter < repetitions)) {
-        Algorithm.Prepare();
-        Algorithm.Start();
+        Optimizer.Prepare();
+        Optimizer.Start();
       } else {
         OnStopped();
       }
     }
-    private void Algorithm_Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+    private void Optimizer_Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
       Runs.RemoveRange(e.OldItems);
       Runs.AddRange(e.Items);
     }
-    private void Algorithm_Runs_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+    private void Optimizer_Runs_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IRun> e) {
       Runs.AddRange(e.Items);
     }
-    private void Algorithm_Runs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+    private void Optimizer_Runs_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IRun> e) {
       Runs.RemoveRange(e.Items);
     }
@@ -355 +363 @@
         if (executionTime != null) ExecutionTime -= executionTime.Value;
       }
-      if (Algorithm != null) Algorithm.Runs.RemoveRange(e.OldItems);
+      if (Optimizer != null) Optimizer.Runs.RemoveRange(e.OldItems);
       foreach (IRun run in e.Items) {
         IItem item;
@@ -378 +386 @@
         if (executionTime != null) ExecutionTime -= executionTime.Value;
       }
-      if (Algorithm != null) Algorithm.Runs.RemoveRange(e.Items);
+      if (Optimizer != null) Optimizer.Runs.RemoveRange(e.Items);
     }
     #endregion