source: addons/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs

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

  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;

  using Interpreter;
  using Stack;

  /// <summary>
  /// Empties the given stack.
  /// </summary>
  /// <typeparam name="T">Stacktype</typeparam>
  [StorableClass]
  public abstract class FlushExpression<T> : StatelessExpression {
    protected FlushExpression() { }
    [StorableConstructor]
    protected FlushExpression(bool deserializing) : base(deserializing) { }

    protected void Eval(IPushStack<T> stack) {
      stack.Clear();
    }
  }

  [PushExpression(
    StackTypes.Integer,
    "INTEGER.FLUSH",
    "Empties the INTEGER stack.")]
  [StorableClass]
  public class IntegerFlushExpression : FlushExpression<long> {
    public IntegerFlushExpression() { }
    [StorableConstructor]
    protected IntegerFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.IntegerStack);
    }
  }

  [PushExpression(
    StackTypes.Float,
    "FLOAT.FLUSH",
    "Empties the FLOAT stack.")]
  [StorableClass]
  public class FloatFlushExpression : FlushExpression<double> {
    public FloatFlushExpression() { }
    [StorableConstructor]
    protected FloatFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.FloatStack);
    }
  }

  [PushExpression(
    StackTypes.Boolean,
    "BOOLEAN.FLUSH",
    "Empties the BOOLEAN stack.")]
  [StorableClass]
  public class BooleanFlushExpression : FlushExpression<bool> {
    public BooleanFlushExpression() { }
    [StorableConstructor]
    protected BooleanFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.BooleanStack);
    }
  }

  [PushExpression(
    StackTypes.Name,
    "NAME.FLUSH",
    "Empties the NAME stack.")]
  [StorableClass]
  public class NameFlushExpression : FlushExpression<string> {
    public NameFlushExpression() { }
    [StorableConstructor]
    protected NameFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.NameStack);
    }
  }

  [PushExpression(
    StackTypes.Exec,
    "EXEC.FLUSH",
    "Empties the EXEC stack.")]
  [StorableClass]
  public class ExecFlushExpression : FlushExpression<Expression> {
    public ExecFlushExpression() { }
    [StorableConstructor]
    protected ExecFlushExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.ExecStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.ExecStack);
    }
  }

  [PushExpression(
    StackTypes.Code,
    "CODE.FLUSH",
    "Empties the CODE stack.")]
  [StorableClass]
  public class CodeFlushExpression : FlushExpression<Expression> {
    public CodeFlushExpression() { }
    [StorableConstructor]
    protected CodeFlushExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return interpreter.CodeStack.IsEmpty;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.CodeStack);
    }
  }

  [PushExpression(
    StackTypes.Char,
    "CHAR.FLUSH",
    "Empties the CHAR stack.")]
  [StorableClass]
  public class CharFlushExpression : FlushExpression<char> {
    public CharFlushExpression() { }
    [StorableConstructor]
    protected CharFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.CharStack);
    }
  }

  [PushExpression(
    StackTypes.String,
    "STRING.FLUSH",
    "Empties the STRING stack.")]
  [StorableClass]
  public class StringFlushExpression : FlushExpression<string> {
    public StringFlushExpression() { }
    [StorableConstructor]
    protected StringFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.StringStack);
    }
  }

  [PushExpression(
    StackTypes.IntegerVector,
    "INTEGER[].FLUSH",
    "Empties the INTEGER[] stack.")]
  [StorableClass]
  public class IntegerVectorFlushExpression : FlushExpression<IReadOnlyList<long>> {
    public IntegerVectorFlushExpression() { }
    [StorableConstructor]
    protected IntegerVectorFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.IntegerVectorStack);
    }
  }

  [PushExpression(
    StackTypes.FloatVector,
    "FLOAT[].FLUSH",
    "Empties the FLOAT[] stack.")]
  [StorableClass]
  public class FloatVectorFlushExpression : FlushExpression<IReadOnlyList<double>> {
    public FloatVectorFlushExpression() { }
    [StorableConstructor]
    protected FloatVectorFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.FloatVectorStack);
    }
  }

  [PushExpression(
    StackTypes.BooleanVector,
    "BOOLEAN[].FLUSH",
    "Empties the BOOLEAN[] stack.")]
  [StorableClass]
  public class BooleanVectorFlushExpression : FlushExpression<IReadOnlyList<bool>> {
    public BooleanVectorFlushExpression() { }
    [StorableConstructor]
    protected BooleanVectorFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.BooleanVectorStack);
    }
  }

  [PushExpression(
    StackTypes.StringVector,
    "STRING[].FLUSH",
    "Empties the STRING[] stack.")]
  [StorableClass]
  public class StringVectorFlushExpression : FlushExpression<IReadOnlyList<string>> {
    public StringVectorFlushExpression() { }
    [StorableConstructor]
    protected StringVectorFlushExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.StringVectorStack);
    }
  }
}