source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptions.cs @ 14906

namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
  using System;
  using System.Collections.Generic;
  using System.Linq;

  using HeuristicLab.Collections;
  using HeuristicLab.Common;
  using HeuristicLab.Core;
  using HeuristicLab.Data;
  using HeuristicLab.Parameters;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Boolean;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Char;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Float;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.FloatVector;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Integer;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.IntegerVector;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.String;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.StringVector;

  [StorableClass]
  public class ErcOptions : ParameterizedNamedItem, IReadOnlyErcOptions {
    private const string ProbabilityParameterName = "Probability";
    private const string IntegerParameterName = "Integer";
    private const string FloatParameterName = "Float";
    private const string CharParameterName = "Char";
    private const string BooleanParameterName = "Boolean";
    private const string StringParameterName = "String";
    private const string NameParameterName = "Name";
    private const string IntegerVectorParameterName = "IntegerVector";
    private const string FloatVectorParameterName = "FloatVector";
    private const string StringVectorParameterName = "StringVector";

    [Storable]
    private readonly NamedItemCollection<IValueParameter> ercOptionParameters;

    [Storable]
    private readonly ReadOnlyCheckedItemCollection<IValueParameter> ercOptions;

    private IDictionary<IValueParameter, EventHandler<bool>> ercOptionEnabledChangedHandler;

    public ErcOptions() {
      Name = "ERC Options";

      Parameters.Add(new FixedValueParameter<PercentValue>(ProbabilityParameterName));

      ercOptionParameters = new NamedItemCollection<IValueParameter>
                              {
                                new ValueParameter<IntegerErcOptions>(IntegerParameterName),
                                new ValueParameter<FloatErcOptions>(FloatParameterName),
                                new ValueParameter<BooleanErcOptions>(BooleanParameterName),
                                new ValueParameter<StringErcOptions>(StringParameterName),
                                new ValueParameter<CharErcOptions>(CharParameterName),
                                new ValueParameter<StringErcOptions>(NameParameterName),
                                new ValueParameter<IntegerVectorErcOptions>(IntegerVectorParameterName),
                                new ValueParameter<FloatVectorErcOptions>(FloatVectorParameterName),
                                new ValueParameter<StringVectorErcOptions>(StringVectorParameterName)
                              };

      InitEnabledChangedHandlerDict(ercOptionParameters);

      var optionsCollection = new CheckedItemCollection<IValueParameter>(ercOptionParameters);
      ercOptions = new ReadOnlyCheckedItemCollection<IValueParameter>(optionsCollection);
      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemCollection<IValueParameter>>("Options", ercOptions));

      ercOptions.CheckedItemsChanged += ErcOptionsCheckedItemsChanged;
      DisableAllOptions();
    }

    [StorableConstructor]
    protected ErcOptions(bool deserializing)
      : base(deserializing) {
    }

    public ErcOptions(ErcOptions origin, Cloner cloner)
      : base(origin, cloner) {
      ercOptions = cloner.Clone(origin.ercOptions);
      ercOptionParameters = cloner.Clone(origin.ercOptionParameters);

      InitEnabledChangedHandlerDict(ercOptionParameters);
    }

    public IValueParameter<PercentValue> ErcProbabilityParameter
    {
      get
      {
        return (IValueParameter<PercentValue>)Parameters[ProbabilityParameterName];
      }
    }

    public IValueParameter<IntegerErcOptions> IntegerErcOptionsParameter
    {
      get
      {
        return (IValueParameter<IntegerErcOptions>)ercOptionParameters[IntegerParameterName];
      }
    }

    public IntegerErcOptions IntegerErcOptions
    {
      get
      {
        return IntegerErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(IntegerErcOptionsParameter, value);
      }
    }

    public IValueParameter<FloatErcOptions> FloatErcOptionsParameter
    {
      get
      {
        return (IValueParameter<FloatErcOptions>)ercOptionParameters[FloatParameterName];
      }
    }

    public FloatErcOptions FloatErcOptions
    {
      get
      {
        return FloatErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(FloatErcOptionsParameter, value);
      }
    }

    /// <summary>
    ///   Integer represents ASCII value
    /// </summary>
    public IValueParameter<CharErcOptions> CharErcOptionsParameter
    {
      get
      {
        return (IValueParameter<CharErcOptions>)ercOptionParameters[CharParameterName];
      }
    }

    public CharErcOptions CharErcOptions
    {
      get
      {
        return CharErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(CharErcOptionsParameter, value);
      }
    }

    public IValueParameter<BooleanErcOptions> BooleanErcOptionsParameter
    {
      get
      {
        return (IValueParameter<BooleanErcOptions>)ercOptionParameters[BooleanParameterName];
      }
    }

    public BooleanErcOptions BooleanErcOptions
    {
      get
      {
        return BooleanErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(BooleanErcOptionsParameter, value);
      }
    }

    public IValueParameter<StringErcOptions> StringErcOptionsParameter
    {
      get
      {
        return (IValueParameter<StringErcOptions>)ercOptionParameters[StringParameterName];
      }
    }

    public StringErcOptions StringErcOptions
    {
      get
      {
        return StringErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(StringErcOptionsParameter, value);
      }
    }

    public IValueParameter<StringErcOptions> NameParameter
    {
      get
      {
        return (IValueParameter<StringErcOptions>)ercOptionParameters[NameParameterName];
      }
    }

    public StringErcOptions NameErcOptions
    {
      get
      {
        return NameParameter.Value;
      }
      set
      {
        SetErcOptions(NameParameter, value);
      }
    }

    public IValueParameter<IntegerVectorErcOptions> IntegerVectorErcOptionsParameter
    {
      get
      {
        return (IValueParameter<IntegerVectorErcOptions>)ercOptionParameters[IntegerVectorParameterName];
      }
    }

    public IntegerVectorErcOptions IntegerVectorErcOptions
    {
      get
      {
        return IntegerVectorErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(IntegerVectorErcOptionsParameter, value);
      }
    }

    public IValueParameter<StringVectorErcOptions> StringVectorErcOptionsValueParameter
    {
      get
      {
        return (IValueParameter<StringVectorErcOptions>)ercOptionParameters[StringVectorParameterName];
      }
    }

    public StringVectorErcOptions StringVectorErcOptions
    {
      get
      {
        return StringVectorErcOptionsValueParameter.Value;
      }
      set
      {
        SetErcOptions(StringVectorErcOptionsValueParameter, value);
      }
    }

    public IValueParameter<FloatVectorErcOptions> FloatVectorErcOptionsParameter
    {
      get
      {
        return (IValueParameter<FloatVectorErcOptions>)ercOptionParameters[FloatVectorParameterName];
      }
    }

    public FloatVectorErcOptions FloatVectorErcOptions
    {
      get
      {
        return FloatVectorErcOptionsParameter.Value;
      }
      set
      {
        SetErcOptions(FloatVectorErcOptionsParameter, value);
      }
    }

    public double ErcProbability
    {
      get
      {
        return ErcProbabilityParameter.Value.Value;
      }
      set
      {
        ErcProbabilityParameter.Value.Value = value;
      }
    }

    IErcValueItem<int> IReadOnlyErcOptions.IntegerErcOptions
    {
      get
      {
        return IntegerErcOptions;
      }
    }

    IErcValueItem<double> IReadOnlyErcOptions.FloatErcOptions
    {
      get
      {
        return FloatErcOptions;
      }
    }

    IErcValueItem<bool> IReadOnlyErcOptions.BooleanErcOptions
    {
      get
      {
        return BooleanErcOptions;
      }
    }

    IErcValueItem<char> IReadOnlyErcOptions.CharErcOptions
    {
      get
      {
        return CharErcOptions;
      }
    }

    IErcValueItem<string> IReadOnlyErcOptions.StringErcOptions
    {
      get
      {
        return StringErcOptions;
      }
    }

    IErcValueItem<string> IReadOnlyErcOptions.NameErcOptions
    {
      get
      {
        return NameErcOptions;
      }
    }

    IErcValueItem<IReadOnlyList<int>> IReadOnlyErcOptions.IntegerVectorErcOptions
    {
      get
      {
        return IntegerVectorErcOptions;
      }
    }

    IErcValueItem<IReadOnlyList<double>> IReadOnlyErcOptions.FloatVectorErcOptions
    {
      get
      {
        return FloatVectorErcOptions;
      }
    }

    IErcValueItem<IReadOnlyList<string>> IReadOnlyErcOptions.StringVectorErcOptions
    {
      get
      {
        return StringVectorErcOptions;
      }
    }

    [StorableHook(HookType.AfterDeserialization)]
    // ReSharper disable once UnusedMember.Local
    private void AfterDeserialization() {
      InitEnabledChangedHandlerDict(ercOptionParameters);
    }

    private void InitEnabledChangedHandlerDict(NamedItemCollection<IValueParameter> parameters) {
      ercOptionEnabledChangedHandler =
        parameters.ToDictionary<IValueParameter, IValueParameter, EventHandler<bool>>(
          param => param,
          param => (sender, state) => ercOptions.SetItemCheckedState(param, state));
    }

    private void ErcOptionsCheckedItemsChanged(object sender, CollectionItemsChangedEventArgs<IValueParameter> e) {
      foreach (var item in e.Items) {
        var ercItem = (IErcItem)item.Value;
        ercItem.IsEnabled = ercOptions.ItemChecked(item);
      }
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new ErcOptions(this, cloner);
    }

    public void DisableAllOptions() {
      SetOptionsState(false);
    }

    public void EnableAllOptions() {
      SetOptionsState(true);
    }

    public void SetOptionsState(bool state) {
      foreach (var param in ercOptions) ercOptions.SetItemCheckedState(param, state);
    }

    private void SetErcOptions(IValueParameter param, IErcItem value) {
      if ((ercOptionEnabledChangedHandler[param] != null) && (param.Value != null)) ((IErcItem)param.Value).EnabledChanged -= ercOptionEnabledChangedHandler[param];

      param.Value = value;
      ercOptions.SetItemCheckedState(param, value != null ? value.IsEnabled : false);

      if (value != null) value.EnabledChanged += ercOptionEnabledChangedHandler[param];
    }
  }
}