source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs @ 14834

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using Attributes;
  using Common;
  using Core;
  using Erc;
  using Erc.Interfaces;
  using Expressions;
  using Persistence.Default.CompositeSerializers.Storable;
  using Stack;

  [StorableClass]
  public class PushConfiguration : ParameterizedNamedItem, IReadOnlyPushConfiguration, IEnabledExpressionsConfiguration {



    public PushConfiguration() {
      Name = "Push Configuration";

      enabledExpressions = ExpressionTable.ExpressionNames.ToList();
      EnabledStacks = new Dictionary<StackTypes, bool>();

      ErcOptions = new ErcOptions();
      EvalPushLimit = 1024;
      MaxPointsInProgram = 128;
      TopLevelPushCode = true;
      TopLevelPopCode = false;
      MaxPointsInRandomExpression = 64;
      MaxStringLength = 32;
      MaxVectorLength = 64;
      MaxDepth = 32;

      InitEnabledStacks();
    }

    private void InitEnabledStacks(bool state = true) {
      foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
        if (!EnabledStacks.ContainsKey(type))
          EnabledStacks.Add(type, state);
      }
    }

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

    public PushConfiguration(PushConfiguration origin, Cloner cloner) : base(origin, cloner) {
      enabledExpressions = origin.EnabledExpressions.ToList();
      EnabledStacks = origin.EnabledStacks.ToDictionary(x => x.Key, x => x.Value);

      ErcOptions = cloner.Clone(origin.ErcOptions);
      EvalPushLimit = origin.EvalPushLimit;
      MaxPointsInProgram = origin.MaxPointsInProgram;
      MaxPointsInRandomExpression = origin.MaxPointsInRandomExpression;
      TopLevelPushCode = origin.TopLevelPushCode;
      TopLevelPopCode = origin.TopLevelPopCode;
      MaxStringLength = origin.MaxStringLength;
      MaxVectorLength = origin.MaxVectorLength;
      MaxDepth = origin.MaxDepth;
    }

    [StorableHook(HookType.AfterDeserialization)]
    // ReSharper disable once UnusedMember.Local
    private void AfterDeserialization() {
      // Ensures that all types added after last serialization are available in enabledStacks
      InitEnabledStacks(false);
    }

    [Storable]
    public IDictionary<StackTypes, bool> EnabledStacks { get; set; }

    IReadOnlyDictionary<StackTypes, bool> IReadOnlyPushConfiguration.EnabledStacks { get { return EnabledStacks as IReadOnlyDictionary<StackTypes, bool>; } }

    public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;

    [Storable]
    private readonly List<string> enabledExpressions;

    public IList<string> EnabledExpressions
    {
      get { return enabledExpressions; }
      set
      {
        var removedExpressions = enabledExpressions.ToArray();
        enabledExpressions.Clear();
        enabledExpressions.AddRange(value);

        if (EnabledExpressionsChanged != null) {
          EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(value, removedExpressions));
        }
      }
    }

    IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions { get { return EnabledExpressions as IReadOnlyList<string>; } }

    [Storable]
    public ErcOptions ErcOptions { get; set; }

    IReadOnlyErcOptions IReadOnlyPushConfiguration.ErcOptions { get { return ErcOptions; } }

    /// <summary>
    ///     This is the maximum allowed number of "executions" in a single top-level call to the interpreter.
    ///     The execution of a single Push instruction counts as one execution, as does the processing of a single literal,
    ///     as does the descent into one layer of parentheses (that is, the processing of the "(" counts as one execution).
    ///     When this limit is exceeded the interpreter aborts immediately, leaving its stacks in the states they were in prior
    ///     to the abort (so they may still be examined by a calling program). Whether or not this counts as an "abnormal"
    ///     termination
    ///     is up to the calling program.
    /// </summary>
    [Storable]
    public int EvalPushLimit { get; set; }

    /// <summary>
    /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
    /// </summary>
    [Storable]
    public int MaxDepth { get; set; }

    /// <summary>
    ///     This is the maximum size of an item on the CODE stack, expressed as a number of points.
    ///     A point is an instruction, a literal, or a pair of parentheses. Any instruction that would cause this limit to be
    ///     exceeded
    ///     should instead act as a NOOP, leaving all stacks in the states that they were in before the execution of the
    ///     instruction.
    /// </summary>
    [Storable]
    public int MaxPointsInProgram { get; set; }

    /// <summary>
    ///     The maximum number of points in an expression produced by the CODE.RAND instruction.
    /// </summary>
    [Storable]
    public int MaxPointsInRandomExpression { get; set; }

    /// <summary>
    ///     When TRUE (which is the default), code passed to the top level of the interpreter
    ///     will be pushed onto the CODE stack prior to execution.
    /// </summary>
    [Storable]
    public bool TopLevelPushCode { get; set; }

    /// <summary>
    ///     When TRUE, the CODE stack will be popped at the end of top level calls to the interpreter. The default is FALSE.
    /// </summary>
    [Storable]
    public bool TopLevelPopCode { get; set; }

    [Storable]
    public int MaxStringLength { get; set; }

    [Storable]
    public int MaxVectorLength { get; set; }

    public void EnableExpressionOfStack(StackTypes types) {
      var names = ExpressionTable.StackTypeToNamesTable[types]
        .Except(EnabledExpressions)
        .ToArray();

      foreach (var name in names)
        EnabledExpressions.Add(name);

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(names, new string[0]));
      }
    }

    public void DisableExpressionOfStack(StackTypes types) {
      var names = ExpressionTable.StackTypeToNamesTable[types]
        .Intersect(EnabledExpressions)
        .ToArray();

      foreach (var name in names)
        EnabledExpressions.Remove(name);

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], names));
      }
    }

    public void EnableExpression(string name, bool enableStackIfDisabled = false) {
      if (EnabledExpressions.Contains(name)) return;

      EnabledExpressions.Add(name);

      if (enableStackIfDisabled) {
        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
        var attribute = ExpressionTable.TypeToAttributeTable[type];
        EnabledStacks[attribute.StackType] = true;
      }

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
          new[] { name },
          new string[0]));
      }
    }

    public void DisableExpression(string name, bool disableStackIfEnabled = false) {
      if (!EnabledExpressions.Contains(name)) return;

      EnabledExpressions.Remove(name);

      if (disableStackIfEnabled) {
        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
        var attribute = ExpressionTable.TypeToAttributeTable[type];
        EnabledStacks[attribute.StackType] = false;
      }

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
          new string[0],
          new[] { name }));
      }
    }

    public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
      EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
    }

    public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
      DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
    }

    public void SetExpression(string name, bool state, bool cascadeForStack = false) {
      if (state) EnableExpression(name, cascadeForStack);
      else DisableExpression(name, cascadeForStack);
    }

    public void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression {
      if (state) EnableExpression<T>(cascadeForStack);
      else DisableExpression<T>(cascadeForStack);
    }

    public void EnableStack(StackTypes type, bool enableExpressions = false) {
      EnabledStacks[type] = true;

      if (enableExpressions)
        EnableExpressionOfStack(type);
    }

    public void DisableStack(StackTypes type, bool disableExpressions = false) {
      EnabledStacks[type] = false;

      if (disableExpressions)
        DisableExpressionOfStack(type);
    }

    public void SetStack(StackTypes type, bool state, bool cascadeForExpressions = false) {
      if (state) EnableStack(type, cascadeForExpressions);
      else DisableStack(type, cascadeForExpressions);
    }

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