source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs @ 14744

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.Linq;

  /// <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 PushStack<T> : IStack<T> {
    private const string Delimiter = " ";

    private readonly List<T> data;

    public PushStack(int capacity = 0) {
      data = new List<T>(capacity);
      IsEnabled = true;
    }

    public bool IsEnabled { get; set; }

    public int Capacity
    {
      get
      {
        return this.data.Capacity;
      }
    }

    public T Top
    {
      get
      {
        return this.data[this.Count - 1];
      }
    }

    public T TopOrDefault
    {
      get
      {
        return this.Count > 0 ? this.data[this.Count - 1] : default(T);
      }
    }

    public T Bottom
    {
      get
      {
        return this.data[0];
      }
    }

    public T BottomOrDefault
    {
      get
      {
        return this.Count > 0 ? this.data[0] : default(T);
      }
    }

    public int Count
    {
      get
      {
        return this.data.Count;
      }
    }

    public bool IsEmpty
    {
      get
      {
        return this.Count == 0;
      }
    }

    public bool IsReadOnly
    {
      get
      {
        return false;
      }
    }

    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 ReverseElementAt(int offset) {
      return this.data[this.data.Count - 1 - offset];
    }

    public void SetTop(T value) {
      this.data[this.Count - 1] = value;
    }

    public T this[int key]
    {
      get
      {
        return this.data[key];
      }
      set
      {
        this.data[key] = value;
      }
    }

    public void Swap(int count) {
      var top = this.Top;
      var bottomIndex = this.Count - count;

      for (var i = this.Count - 1; i > bottomIndex; i--) this.data[i] = this.data[i - 1];

      this.data[bottomIndex] = top;
    }

    public void Yank(int index) {
      if (index == this.Count - 1) return;

      var item = this.ElementAt(index);
      this.data.RemoveAt(index);
      this.data.Add(item);
    }

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

      return value;
    }

    public T[] Pop(int count) {
      var items = Peek(count);
      this.Remove(count);

      return items;
    }

    public T Peek() {
      return Top;
    }

    public T[] Peek(int count) {
      var startIndex = this.Count - count;

      var items = new T[count];
      this.data.CopyTo(startIndex, items, 0, count);

      return items;
    }

    public void Push(T item) {
      if (!IsEnabled) return;

      this.data.Add(item);
    }

    public void PushResult(int count, Func<T[], T> templateFunc) {
      if (!IsEnabled) return;

      var startIndex = this.Count - count;
      var items = new T[count];

      this.data.CopyTo(startIndex, items, 0, count);
      this.Remove(count - 1);

      this.data[this.Count - 1] = templateFunc(items);
    }

    public void Push(params T[] items) {
      if (!IsEnabled) return;

      for (var i = 0; i < items.Length; i++) this.data.Add(items[i]);
      //this.data.AddRange(items);
    }

    public void ReversePush(params T[] items) {
      for (var i = items.Length - 1; i >= 0; i--) this.data.Add(items[i]);
    }

    public void Push(IReadOnlyList<T> items) {
      if (!IsEnabled) return;

      for (var i = 0; i < items.Count; i++) this.data.Add(items[i]);
      //this.data.AddRange(items);
    }

    public void Insert(int index, T item) {
      if (!IsEnabled) return;

      this.data.Insert(index, item);
    }

    public void Insert(int index, params T[] items) {
      if (!IsEnabled) return;

      this.data.InsertRange(index, items);
    }

    public void Insert(int index, IEnumerable<T> items) {
      if (!IsEnabled) return;

      this.data.InsertRange(index, items);
    }

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

    public void RemoveTop() {
      this.data.RemoveAt(this.Count - 1);
    }

    public void Remove(int count) {
      for (var i = 0; i < count; i++) this.data.RemoveAt(this.Count - 1);
    }

    public void RemoveAt(int index) {
      this.data.RemoveAt(index);
    }

    public void RemoveAt(int index, int count) {
      this.data.RemoveRange(index, count);
    }

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

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

    public override string ToString() {
      var data = this.data as IEnumerable<T>;
      return string.Join(Delimiter, data.Reverse());
    }
  }
}