source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs @ 15017

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System.Collections.Generic;
  using System.Globalization;
  using System.Text;
  using Attributes;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
  using Interpreter;
  using Stack;

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.NEWLINE")]
  public class PrintNewLineExpression : StatelessExpression {
    public PrintNewLineExpression() { }
    [StorableConstructor]
    protected PrintNewLineExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return false;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      interpreter.PrintStack.Push(string.Empty);
    }
  }

  [StorableClass]
  public abstract class PrintExpression<T> : StatelessExpression {
    protected PrintExpression() { }
    [StorableConstructor]
    protected PrintExpression(bool deserializing) : base(deserializing) { }

    protected void Eval(IInternalPushInterpreter interpreter, IPushStack<T> stack) {
      var value = stack.Pop().ToString();

      if (interpreter.PrintStack.IsEmpty)
        interpreter.PrintStack.Push(value);
      else
        interpreter.PrintStack.Top += value;
    }

    protected void EvalVector(IInternalPushInterpreter interpreter, IPushStack<IReadOnlyList<T>> vectorStack) {
      var sb = new StringBuilder();
      var vector = vectorStack.Pop();

      sb.Append(PushEnvironment.VectorStartSymbol);

      if (vector.Count > 0) {
        sb.Append(vector[0]);

        for (var i = 1; i < vector.Count; i++) {
          sb.Append(PushEnvironment.VectorSeparatorSymbol);
          sb.Append(vector[i]);
        }
      }

      sb.Append(PushEnvironment.VectorEndSymbol);

      var value = sb.ToString();
      interpreter.PrintStack.Push(value);
    }
  }

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTBOOLEAN", StackTypes.Boolean)]
  public class BooleanPrintExpression : PrintExpression<bool> {
    public BooleanPrintExpression() { }
    [StorableConstructor]
    protected BooleanPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTCHAR", StackTypes.Char)]
  public class CharPrintExpression : PrintExpression<char> {
    public CharPrintExpression() { }
    [StorableConstructor]
    protected CharPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTEXEC", StackTypes.Exec, execIn: 1)]
  public class ExecPrintExpression : PrintExpression<Expression> {
    public ExecPrintExpression() { }
    [StorableConstructor]
    protected ExecPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTFLOAT", StackTypes.Float)]
  public class FloatPrintExpression : PrintExpression<double> {
    public FloatPrintExpression() { }
    [StorableConstructor]
    protected FloatPrintExpression(bool deserializing) : base(deserializing) { }

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

    public override void Eval(IInternalPushInterpreter interpreter) {
      var value = interpreter.FloatStack.Pop();
      var str = value.ToString(interpreter.Configuration.FloatStringFormat, CultureInfo.InvariantCulture);

      if (interpreter.PrintStack.IsEmpty)
        interpreter.PrintStack.Push(str);
      else
        interpreter.PrintStack.Top += str;
    }
  }

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTINTEGER", StackTypes.Integer)]
  public class IntegerPrintExpression : PrintExpression<long> {
    public IntegerPrintExpression() { }
    [StorableConstructor]
    protected IntegerPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTSTRING", StackTypes.String)]
  public class StringPrintExpression : PrintExpression<string> {
    public StringPrintExpression() { }
    [StorableConstructor]
    protected StringPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTINTEGERVECTOR", StackTypes.IntegerVector)]
  public class IntegerVectorPrintExpression : PrintExpression<long> {
    public IntegerVectorPrintExpression() { }
    [StorableConstructor]
    protected IntegerVectorPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTFLOATVECTOR", StackTypes.FloatVector)]
  public class FloatVectorPrintExpression : PrintExpression<double> {
    public FloatVectorPrintExpression() { }
    [StorableConstructor]
    protected FloatVectorPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTSTRINGVECTOR", StackTypes.StringVector)]
  public class StringVectorPrintExpression : PrintExpression<string> {
    public StringVectorPrintExpression() { }
    [StorableConstructor]
    protected StringVectorPrintExpression(bool deserializing) : base(deserializing) { }

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

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

  [StorableClass]
  [PushExpression(StackTypes.Print, "PRINT.PRINTBOOLEANVECTOR", StackTypes.BooleanVector)]
  public class BooleanVectorPrintExpression : PrintExpression<bool> {
    public BooleanVectorPrintExpression() { }
    [StorableConstructor]
    protected BooleanVectorPrintExpression(bool deserializing) : base(deserializing) { }

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

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