tpl_dynListQueue.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_DYNLISTQUEUE_H
# define TPL_DYNLISTQUEUE_H

# include <iostream>
# include <ahDry.H>
# include <ahIterator.H>
# include <ah-args-ctor.H>
# include <htlist.H>
# include <tpl_dynDlist.H>

using namespace std;


namespace Aleph {

    template <typename T> 
class DynListQueue 
      : public LocateFunctions<DynListQueue<T>, T>,
        public FunctionalMethods<DynListQueue<T>, T>,
        public GenericKeys<DynListQueue<T>, T>,
        public EqualToMethod<DynListQueue<T>>,
        public StlAlephIterator<DynListQueue<T>>
{
  DynList<T> q;
  size_t num_items = 0;

  using Base = DynList<T>;

public:

  void swap(DynListQueue & __q) noexcept
  {
    std::swap(num_items, __q.num_items);
    q.swap(__q.q);
  }

  DynListQueue() noexcept : num_items(0) { /* empty */ }

  DynListQueue(const DynListQueue & __q) : q(__q.q), num_items(__q.num_items)
  {
    // empty
  }

  DynListQueue(DynListQueue && __q) noexcept
  {
    swap(__q);
  }

  Special_Ctors(DynListQueue, T);

  DynListQueue & operator = (const DynListQueue & rhs)
  {
    if (this == &rhs)
      return *this;

    q = rhs.q;
    num_items = rhs.num_items;

    return *this;
  }

  DynListQueue & operator = (DynListQueue && rhs) noexcept
  {
    std::swap(num_items, rhs.num_items);
    q.swap(rhs.q);
    return *this;
  }

  size_t size() const noexcept { return num_items; }

  bool is_empty() const noexcept { return q.is_empty(); }

  using Set_Type = DynListQueue; 

  using Item_Type = T; 

  T & put(const T & data) 
  {
    T & ret_val = q.append(data);
    ++num_items;
    return ret_val;
  }

  T & put(T && data)
  {
    T & ret_val = q.append(std::forward<T>(data));
    ++num_items;
    return ret_val;
  }

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

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

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

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

  T get() 
  {
    T ret_val = q.remove_first();
    --num_items;
    return ret_val;
  }
 
  T & front() const
  {
    return q.get_first();
  }

  T & rear() const 
  {
    return q.get_last();
  } 

  void empty() noexcept
  {
    q.empty();
    num_items = 0;
    assert(q.is_empty());
  }

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

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

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
    noexcept(noexcept(operation))
  {
    return q.traverse(std::forward<Operation>(operation));
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) 
    noexcept(noexcept(operation))
  {
    return q.traverse(std::forward<Operation>(operation));
  }

  struct Iterator : public DynList<T>::Iterator
  {
    using Base = typename DynList<T>::Iterator;
    using Base::Base;

    Iterator(const DynListQueue<T> & q) noexcept : Base(q.q) {}
  };
};

} // end namespace Aleph
# endif // TPL_DYNLISTQUEUE_H