source: branches/OKB/HeuristicLab.OKB.AlgorithmHost/AlgorithmContainer.cs @ 7317

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Optimization;
using HeuristicLab.Data;
using HeuristicLab.Collections;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Common.Resources;
using HeuristicLab.Common;

namespace HeuristicLab.OKB.AlgorithmHost {

  [Item("Algorithm Container", "Encapsulates algorithm & parameters for storing in the OKB")]  
  [StorableClass]
  public class AlgorithmContainer : ParameterizedNamedItemContainer {

    public AlgorithmContainer() {
      ResultMapping = new ObservableDictionary<string, string>();
    }

    [StorableConstructor]
    public AlgorithmContainer(bool deserializing) : base(deserializing) { }

    public IAlgorithm Algorithm {
      get { return (IAlgorithm)Item; }
      set { Item = value; }
    }

    public override Type ItemType { get { return typeof(IAlgorithm); } }

    public override string ItemName { get { return "AlgorithmContainer"; } }
    public override string ItemDescription { get { return "Container for algorithms to be stored in the OKB"; } }


    [Storable]
    public ObservableDictionary<string, string> ResultMapping { get; private set; }

    private ResultCollection results;

    public override void InitializeMapping() {
      base.InitializeMapping();
      Results_CollectionReset(this, new CollectionItemsChangedEventArgs<IResult>(Enumerable.Empty<IResult>()));
    }

    protected override void RegisterItemEvents() {
      base.RegisterItemEvents();
      Algorithm.Prepared += new EventHandler(Algorithm_Prepared);
      RegisterResultEvents();
    }

    protected override void DeregisterItemEvents() {
      base.DeregisterItemEvents();
      Algorithm.Prepared -= new EventHandler(Algorithm_Prepared);
      DeregisterResultEvents();
    }

    private void RegisterResultEvents() {
      results = Algorithm.Results;
      results.CollectionReset += new CollectionItemsChangedEventHandler<IResult>(Results_CollectionReset);
      results.ItemsAdded += new CollectionItemsChangedEventHandler<IResult>(Results_ItemsAdded);
      results.ItemsRemoved += new CollectionItemsChangedEventHandler<IResult>(Results_ItemsRemoved);
    }

    private void DeregisterResultEvents() {
      if (results == null) return;
      results.CollectionReset -= new CollectionItemsChangedEventHandler<IResult>(Results_CollectionReset);
      results.ItemsAdded -= new CollectionItemsChangedEventHandler<IResult>(Results_ItemsAdded);
      results.ItemsRemoved -= new CollectionItemsChangedEventHandler<IResult>(Results_ItemsRemoved);
    }

    void Algorithm_Prepared(object sender, EventArgs e) {
      DeregisterResultEvents();
      RegisterResultEvents();
    }

    void Results_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IResult> e) {
      foreach (var result in e.OldItems) {
        ResultMapping.Remove(result.Name);
      }
    }

    void Results_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IResult> e) {
      foreach (var result in e.Items) {
        ResultMapping.Add(result.Name, null);
      }
    }

    void Results_CollectionReset(object sender, CollectionItemsChangedEventArgs<IResult> e) {
      ResultMapping.Clear();
      foreach (Result r in Algorithm.Results) {
        ResultMapping.Add(r.Name, null);
      }
    }

    public override HeuristicLab.Common.IDeepCloneable Clone(Cloner cloner) {
      AlgorithmContainer clone = (AlgorithmContainer)base.Clone(cloner);
      clone.ResultMapping = new ObservableDictionary<string, string>();
      foreach (var item in ResultMapping) {
        clone.ResultMapping.Add(item.Key, item.Value);
      }
      return clone;
    }

    public void Strip() {
      DeregisterItemEvents();
      DeregisterResultEvents();
      try { Algorithm.Prepare(true); } catch (Exception) { }
      try { Algorithm.Problem = null; } catch (Exception) { }
    }
  }
}