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

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

namespace HeuristicLab.Problems.MetaOptimization {
  [StorableClass]
  public class ParameterConfiguration : DeepCloneable, IParameterConfiguration, IStorableContent {
    protected ParameterConfiguration parentConfiguration;

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

    [Storable]
    protected bool optimizationEnabled;
    public bool OptimizationEnabled {
      get { return optimizationEnabled; }
      set {
        if (optimizationEnabled != value) {
          optimizationEnabled = value;
          OnOptimizationEnabledChanged();
        }
      }
    }

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

    [Storable]
    protected IItemList<IParameterConfiguration> childParameterConfigurations = new ItemList<IParameterConfiguration>();
    public IItemList<IParameterConfiguration> ChildParameterConfigurations {
      get { return childParameterConfigurations; }
    }

    //public virtual IParameter Parameter {
    //  get {
    //    return parentConfiguration.GetChildParameter(this.parameterName);
    //  }
    //}


    protected Type parameterType;
    public Type ParameterType {
      get { return this.parameterType; }
    }

    protected Type valueType;
    public Type ValueType {
      get { return this.valueType; }
    }

    protected IItem value;
    public IItem Value {
      get { return value; }
      set {
        if (this.value != value) {
          ClearChildParameterConfigurations();
          OnValueChanging();
          this.value = value;
          if(this.value is IParameterizedNamedItem) AddChildParameterConfigurations(this.value as IParameterizedNamedItem);
          OnValueChanged();
        }
      }
    }

    // store parameter reference only for name/description/image/...
    private IValueParameter parameter;

    public ParameterConfiguration(ParameterConfiguration parentConfiguration, string parameterName, IValueParameter valueParameter) {
      this.parentConfiguration = parentConfiguration;
      this.ParameterName = parameterName;
      this.Value = valueParameter.Value;
      this.parameterType = valueParameter.GetType();
      this.valueType = valueParameter.DataType;

      this.parameter = valueParameter;
    }

    public ParameterConfiguration() { }
    [StorableConstructor]
    protected ParameterConfiguration(bool deserializing) { }
    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner)
      : base(original, cloner) {
      this.OptimizationEnabled = original.optimizationEnabled;
      this.ParameterName = original.parameterName;
      this.Value = cloner.Clone(original.Value);
      this.childParameterConfigurations = cloner.Clone(original.childParameterConfigurations);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ParameterConfiguration(this, cloner);
    }

    protected virtual IValueParameter GetChildParameter(string childParameterName) {
      return (IValueParameter)((IParameterizedItem)Value).Parameters[childParameterName];
    }

    protected virtual void AddChildParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
      foreach (var childParameter in parameterizedItem.Parameters) {
        var pc = ParameterConfiguration.Create(this, parameterizedItem, childParameter);
        if (pc != null) this.childParameterConfigurations.Add(pc);
      }
    }
    protected virtual void ClearChildParameterConfigurations() {
      childParameterConfigurations.Clear();
    }

    #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 virtual string ItemDescription {
      get { return parameter.Description; }
    }
    public virtual System.Drawing.Image ItemImage {
      get { return parameter.ItemImage; }
    }
    public virtual string ItemName {
      get { return parameter.ItemName; }
    }
    public virtual Version ItemVersion {
      get { return parameter.ItemVersion; }
    }
    #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 ItemImageChanged;
    protected virtual void OnItemImageChanged(object sender, EventArgs e) {
      var handler = ItemImageChanged;
      if (handler != null) handler(sender, e);
    }

    public virtual event EventHandler ToStringChanged;
    protected virtual void OnStringChanged(object sender, EventArgs e) {
      var handler = ToStringChanged;
      if (handler != null) handler(this, e); // important to set 'this' as sender
    }

    public virtual event EventHandler OptimizationEnabledChanged;
    protected virtual void OnOptimizationEnabledChanged() {
      var handler = OptimizationEnabledChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public virtual event EventHandler ValueChanging;
    protected virtual void OnValueChanging() {
      var handler = ValueChanging;
      if (handler != null) handler(this, EventArgs.Empty);
    }

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

    public override string ToString() {
      return string.Format("{0} ({1})", ParameterName, Value);
    }

    public static IParameterConfiguration Create(IParameterizedNamedItem parent) {
      return new RootParameterConfiguration(parent);
    }

    public static IParameterConfiguration Create(ParameterConfiguration parentConfiguration, IParameterizedNamedItem parent, IParameter parameter) {
      if (parameter is IValueParameter) {
        IValueParameter valueParameter = parameter as IValueParameter;

        if (typeof(IntValue).IsAssignableFrom(parameter.DataType)) {
          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter);
        } else if (typeof(IParameterizedItem).IsAssignableFrom(parameter.DataType)) {
          return new ParameterConfiguration(parentConfiguration, parameter.Name, valueParameter);
        } else {
          // todo
          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter);
        }
      }
      return null;
    }

    public void Parameterize(IParameterizedItem parameterizedItem) {
      throw new NotImplementedException();
    }

  }
}