Changeset 11522 for stable/HeuristicLab.Optimization

Timestamp:

11/04/14 18:35:25 (9 years ago)

Author:

abeham

Message:

#2120: merged to stable

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Optimization/3.3/Interfaces/IRun.cs (modified) (2 diffs)
• HeuristicLab.Optimization/3.3/Run.cs (modified) (8 diffs)
• HeuristicLab.Optimization/3.3/RunCollection.cs (modified) (5 diffs)

stable/HeuristicLab.Optimization/3.3/Interfaces/IRun.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
+using System.ComponentModel;
 using System.Drawing;
+using HeuristicLab.Collections;
 using HeuristicLab.Core;
 
@@ -29 +29 @@
   /// Represents the parameters and results of an algorithm run.
   /// </summary>
-  public interface IRun : INamedItem {
+  public interface IRun : INamedItem, INotifyPropertyChanged {
     IAlgorithm Algorithm { get; }
-    IDictionary<string, IItem> Parameters { get; }
-    IDictionary<string, IItem> Results { get; }
+    IObservableDictionary<string, IItem> Parameters { get; }
+    IObservableDictionary<string, IItem> Results { get; }
 
     Color Color { get; set; }
     bool Visible { get; set; }
-    event EventHandler Changed;
   }
 }

stable/HeuristicLab.Optimization/3.3/Run.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Drawing;
-using System.Linq;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -44 +45 @@
       algorithm = cloner.Clone(original.algorithm);
 
-      parameters = new Dictionary<string, IItem>();
+      parameters = new ObservableDictionary<string, IItem>();
       foreach (string key in original.parameters.Keys)
         parameters.Add(key, cloner.Clone(original.parameters[key]));
 
-      results = new Dictionary<string, IItem>();
+      results = new ObservableDictionary<string, IItem>();
       foreach (string key in original.results.Keys)
         results.Add(key, cloner.Clone(original.results[key]));
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new Run(this, cloner);
@@ -62 +64 @@
       color = Color.Black;
       algorithm = null;
-      parameters = new Dictionary<string, IItem>();
-      results = new Dictionary<string, IItem>();
+      parameters = new ObservableDictionary<string, IItem>();
+      results = new ObservableDictionary<string, IItem>();
     }
     public Run(IAlgorithm algorithm)
@@ -88 +90 @@
 
     private void Initialize(IAlgorithm algorithm) {
-      parameters = new Dictionary<string, IItem>();
-      results = new Dictionary<string, IItem>();
+      parameters = new ObservableDictionary<string, IItem>();
+      results = new ObservableDictionary<string, IItem>();
 
       if (algorithm.StoreAlgorithmInEachRun) {
-        IAlgorithm clone = (IAlgorithm)algorithm.Clone();
+        var clone = (IAlgorithm)algorithm.Clone();
         clone.CollectParameterValues(parameters);
         clone.CollectResultValues(results);
@@ -98 +100 @@
         this.algorithm = clone;
       } else {
-        algorithm.CollectParameterValues(parameters);
-        algorithm.CollectResultValues(results);
-        Cloner cloner = new Cloner();
-        parameters = parameters.Select(x => new KeyValuePair<string, IItem>(x.Key, cloner.Clone(x.Value))).ToDictionary(x => x.Key, x => x.Value);
-        results = results.Select(x => new KeyValuePair<string, IItem>(x.Key, cloner.Clone(x.Value))).ToDictionary(x => x.Key, x => x.Value);
+        var par = new Dictionary<string, IItem>();
+        var res = new Dictionary<string, IItem>();
+        algorithm.CollectParameterValues(par);
+        algorithm.CollectResultValues(res);
+        var cloner = new Cloner();
+        foreach (var k in par) parameters.Add(k.Key, cloner.Clone(k.Value));
+        foreach (var k in res) results.Add(k.Key, cloner.Clone(k.Value));
       }
     }
@@ -115 +119 @@
       get { return algorithm; }
     }
-    [Storable]
-    private Dictionary<string, IItem> parameters;
-    public IDictionary<string, IItem> Parameters {
+
+    [Storable(Name = "parameters")]
+    private IDictionary<string, IItem> StorableParameters {
       get { return parameters; }
+      set {
+        if (!(value is IObservableDictionary<string, IItem>))
+          parameters = new ObservableDictionary<string, IItem>(value);
+        else parameters = (IObservableDictionary<string, IItem>)value;
+      }
     }
-    [Storable]
-    private Dictionary<string, IItem> results;
-    public IDictionary<string, IItem> Results {
+    private IObservableDictionary<string, IItem> parameters;
+    public IObservableDictionary<string, IItem> Parameters {
+      get { return parameters; }
+      private set {
+        if (parameters != value) {
+          parameters = value;
+          OnPropertyChanged("Parameters");
+        }
+      }
+    }
+
+    [Storable(Name = "results")]
+    private IDictionary<string, IItem> StorableResults {
       get { return results; }
+      set {
+        if (!(value is IObservableDictionary<string, IItem>))
+          results = new ObservableDictionary<string, IItem>(value);
+        else results = (IObservableDictionary<string, IItem>)value;
+      }
+    }
+    private IObservableDictionary<string, IItem> results;
+    public IObservableDictionary<string, IItem> Results {
+      get { return results; }
+      private set {
+        if (results != value) {
+          results = value;
+          OnPropertyChanged("Results");
+        }
+      }
     }
 
@@ -133 +167 @@
         if (color != value) {
           this.color = value;
-          this.OnChanged();
+          OnPropertyChanged("Color");
         }
       }
@@ -143 +177 @@
         if (visible != value) {
           this.visible = value;
-          this.OnChanged();
+          OnPropertyChanged("Visible");
         }
       }
     }
-    public event EventHandler Changed;
-    private void OnChanged() {
-      EventHandler handler = Changed;
-      if (handler != null)
-        handler(this, EventArgs.Empty);
+
+    public event PropertyChangedEventHandler PropertyChanged;
+    private void OnPropertyChanged(string property) {
+      var handler = PropertyChanged;
+      if (handler != null) handler(this, new PropertyChangedEventArgs(property));
     }
   }

stable/HeuristicLab.Optimization/3.3/RunCollection.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using HeuristicLab.Collections;
@@ -160 +161 @@
         foreach (KeyValuePair<string, IItem> result in run.Results)
           AddResult(result.Key, result.Value);
+        run.PropertyChanged += RunOnPropertyChanged;
+        RegisterRunParametersEvents(run);
+        RegisterRunResultsEvents(run);
+      }
+      foreach (IRun run in oldItems) {
+        run.PropertyChanged -= RunOnPropertyChanged;
+        DeregisterRunParametersEvents(run);
+        DeregisterRunResultsEvents(run);
       }
       columnNameCache = null;
@@ -178 +187 @@
         foreach (KeyValuePair<string, IItem> result in run.Results)
           columnsChanged |= AddResult(result.Key, result.Value);
+        run.PropertyChanged += RunOnPropertyChanged;
+        RegisterRunParametersEvents(run);
+        RegisterRunResultsEvents(run);
       }
       if (columnsChanged) columnNameCache = null;
@@ -198 +210 @@
         foreach (string resultName in run.Results.Keys)
           columnsChanged |= RemoveResultName(resultName);
+        run.PropertyChanged -= RunOnPropertyChanged;
+        DeregisterRunParametersEvents(run);
+        DeregisterRunResultsEvents(run);
       }
       if (columnsChanged) columnNameCache = null;
@@ -205 +220 @@
       OnRowsChanged();
       OnRowNamesChanged();
+      if (columnsChanged) {
+        OnColumnsChanged();
+        OnColumnNamesChanged();
+      }
+    }
+
+    private void RunOnPropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (e.PropertyName == "Parameters") {
+        RegisterRunParametersEvents((IRun)sender);
+      } else if (e.PropertyName == "Results") {
+        RegisterRunResultsEvents((IRun)sender);
+      }
+    }
+
+    private void RegisterRunParametersEvents(IRun run) {
+      IObservableDictionary<string, IItem> dict = run.Parameters;
+      dict.ItemsAdded += RunOnParameterChanged;
+      dict.ItemsRemoved += RunOnParameterRemoved;
+      dict.ItemsReplaced += RunOnParameterChanged;
+      dict.CollectionReset += RunOnParameterChanged;
+    }
+
+    private void RegisterRunResultsEvents(IRun run) {
+      IObservableDictionary<string, IItem> dict = run.Results;
+      dict.ItemsAdded += RunOnResultChanged;
+      dict.ItemsRemoved += RunOnResultRemoved;
+      dict.ItemsReplaced += RunOnResultChanged;
+      dict.CollectionReset += RunOnResultChanged;
+    }
+
+    private void DeregisterRunParametersEvents(IRun run) {
+      IObservableDictionary<string, IItem> dict = run.Parameters;
+      dict.ItemsAdded -= RunOnParameterChanged;
+      dict.ItemsRemoved -= RunOnParameterRemoved;
+      dict.ItemsReplaced -= RunOnParameterChanged;
+      dict.CollectionReset -= RunOnParameterChanged;
+    }
+
+    private void DeregisterRunResultsEvents(IRun run) {
+      IObservableDictionary<string, IItem> dict = run.Results;
+      dict.ItemsAdded -= RunOnResultChanged;
+      dict.ItemsRemoved -= RunOnResultRemoved;
+      dict.ItemsReplaced -= RunOnResultChanged;
+      dict.CollectionReset -= RunOnResultChanged;
+    }
+
+    private void RunOnParameterChanged(object sender, CollectionItemsChangedEventArgs<KeyValuePair<string, IItem>> e) {
+      bool columnsChanged = false;
+      foreach (var param in e.Items)
+        columnsChanged |= AddParameter(param.Key, param.Value);
+      foreach (var param in e.OldItems)
+        columnsChanged |= RemoveParameterName(param.Key);
+      if (columnsChanged) columnNameCache = null;
+      OnReset();
+      if (columnsChanged) {
+        OnColumnsChanged();
+        OnColumnNamesChanged();
+      }
+    }
+
+    private void RunOnParameterRemoved(object sender, CollectionItemsChangedEventArgs<KeyValuePair<string, IItem>> e) {
+      bool columnsChanged = false;
+      foreach (var param in e.Items)
+        columnsChanged |= RemoveParameterName(param.Key);
+      if (columnsChanged) columnNameCache = null;
+      OnReset();
+      if (columnsChanged) {
+        OnColumnsChanged();
+        OnColumnNamesChanged();
+      }
+    }
+
+    private void RunOnResultChanged(object sender, CollectionItemsChangedEventArgs<KeyValuePair<string, IItem>> e) {
+      bool columnsChanged = false;
+      foreach (var result in e.Items)
+        columnsChanged |= AddResult(result.Key, result.Value);
+      foreach (var result in e.OldItems)
+        columnsChanged |= RemoveResultName(result.Key);
+      if (columnsChanged) columnNameCache = null;
+      OnReset();
+      if (columnsChanged) {
+        OnColumnsChanged();
+        OnColumnNamesChanged();
+      }
+    }
+
+    private void RunOnResultRemoved(object sender, CollectionItemsChangedEventArgs<KeyValuePair<string, IItem>> e) {
+      bool columnsChanged = false;
+      foreach (var result in e.Items)
+        columnsChanged |= RemoveResultName(result.Key);
+      if (columnsChanged) columnNameCache = null;
+      OnReset();
       if (columnsChanged) {
         OnColumnsChanged();