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

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

  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]
  public class LoopState : 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 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 (this.Body != null)
        hash = hash * 31 + this.Body.GetHashCode();

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

      return hash;
    }
  }

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

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

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

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

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

      this.PushIteration(interpreter);

      return true;
    }

    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(this.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);
  }
}