source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs @ 4984

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Data;
using System.Drawing;

namespace HeuristicLab.Problems.MetaOptimization {
  // TODO: ItemName/Descr, storability
  public class ValueConfiguration : Item, IValueConfiguration {
    protected bool isOptimizable;
    public bool IsOptimizable {
      get { return isOptimizable; }
      set {
        if (this.isOptimizable != value) {
          this.isOptimizable = value;
          OnIsOptimizableChanged();
        }
      }
    }

    protected bool optimize;
    public bool Optimize {
      get { return optimize; }
      set {
        if (optimize != value) {
          optimize = value;
          if (optimize) {
            ClearParameterConfigurations();
            PopulateParameterConfigurations();
          } else {
            ClearParameterConfigurations();
          }
          OnOptimizeChanged();
          OnToStringChanged();
        }
      }
    }

    protected IItemCollection<IParameterConfiguration> parameterConfigurations = new ItemCollection<IParameterConfiguration>();
    public IItemCollection<IParameterConfiguration> ParameterConfigurations {
      get { return new ReadOnlyItemCollection<IParameterConfiguration>(this.parameterConfigurations); }
      protected set { this.parameterConfigurations = value; }
    }

    protected ConstrainedValue constrainedValue;
    public ConstrainedValue ConstrainedValue {
      get { return constrainedValue; }
      set {
        if (this.constrainedValue != value) {
          ClearParameterConfigurations();
          this.constrainedValue = value;
          PopulateParameterConfigurations();
          OnValueChanged();
          OnToStringChanged();
        }
      }
    }

    protected IRange rangeConstraint;
    public IRange RangeConstraint {
      get { return rangeConstraint; }
    }

    #region Constructors and Cloning
    public ValueConfiguration(IItem value, Type valueDataType) {
      this.ParameterConfigurations = new ItemList<IParameterConfiguration>();
      this.ConstrainedValue = new ConstrainedValue(value, valueDataType);
      this.IsOptimizable = true;
      if (constrainedValue.ValueDataType == typeof(IntValue)) {
        rangeConstraint = new Range<IntValue>(new IntValue(0), (IntValue)value, new IntValue(1));
      } else if (constrainedValue.ValueDataType == typeof(DoubleValue)) {
        rangeConstraint = new Range<DoubleValue>(new DoubleValue(0), (DoubleValue)value, new DoubleValue(0.01));
      } else if (constrainedValue.ValueDataType == typeof(PercentValue)) {
        rangeConstraint = new Range<PercentValue>(new PercentValue(0), new PercentValue(1), new PercentValue(0.001));
      } else if (constrainedValue.ValueDataType == typeof(BoolValue)) {
        this.IsOptimizable = false; // there is nothing to configure for bools
      } else {
        rangeConstraint = null;
      }
      RegisterEvents();
    }

    public ValueConfiguration() { }
    [StorableConstructor]
    protected ValueConfiguration(bool deserializing) { }
    protected ValueConfiguration(ValueConfiguration original, Cloner cloner) : base(original, cloner) {
      this.ParameterConfigurations = cloner.Clone(original.ParameterConfigurations);
      this.ConstrainedValue = cloner.Clone(original.ConstrainedValue);
      this.rangeConstraint = cloner.Clone(original.RangeConstraint);
      this.IsOptimizable = original.IsOptimizable;
      RegisterEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ValueConfiguration(this, cloner);
    }
    #endregion

    protected virtual void PopulateParameterConfigurations() {
      if (this.constrainedValue.Value is IParameterizedNamedItem) {
        var parameterizedItem = this.constrainedValue.Value as IParameterizedNamedItem;
        foreach (var childParameter in parameterizedItem.Parameters) {
          var pc = ParameterConfiguration.Create(parameterizedItem, childParameter);
          if (pc != null) this.parameterConfigurations.Add(pc);
        }
      }
    }
    protected virtual void ClearParameterConfigurations() {
      parameterConfigurations.Clear();
    }

    private void RegisterEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged += new EventHandler(RangeConstraint_ToStringChanged);
      if (this.ConstrainedValue != null) this.ConstrainedValue.ToStringChanged += new EventHandler(ConstrainedValue_ToStringChanged);
    }
    private void DeregisterEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged += new EventHandler(RangeConstraint_ToStringChanged);
      if (this.ConstrainedValue != null) this.ConstrainedValue.ToStringChanged += new EventHandler(ConstrainedValue_ToStringChanged);
    }

    void ConstrainedValue_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }
    void RangeConstraint_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }

    #region IItem Members
    public override string ItemDescription {
      get { return (constrainedValue != null && constrainedValue.Value != null) ? constrainedValue.Value.ItemDescription : base.ItemDescription; }
    }

    public override Image ItemImage {
      get { return (constrainedValue != null && constrainedValue.Value != null) ? constrainedValue.Value.ItemImage : base.ItemImage; }
    }

    public override string ItemName {
      get { return (constrainedValue != null && constrainedValue.Value != null) ? constrainedValue.Value.ItemDescription : base.ItemName; }
    }
    #endregion

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

    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 (ConstrainedValue != null && ConstrainedValue.Value != null) {
        if (ConstrainedValue.Value is IParameterizedItem) {
          if (Optimize) {
            return string.Format("{0} (Optimize)", ConstrainedValue.Value.ItemName);
          } else {
            return string.Format("{0}", ConstrainedValue.Value.ItemName);
          }
        } else {
          if (Optimize) {
            return string.Format("{0} (Optimize: {1})", ConstrainedValue.Value.ItemName, RangeConstraint);
          } else {
            return string.Format("{0}: {1}", ConstrainedValue.Value.ItemName, ConstrainedValue.Value);
          }
        }
      } else {
        return base.ToString();
      }
    }
  }
}