tpl_array.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_ARRAY_H
# define TPL_ARRAY_H

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

using namespace std;

using namespace Aleph;

namespace Aleph {

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

public:

  using Item_Type = T; 

  Array(size_t dim = 32) : array(dim) { /* empty */ }

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

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

  Special_Ctors(Array, T);

  Args_Ctor(Array, T);

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

    array = s.array;

    return *this;
  }

  void swap(Array & s) noexcept
  {
    array.swap(s.array);
  }

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

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

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

  Array & append(const Array & a)
  {
    array.append(a.array);
    return *this;
  }

  Array append(const Array & a) const
  {
    Array ret = *this;
    return ret.append(a);
  }

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

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

  void putn(const size_t n) { array.putn(n); }

  void reserve(size_t cap) { array.reserve(cap); }

  T & base() const noexcept { return *array.get_ptr(); }

  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(); }

  T & get_first() const { return array.first(); }

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

  T remove_last() { return array.remove_last(); }

  T remove_first() { return array.remove_first(); }

  T & operator [] (size_t i) const
  {
    return array[i];
  }

  T & operator () (const size_t i) const noexcept
  {
    return array(i);
  }

  Array & reverse()
  {
    array.reverse();
    return *this;
  }

  Array reverse() const
  {
    const size_t & n = array.size();
    Array ret(n);
    for (size_t i = 0; i < n; ++i)
      ret.append(array(n - i - 1));
    return ret;
  }

  Array & rev() { return reverse(); }

  const Array rev() const { return reverse(); }

  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);
  }

  bool is_valid() const noexcept { return array.is_valid(); }

  struct Iterator : public MemArray<T>::Iterator
  {
    using Base = typename MemArray<T>::Iterator;
    using Base::Base;
    using Set_Type = Array;

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

    template <typename T, typename ... Args>
Array<T> build_array(Args ... args)
{
  return build_container<Array<T>>(args...);
}


} // end namespace Aleph

# endif /* TPL_ARRAY_H */