source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs @ 14952

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

  using HeuristicLab.Common;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  [Serializable]
  [StorableClass]
  public class LoopState : IDeepCloneable, IPooledObject {
    public static LoopState Create(
      IManagedPool<LoopState> pool,
      Expression body,
      long currentIndex,
      long destinationIndex,
      long incrementor) {
      var state = pool.Get(false);

      state.Body = body;
      state.CurrentIndex = currentIndex;
      state.DestinationIndex = destinationIndex;
      state.Incrementor = incrementor;

      return state;
    }

    public LoopState() { }

    [StorableConstructor]
    protected LoopState(bool deserializing) { }
    protected LoopState(LoopState origin, Cloner cloner) {
      Body = origin.Body;
      CurrentIndex = origin.CurrentIndex;
      DestinationIndex = origin.DestinationIndex;
      Incrementor = origin.Incrementor;
    }

    public Expression Body { get; private set; }
    public long CurrentIndex { get; private set; }
    public long DestinationIndex { get; private set; }
    public long Incrementor { get; private set; }

    private int? hashCode;
    public override int GetHashCode() {
      if (hashCode == null) hashCode = CalcHashCode();
      return hashCode.Value;
    }



    public void Reset() {
      Body = null;
      CurrentIndex = default(long);
      DestinationIndex = default(long);
      Incrementor = default(long);
    }

    private int CalcHashCode() {
      var hash = 19;

      if (Body != null)
        hash = hash * 31 + Body.GetHashCode();

      hash = hash * 31 + CurrentIndex.GetHashCode();
      hash = hash * 31 + DestinationIndex.GetHashCode();
      hash = hash * 31 + Incrementor.GetHashCode();

      return hash;
    }

    public object Clone() {
      return Clone(new Cloner());
    }

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

  [Serializable]
  [StorableClass]
  public abstract class LoopExpression : StatefulExpression<LoopState> {
    protected LoopExpression() : base(new LoopState()) { }
    protected LoopExpression(LoopState state) : base(state) { }
    [StorableConstructor]
    protected LoopExpression(bool deserializing) : base(deserializing) { }

    protected void Eval(IInternalPushInterpreter interpreter, IPushStack<Expression> sourceStack, bool pushCurrentIndex = false) {
      // if not initialized
      if (State.Body == null) {
        if (HasInsufficientArguments(interpreter, sourceStack)) return;

        var state = InitState(interpreter, sourceStack);
        var initLoopExpression = Clone(state, interpreter);

        interpreter.ExecStack.Push(initLoopExpression, state.Body);
        return;
      }

      // if loop end reached
      if (State.DestinationIndex == State.CurrentIndex) {
        PushLastIteration(interpreter);
        return;
      }

      PushIteration(interpreter);
    }

    private string stringRepresentation;
    public override string StringRepresentation
    {
      get
      {
        if (stringRepresentation == null) {
          var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(GetType(), typeof(PushExpressionAttribute));
          stringRepresentation = attribute.ExpressionName;
        }

        return stringRepresentation;
      }
    }

    protected virtual void PushIteration(IInternalPushInterpreter interpreter) {
      interpreter.IntegerStack.Push(State.CurrentIndex);

      var newState = LoopState.Create(
        interpreter.PoolContainer.LoopStatePool,
        State.Body,
        State.CurrentIndex + State.Incrementor,
        State.DestinationIndex,
        State.Incrementor);

      var nextLoopExpression = Clone(newState, interpreter);

      interpreter.ExecStack.Push(nextLoopExpression, State.Body);
    }

    protected virtual void PushLastIteration(IInternalPushInterpreter interpreter) {
      interpreter.IntegerStack.Push(State.CurrentIndex);
      interpreter.ExecStack.Push(State.Body);
    }

    protected abstract LoopExpression Clone(LoopState state, IInternalPushInterpreter interpreter);
    protected abstract bool HasInsufficientArguments(IInternalPushInterpreter interpreter, IPushStack<Expression> sourceStack);
    protected abstract LoopState InitState(IInternalPushInterpreter interpreter, IPushStack<Expression> sourceStack);
  }
}