source: addons/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs @ 17603

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System;
  using System.Collections.Generic;

  using Attributes;

  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

  using Interpreter;
  using Stack;

  /// <summary>
  /// Defines the name on top of the NAME stack as an instruction that will push the top item of the T stack onto the EXEC stack.
  /// </summary>
  /// <typeparam name="T">Stack item type</typeparam>
  [StorableClass]
  public abstract class DefineExpression<T> : StatelessExpression {
    protected DefineExpression() { }
    [StorableConstructor]
    protected DefineExpression(bool deserializing) : base(deserializing) { }

    protected void Eval(
      IPushStack<T> stack,
      IPushStack<string> nameStack,
      IDictionary<string, Expression> customExpressions,
      Func<T, Expression> creator) {
      var name = nameStack.Pop();
      var expression = creator(stack.Top);

      if (customExpressions.ContainsKey(name)) customExpressions[name] = expression;
      else customExpressions.Add(name, expression);
    }
  }

  [PushExpression(
    StackTypes.Code,
    "CODE.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the CODE stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class CodeDefineExpression : DefineExpression<Expression> {
    public CodeDefineExpression() { }
    [StorableConstructor]
    protected CodeDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return (interpreter.Configuration.TopLevelPushCode && interpreter.CodeStack.Count < 2) ||
             interpreter.CodeStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<ExecPushExpression>();

      Eval(
        interpreter.CodeStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => ExecPushExpression.Create(pool, v));

      interpreter.CodeStack.Pop();
    }
  }

  [PushExpression(
    StackTypes.Exec,
    "EXEC.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the EXEC stack onto the EXEC stack.",
    StackTypes.Name,
    requiredBlockCount: 1)]
  [StorableClass]
  public class ExecDefineExpression : DefineExpression<Expression> {
    public ExecDefineExpression() { }
    [StorableConstructor]
    protected ExecDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.ExecStack.Count < 2 ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<ExecPushExpression>();

      Eval(
        interpreter.ExecStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => ExecPushExpression.Create(pool, v));

      interpreter.ExecStack.Pop();
    }
  }

  [PushExpression(
    StackTypes.Float,
    "FLOAT.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the FLOAT stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class FloatDefineExpression : DefineExpression<double> {
    public FloatDefineExpression() { }
    [StorableConstructor]
    protected FloatDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.FloatStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<FloatPushExpression>();

      Eval(
        interpreter.FloatStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => FloatPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.Integer,
    "INTEGER.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the INTEGER stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class IntegerDefineExpression : DefineExpression<long> {
    public IntegerDefineExpression() { }
    [StorableConstructor]
    protected IntegerDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.IntegerStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<IntegerPushExpression>();

      Eval(
        interpreter.IntegerStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => IntegerPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.Boolean,
    "BOOLEAN.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the BOOLEAN stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class BooleanDefineExpression : DefineExpression<bool> {
    public BooleanDefineExpression() { }
    [StorableConstructor]
    protected BooleanDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.BooleanStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<BooleanPushExpression>();

      Eval(
        interpreter.BooleanStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => BooleanPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.Char,
    "CHAR.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the CHAR stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class CharDefineExpression : DefineExpression<char> {
    public CharDefineExpression() { }
    [StorableConstructor]
    protected CharDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.CharStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<CharPushExpression>();

      Eval(
        interpreter.CharStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => CharPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.String,
    "STRING.DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the STRING stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class StringDefineExpression : DefineExpression<string> {
    public StringDefineExpression() { }
    [StorableConstructor]
    protected StringDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.StringStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<StringPushExpression>();

      Eval(
        interpreter.StringStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => StringPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.IntegerVector,
    "INTEGER[].DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the INTEGER[] stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class IntegerVectorDefineExpression : DefineExpression<IReadOnlyList<long>> {
    public IntegerVectorDefineExpression() { }
    [StorableConstructor]
    protected IntegerVectorDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.IntegerVectorStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<IntegerVectorPushExpression>();

      Eval(
        interpreter.IntegerVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => IntegerVectorPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.FloatVector,
    "FLOAT[].DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the FLOAT[] stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class FloatVectorDefineExpression : DefineExpression<IReadOnlyList<double>> {
    public FloatVectorDefineExpression() { }
    [StorableConstructor]
    protected FloatVectorDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.FloatVectorStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<FloatVectorPushExpression>();

      Eval(
        interpreter.FloatVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => FloatVectorPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.BooleanVector,
    "BOOLEAN[].DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the BOOLEAN[] stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class BooleanVectorDefineExpression : DefineExpression<IReadOnlyList<bool>> {
    public BooleanVectorDefineExpression() { }
    [StorableConstructor]
    protected BooleanVectorDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.BooleanVectorStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<BooleanVectorPushExpression>();

      Eval(
        interpreter.BooleanVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => BooleanVectorPushExpression.Create(pool, v));
    }
  }

  [PushExpression(
    StackTypes.StringVector,
    "STRING[].DEFINE",
    "Defines the name on top of the NAME stack as an instruction that will push the top item of the STRING[] stack onto the EXEC stack.",
    StackTypes.Name)]
  [StorableClass]
  public class StringVectorDefineExpression : DefineExpression<IReadOnlyList<string>> {
    public StringVectorDefineExpression() { }
    [StorableConstructor]
    protected StringVectorDefineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.StringVectorStack.IsEmpty ||
             interpreter.NameStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      var pool = interpreter.PoolContainer.GetStatefulExpressionPool<BooleanVectorPushExpression>();

      Eval(
        interpreter.StringVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => StringVectorPushExpression.Create(pool, v));
    }
  }
}