using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace IntervalAttempt
{
    public class Program
    {
        static void Main(string[] args)
        {
            Int32IntervalI i1 = new Int32IntervalI(0, 100, 10);
            while (i1.hasNext())
            {
                Console.WriteLine(i1.next());
            }

            Int32IntervalD i2 = new Int32IntervalD(0, 100, 10);
            while (i2.hasNext())
            {
                Console.WriteLine(i2.next());
            }
        }
    }

    #region Interface Version
    public interface IBinaryAddition<V>
    {
        V Add(V left, V right);
    }

    public interface IBinaryLessThanOrEqual<V>
    {
        bool LessThan(V left, V right);
    }

    public class Int32IntervalI : IntervalWithInterface<int>
    {
        #region Operators
        private class Int32BinaryAddition : IBinaryAddition<int>
        {
            public int Add(int left, int right)
            {
                return left + right;
            }
        }

        private class Int32BinaryLessThanOrEqual : IBinaryLessThanOrEqual<int>
        {
            public bool LessThan(int left, int right)
            {
                return left <= right;
            }
        }
        #endregion

        private static Int32BinaryAddition adder = new Int32BinaryAddition();
        private static Int32BinaryLessThanOrEqual comparer = new Int32BinaryLessThanOrEqual();

        public Int32IntervalI(int start, int stop, int step)
            : base(start, stop, step, adder, comparer) { }
    }

    public class IntervalWithInterface<T>
    {
        T start;
        T current;
        T stop;
        T step;

        IBinaryAddition<T> adder;
        IBinaryLessThanOrEqual<T> comparer;

        public IntervalWithInterface(T start, T stop, T step, IBinaryAddition<T> adder, IBinaryLessThanOrEqual<T> comparer)
        {
            this.start = start;
            this.current = start;
            this.stop = stop;
            this.step = step;
            this.adder = adder;
            this.comparer = comparer;
        }

        public bool hasNext()
        {
            return comparer.LessThan(current, stop);
        }

        public T next()
        {
            T tmp = current;
            if (hasNext())
            {
                current = adder.Add(current, step);
            }
            return tmp;
        }
    }
    #endregion

    #region Delegate Version
    public delegate V BinaryAddition<V>(V left, V right);

    public delegate bool BinaryLessThanOrEqual<V>(V left, V right);
    
    public class Int32IntervalD : IntervalWithDelegate<int>
    {
        private static BinaryAddition<int> adder = 
            new BinaryAddition<int>(delegate(int left, int right) {
                return left + right;
        });

        private static BinaryLessThanOrEqual<int> comparer = 
            new BinaryLessThanOrEqual<int>(delegate(int left, int right) {
                return left <= right;
        });

        public Int32IntervalD(int start, int stop, int step)
            : base(start, stop, step, adder, comparer) { }
    }


    public class IntervalWithDelegate<T>
    {
        T start;
        T current;
        T stop;
        T step;

        BinaryAddition<T> addBlock;
        BinaryLessThanOrEqual<T> lessThanBlock;

        public IntervalWithDelegate(T start, T stop, T step, BinaryAddition<T> addBlock, BinaryLessThanOrEqual<T> lessThanBlock)
        {
            this.start = start;
            this.current = start;
            this.stop = stop;
            this.step = step;
            this.addBlock = addBlock;
            this.lessThanBlock = lessThanBlock;
        }

        public bool hasNext()
        {
            return lessThanBlock(current, stop);
        }

        public T next()
        {
            T tmp = current;
            if (hasNext())
            {
                current = addBlock(current, step);
            }
            return tmp;
        }
    }
    #endregion
}