tpl_arrayStack.H

/* Aleph-w

     / \  | | ___ _ __ | |__      __      __
    / _ \ | |/ _ \ '_ \| '_ \ ____\ \ /\ / / Data structures & Algorithms
   / ___ \| |  __/ |_) | | | |_____\ V  V /  version 1.9b
  /_/   \_\_|\___| .__/|_| |_|      \_/\_/   https://github.com/lrleon/Aleph-w
                 |_|

  This file is part of Aleph-w library

  Copyright (c) 2002-2018 Leandro Rabindranath Leon & Alejandro Mujica

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program. If not, see <https://www.gnu.org/licenses/>.
*/

# ifndef TPL_ARRAYSTACK_H
# define TPL_ARRAYSTACK_H

# include <iostream>
# include <aleph.H>
# include <htlist.H>
# include <tpl_dynDlist.H>
# include <ah-args-ctor.H>
# include <ah-dry.H>
# include <tpl_memArray.H>

using namespace std;

using namespace Aleph;

namespace Aleph {

    template <typename T>
class ArrayStack : public LocateFunctions<ArrayStack<T>, T>,
                   public FunctionalMethods<ArrayStack<T>, T>,
                   public GenericKeys<ArrayStack<T>, T>,
                   public EqualToMethod<ArrayStack<T>>,
                   public StlAlephIterator<ArrayStack<T>>
{
  MemArray<T> array;

public:

  using Item_Type = T; 

  ArrayStack(size_t dim = 4) : array(dim) { /* empty */ }

  ArrayStack(const ArrayStack & s) : array(s.array) { /* empty */ }

  ArrayStack(ArrayStack && s)
    : array(std::forward<MemArray<T>>(s.array)) { /* empty */ }

  Special_Ctors(ArrayStack, T);

  ArrayStack & operator = (const ArrayStack & s)
  {
    if (this == &s)
      return *this;

    array = s.array;

    return *this;
  }

  void swap(ArrayStack & s) noexcept
  {
    std::swap(*this, s);
  }

  ArrayStack & operator = (ArrayStack && s) noexcept
  {
    array.swap(s.array);
    return *this;
  }

  T & push(const T & data)
  {
    return array.put(data);
  }

  T & push(T && data)
  {
    return array.put(std::forward<T>(data));
  }

  T & append(const T & data) { return push(data); }

  T & append(T && data) { return push(std::forward<T>(data)); }

  T & insert(const T & data) { return push(data); }

  T & insert(T && data) { return push(std::forward<T>(data)); }

  T & pushn(const size_t & n = 1)
  {
    array.putn(n);
    return array.last();
  }

  T pop()
  {
    return array.get(1);
  }

  T pop_ne() noexcept
  {
    return array.get_ne(1);
  }

  T popn(size_t n)
  {
    return array.get(n);
  }

  T & top() const
  {
    return array.last();
  }

  T & base() noexcept
  {
    return array.first();
  }

  T & top(size_t i) const
  {
    const size_t sz = array.size();
    if (i >= sz)
      throw std::out_of_range("top index out of range");
    return array.access(sz - i - 1);
  }

  T & get_last() const { return top(); }

  void empty() noexcept { array.empty(); }

  bool is_empty() const noexcept { return array.size() == 0; }

  size_t size() const noexcept { return array.size(); }

  size_t capacity() const noexcept { return array.capacity(); }

  template <class Operation>
  bool traverse(Operation & operation) noexcept(noexcept(operation))
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation & operation) const noexcept(noexcept(operation))
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
    noexcept(noexcept(operation))
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation())
    noexcept(noexcept(operation))
  {
    return array.traverse(operation);
  }

  class Iterator : public MemArray<T>::Iterator
  {
  public:

    using Base = typename MemArray<T>::Iterator;
    using Set_Type = ArrayStack;

    using Base::Base;

    Iterator(const ArrayStack<T> & s) : Base(s.array) {}
  };
};

    template <typename T>
class FixedStack : public LocateFunctions<FixedStack<T>, T>,
                   public FunctionalMethods<FixedStack<T>, T>,
                   public GenericKeys<FixedStack<T>, T>,
                   public EqualToMethod<FixedStack<T>>,
                   public StlAlephIterator<FixedStack<T>>
{
  T *    array = nullptr;
  size_t head = 0;
  size_t dim = 0;

public:

  using Item_Type = T; 

  FixedStack(size_t d = 1024)
    // Don't change the default value because you would risk of
    // breaking the tests
    : array(new T[d]), head(0), dim(d)
  {
    /* empty */
  }

  ~FixedStack()
  {
    if (array)
      delete [] array;
  }

  FixedStack(const FixedStack & s)
    : array(new T [s.dim]), head(s.head), dim(s.dim)
  {
    for (int i = 0; i < head; ++i)
      array[i] = s.array[i];
  }

  Special_Ctors(FixedStack, T);

  void swap(FixedStack & s) noexcept
  {
    std::swap(array, s.array);
    std::swap(head, s.head);
    std::swap(dim, s.dim);
  }

  FixedStack(FixedStack && s) noexcept
    : array(nullptr), head(0), dim(0)
  {
    swap(s);
  }

  FixedStack & operator = (const FixedStack & s)
  {
    if (this == &s)
      return *this;

    T * ptr = new T [s.dim];
    if (array)
      delete [] array;
    array = ptr;
    for (size_t i = 0; i < s.head; ++i)
      array[i] = s.array[i];
    head  = s.head;
    dim   = s.dim;

    return *this;
  }

  FixedStack & operator = (FixedStack && s) noexcept
  {
    swap(s);
    return *this;
  }

  T & push(const T & data) noexcept
  {
    assert(head < dim);
    array[head++] = data;
    return array[head - 1];
  }

  T & push(T && data) noexcept
  {
    assert(head < dim );
    std::swap(array[head++], data);
    return array[head - 1];
  }

  T & append(const T & data) noexcept { return push(data); }

  T & append(T && data) noexcept { return push(std::forward<T>(data)); }

  T & insert(const T & data) noexcept { return push(data); }

  T & insert(T && data) noexcept { return push(std::forward<T>(data)); }

  T & pushn(const size_t & n = 1) noexcept
  {
    assert(head + n <= dim);

    head += n;
    return array[head - 1];
  }

  T pop() noexcept
  {
    assert(head > 0);

    return std::move(array[--head]);
  }

  T popn(const int & n) noexcept
  {
    assert((int (head - n)) >= 0);

    head -= n;
    return std::move(array[head]);
  }

  T & top() const noexcept
  {
    assert(head > 0);

    return array[head - 1];
  }

  T & get_last() const noexcept { return top(); }

  T & base() const noexcept { return array[0]; }

  T & top(size_t i) const noexcept
  {
    assert(i < head);
    return array[head - i - 1];
  }

  bool is_empty() const noexcept { return head == 0; }

  void empty() noexcept { head = 0; }

  size_t size() const noexcept { return head; }

  template <class Operation>
    bool traverse(Operation & operation) noexcept(noexcept(operation))
  {
    for (int i = 0; i < head; i++)
      if (not operation(array[i]))
        return false;

    return true;
  }

  template <class Operation>
    bool traverse(Operation & operation) const noexcept(noexcept(operation))
  {
    return const_cast<FixedStack*>(this)->traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation())
    const noexcept(noexcept(operation))
  {
    return traverse<Operation>(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation())
    noexcept(noexcept(operation))
  {
    return traverse<Operation>(operation);
  }

  class Iterator : public Array_Iterator<T>
  {
  public:

    using Base = Array_Iterator<T>;
    using Base::Base;
    using Set_Type = FixedStack;

    Iterator(const FixedStack<T> & s)
      : Base(no_exception_ctor, s.array, s.dim, s.head) {}
  };
};

} // end namespace Aleph

# endif /* TPL_ARRAYSTACK_H */