source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Stack/PushGPStack.cs @ 14328

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

namespace HeuristicLab.Algorithms.PushGP.Stack
{
    /// <summary>
    /// While Push's stacks are generally treated as genuine stacks---that is, inclassions take their arguments from the tops of
    /// the stacks and push their results onto the tops of the stacks---a few inclassions (like YANK and SHOVE) do allow direct access
    /// to "deep" stack elements by means of integer indices. To this extent the stacks can be used as general, random access memory
    /// classures. This is one of the features that ensures the Turing-completeness of Push (another being the arbitrary name/value
    /// bindings supported by the NAME data type and DEFINE methods; see below).
    /// </summary>
    /// <typeparam name="T">The item type of the collection.</typeparam>
    public class PushGPStack<T> : IStack<T>
    {
        private readonly List<T> data;
        private const string delimiter = " ";

        public PushGPStack(int capacity = 0)
        {
            this.data = new List<T>();
        }

        public T Top { get { return this.data[Count - 1]; } }
        public int Count { get { return this.data.Count; } }
        public int Capacity { get { return this.data.Capacity; } }
        public bool IsEmpty { get { return this.Count == 0; } }

        public bool IsReadOnly
        {
            get
            {
                throw new NotImplementedException();
            }
        }

        public void Add(T item)
        {
            this.Push(item);
        }

        public void Clear()
        {
            this.data.Clear();
        }

        public bool Contains(T item)
        {
            return this.data.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            this.data.CopyTo(array, arrayIndex);
        }

        public IEnumerator<T> GetEnumerator()
        {
            return this.data.GetEnumerator();
        }

        public T ElementAt(int index)
        {
            return this.data[index];
        }

        public T Pop()
        {
            var value = this.data[Count - 1];
            this.data.RemoveAt(Count - 1);

            return value;
        }

        public T[] Pop(int count)
        {
            var startIndex = Count - count;
            var items = this.data.GetRange(startIndex, count);

            this.data.RemoveRange(startIndex, count);

            // is faster than remove range??
            for (var i = this.Count - 1; i > startIndex - 1; i--)
            {
                this.data.RemoveAt(i);
            }

            return items.ToArray();
        }

        public void Push(T item)
        {
            this.data.Add(item);
        }

        public void Push(params T[] items)
        {
            foreach (var item in items)
            {
                this.data.Add(item);
            }
        }

        public void Push(IEnumerable<T> items)
        {
            this.data.AddRange(items);
        }

        public void Insert(int index, T item)
        {
            this.data.Insert(index, item);
        }

        public void Insert(int index, params T[] items)
        {
            this.data.InsertRange(index, items);
        }

        public void Insert(int index, IEnumerable<T> items)
        {
            this.data.InsertRange(index, items);
        }

        public bool Remove(T item)
        {
            var index = Count - 1;
            if (this.Count > 0 && this.data[index].Equals(item))
            {
                this.data.RemoveAt(index);
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool TryPop(out T item)
        {
            if (this.Count > 0)
            {
                item = this.Pop();
                return true;
            }
            else
            {
                item = default(T);
                return false;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return (this.data as IEnumerable).GetEnumerator();
        }

        public override string ToString()
        {
            if (this.Count == 0)
            {
                return string.Empty;
            }

            var sb = new StringBuilder();

            for (var i = this.Count - 1; i > 0; i--)
            {
                sb.Append(this.data[i] + delimiter);
            }

            sb.Append(this.data[0]);

            return sb.ToString();
        }
    }
}