source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs @ 4997

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Problems.MetaOptimization {
  [StorableClass]
  public class ParameterConfiguration : Item, IParameterConfiguration, IStorableContent {
    public bool IsOptimizable { 
      get { return true; } 
    }

    [Storable]
    public string Filename { get; set; }

    [Storable]
    protected bool optimize;
    public bool Optimize {
      get { return optimize; }
      set {
        if (optimize != value) {
          optimize = value;
          if (optimize) {
            PopulateValueConfigurations();
          } else {
            this.ValueConfigurations.Clear();
          }
          OnOptimizeChanged();
          OnToStringChanged();
        }
      }
    }

    [Storable]
    protected string parameterName;
    public string ParameterName {
      get { return parameterName; }
      set {
        if (parameterName != value) {
          parameterName = value;
          OnToStringChanged();
        }
      }
    }

    protected Type parameterDataType;
    public Type ParameterDataType {
      get { return this.parameterDataType; }
    }

    protected IEnumerable<IItem> validValues;
    public IEnumerable<IItem> ValidValues {
      get { return validValues; }
      protected set {
        if (this.validValues != value) {
          this.validValues = value;
        }
      }
    }

    protected Type valueDataType;
    public Type ValueDataType {
      get { return valueDataType; }
      protected set { this.valueDataType = value; }
    }

    protected ICheckedValueConfigurationCollection valueConfigurations;
    public ICheckedValueConfigurationCollection ValueConfigurations {
      get { return this.valueConfigurations; }
      protected set {
        if (this.valueConfigurations != value) {
          if (this.valueConfigurations != null) DeregisterValueConfigurationEvents();
          this.valueConfigurations = value;
          if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
        }
      }
    }

    protected int actualValueConfigurationIndex = 0;

    protected ConstrainedValue actualValue;
    public ConstrainedValue ActualValue {
      get { return actualValue; }
      set { actualValue = value; }
    }
    
    // store parameter reference only for name/description/image/...
    private IValueParameter parameter;

    #region Constructors and Cloning
    public ParameterConfiguration(string parameterName, IValueParameter valueParameter) {
      this.ParameterName = parameterName;
      this.parameterDataType = valueParameter.GetType();
      this.parameter = valueParameter;
      this.valueDataType = valueParameter.DataType;
      this.validValues = GetValidValues();
      this.ValueConfigurations = new CheckedValueConfigurationCollection(this.valueDataType);
      this.ActualValue = new ConstrainedValue(valueParameter.Value, valueParameter.DataType);
      if (Optimize) {
        PopulateValueConfigurations();
      }
    }

    public ParameterConfiguration() { }
    [StorableConstructor]
    protected ParameterConfiguration(bool deserializing) { }
    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner) : base(original, cloner) {
      this.parameterName = original.ParameterName;
      this.parameterDataType = original.parameterDataType;
      this.parameter = cloner.Clone(original.parameter);
      this.valueDataType = original.ValueDataType;
      this.validValues = original.ValidValues.Select(x => cloner.Clone(x));
      this.ValueConfigurations = cloner.Clone(original.ValueConfigurations);
      this.ActualValue = cloner.Clone(original.ActualValue);
      this.optimize = original.optimize;
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ParameterConfiguration(this, cloner);
    }
    #endregion

    private void RegisterValueConfigurationEvents() {
      this.ValueConfigurations.CheckedItemsChanged += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
      this.ValueConfigurations.ItemsAdded += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
      this.ValueConfigurations.ItemsRemoved += new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
    }

    private void DeregisterValueConfigurationEvents() {
      this.ValueConfigurations.CheckedItemsChanged -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_CheckedItemsChanged);
      this.ValueConfigurations.ItemsAdded -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsAdded);
      this.ValueConfigurations.ItemsRemoved -= new Collections.CollectionItemsChangedEventHandler<IValueConfiguration>(ValueConfigurations_ItemsRemoved);
    }

    private void PopulateValueConfigurations() {
      foreach (IItem validValue in this.validValues) {
        IItem val;
        if (ActualValue.Value != null && ActualValue.ValueDataType == validValue.GetType()) {
          val = ActualValue.Value; // use existing value for that type (if available)
        } else {
          val = validValue;
        }
        this.ValueConfigurations.Add(new ValueConfiguration(val, val.GetType()), true);
      }
    }

    private IEnumerable<IItem> GetValidValues() {
      return ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName).ToArray();
    }

    void ValueConfigurations_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
      OnToStringChanged();
    }
    void ValueConfigurations_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
      OnToStringChanged();
    }
    void ValueConfigurations_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IValueConfiguration> e) {
      OnToStringChanged();
    }

    #region INamedItem Properties
    public virtual string Name {
      get { return ParameterName; }
      set { throw new NotSupportedException(); }
    }
    public virtual string Description {
      get { return parameter.Description; }
      set { throw new NotSupportedException(); }
    }
    public virtual bool CanChangeDescription {
      get { return false; }
    }
    public virtual bool CanChangeName {
      get { return false; }
    }
    public override string ItemDescription {
      get { return parameter != null ? parameter.Description : base.ItemDescription; }
    }
    public override System.Drawing.Image ItemImage {
      get { return parameter != null ? parameter.ItemImage : base.ItemImage; }
    }
    public override string ItemName {
      get { return parameter != null ?parameter.ItemName : base.ItemName; }
    }
    #endregion

    #region Events
    public virtual event EventHandler NameChanged;
    protected virtual void OnNameChanged(object sender, EventArgs e) {
      var handler = NameChanged;
      if (handler != null) handler(sender, e);
    }

    public virtual event EventHandler<CancelEventArgs<string>> NameChanging;
    protected virtual void OnNameChanging(object sender, CancelEventArgs<string> e) {
      var handler = NameChanging;
      if (handler != null) handler(sender, e);
    }

    public virtual event EventHandler DescriptionChanged;
    protected virtual void OnDescriptionChanged(object sender, EventArgs e) {
      var handler = DescriptionChanged;
      if (handler != null) handler(sender, e);
    }
    
    public virtual event EventHandler IsOptimizableChanged;
    private void OnIsOptimizableChanged() {
      var handler = IsOptimizableChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public virtual event EventHandler OptimizeChanged;
    protected virtual void OnOptimizeChanged() {
      var handler = OptimizeChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    #endregion

    public override string ToString() {
      if (Optimize) {
        return string.Format("{0}: (Optimize: {1})", ParameterName, ValueConfigurations.CheckedItems.Count());
      } else {
        return string.Format("{0}: {1}", ParameterName, ActualValue.Value);
      }
    }

    public static IParameterConfiguration Create(IParameterizedNamedItem parent, IParameter parameter) {
      if (parameter is IValueParameter) {
        IValueParameter valueParameter = parameter as IValueParameter;
        return new ParameterConfiguration(parameter.Name, valueParameter);
      }
      return null;
    }

    public void Parameterize() {
      this.parameter.ActualValue = this.ActualValue.Value;
    }

    public void Randomize() {
      if (Optimize) {
        Random rand = new Random(); // todo: use global random
        actualValueConfigurationIndex = rand.Next(ValueConfigurations.CheckedItems.Count());
        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Randomize();
        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
      }
    }

    public void Mutate() {
      if (Optimize) {
        foreach (IValueConfiguration vc in this.ValueConfigurations.CheckedItems) {
          vc.Mutate();
        }
        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
      }
    }

    public void Cross(IOptimizable other) {
      if (Optimize) {
        IParameterConfiguration otherPc = (IParameterConfiguration)other;
        for (int i = 0; i < this.ValueConfigurations.Count; i++) {
          this.ValueConfigurations.ElementAt(i).Cross(otherPc.ValueConfigurations.ElementAt(i));
        }
        this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
      }
    }
  }
}