source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/LoopExpression.cs @ 14392

using HeuristicLab.Algorithms.PushGP.Interpreter;
using HeuristicLab.Algorithms.PushGP.Stack;

namespace HeuristicLab.Algorithms.PushGP.Expressions
{
    public abstract class LoopExpression : Expression
    {
        public long destinationIndex;
        public long currentIndex;
        public long incrementor;
        public bool pushCurrentIndex = false;
        public Expression body;

        public LoopExpression(string stringRepresentation) : base(stringRepresentation) { }

        protected void Eval(IInterpreter interpreter, IStack<Expression> sourceStack)
        {
            // if not initialized
            if (body == null)
            {
                if (this.HasInsufficientArguments(interpreter, sourceStack))
                {
                    return;
                }

                this.InitState(interpreter, sourceStack);

                interpreter.ExecStack.Push(this, this.body);

                return;
            }

            // if loop end reached
            if (destinationIndex == currentIndex)
            {
                this.PushLastIteration(interpreter);
                this.Clear();

                return;
            }

            this.PushIteration(interpreter);
            this.currentIndex += this.incrementor;
        }

        protected virtual void Clear()
        {
            this.body = null;
        }

        protected virtual void PushIteration(IInterpreter interpreter)
        {
            interpreter.IntegerStack.Push(this.currentIndex);
            interpreter.ExecStack.Push(this, this.body);
        }

        protected virtual void PushLastIteration(IInterpreter interpreter)
        {
            interpreter.IntegerStack.Push(this.currentIndex);
            interpreter.ExecStack.Push(this.body);
        }

        public override bool Equals(object obj)
        {
            if (!base.Equals(obj))
            {
                return false;
            }

            var other = obj as LoopExpression;

            var isBodyEqual =
                (this.body == null && other.body == null) ||
                (this.body != null && other.body != null && this.body.Equals(other.body));

            return isBodyEqual &&
                this.currentIndex == other.currentIndex &&
                this.destinationIndex == other.destinationIndex &&
                this.incrementor == other.incrementor;
        }

        protected abstract bool HasInsufficientArguments(IInterpreter interpreter, IStack<Expression> sourceStack);
        protected abstract void InitState(IInterpreter interpreter, IStack<Expression> sourceStack);
    }
}