tpl_dynDlist.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef TPL_DYNDLIST_H
#define TPL_DYNDLIST_H
 
#include <ahFunctional.H>
#include <ahDry.H>
#include <ah-dry.H>
#include <ah-args-ctor.H>
#include <ahIterator.H>
#include <ah-iterator.H>
#include <tpl_dnode.H>
#include <stdexcept>
#include <ah-errors.H>
 
namespace Aleph {
 
template <typename T = int>
class DynDlist : public Dnode<T>,
                 public GenericTraverse<DynDlist<T>>,
                 public SpecialCtors<DynDlist<T>, T>,
                 public LocateFunctions<DynDlist<T>, T>,
                 public FunctionalMethods<DynDlist<T>, T>,
                 public GenericItems<DynDlist<T>, T>,
                 public EqualSequenceMethod<DynDlist<T>>,
                 public StlAlephIterator<DynDlist<T>>
{
  size_t num_elem = 0;
 
public:
  using Set_Type = DynDlist;
 
  using Item_Type = T;
 
  using Key_Type = T;
 
  [[nodiscard]] const size_t &size() const noexcept
  {
    return num_elem;
  }
 
  DynDlist() = default;
 
  // using CtorBase = SpecialCtors<DynDlist<T>, T>;
  // using CtorBase::CtorBase;
 
  // /** Construct a new list with copies of elements of list `l`
 
  //     \param[in] l list to be copied
  //     \throw bad_alloc if there is no enough memory
  // */
  // DynDlist(const DynList<T> & l) : Dnode<T>(), CtorBase(l) {}
 
  Special_Ctors(DynDlist, T);
 
  void empty() noexcept  
  {
    while (not this->is_empty())
      delete this->Dnode<T>::remove_next();
 
    num_elem = 0;
  }
 
  void clear() noexcept { empty(); }
 
  ~DynDlist()  
  {
    empty();
  }
 
private:
  T &_insert(Dnode<T> *p) noexcept
  {
    Dnode<T>::insert(p);
    ++num_elem;
    return p->get_data();
  }
 
  T &_append(Dnode<T> *p) noexcept
  {
    Dnode<T>::append(p);
    ++num_elem;
    return p->get_data();
  }
 
public:
  T &insert(const T &item)
  {
    return _insert(new Dnode<T>(item));
  }
 
  T &insert(T &&item)
  {
    return _insert(new Dnode<T>(std::forward<T>(item)));
  }
 
  T &append(const T &item)
  {
    return _append(new Dnode<T>(item));
  }
 
  T &append(T &&item)
  {
    return _append(new Dnode<T>(std::forward<T>(item)));
  }
 
private:
  void _insert(DynDlist<T> &list) noexcept
  {
    Dlink::insert_list(&list);
    num_elem += list.num_elem;
    list.num_elem = 0;
 
    assert(list.is_empty());
  }
 
  void _append(DynDlist<T> &list) noexcept
  {
    Dlink::append_list(&list);
    num_elem += list.num_elem;
    list.num_elem = 0;
 
    assert(list.is_empty());
  }
 
public:
  void insert(const DynDlist &list)
  {
    auto l = list;  // perform a copy of list
    _insert(l);
  }
 
  void insert(DynDlist &&list) noexcept
  {
    _insert(list);
  }
 
  void append(const DynDlist &list)
  {
    auto l = list;  // perform a copy of list
    _append(l);
  }
 
  void append(DynDlist &&list) noexcept
  {
    _append(list);
  }
 
  T &get_first_ne() const noexcept
  {
    return this->get_next()->get_data();
  }
 
  T &get_last_ne() const noexcept
  {
    return this->get_prev()->get_data();
  }
 
  T &get_first() const
  {
    ah_underflow_error_if(this->is_empty()) << "DynDlist is empty";
    return get_first_ne();
  }
 
  T &get_last() const
  {
    ah_underflow_error_if(this->is_empty()) << "DynDlist is empty";
    return get_last_ne();
  }
 
  T remove_first_ne() noexcept
  {
    Dnode<T> *ptr = this->remove_next();
    T retVal = ptr->get_data();
    delete ptr;
    --num_elem;
 
    return retVal;
  }
 
  T remove_last_ne() noexcept
  {
    Dnode<T> *ptr = this->remove_prev();
    T retVal = ptr->get_data();
    delete ptr;
    --num_elem;
 
    return retVal;
  }
 
  T remove_first()
  {
    ah_underflow_error_if(this->is_empty()) << "DynDlist is empty";
    return remove_first_ne();
  }
 
  T remove_last()
  {
    ah_underflow_error_if(this->is_empty()) << "DynDlist is empty";
    return remove_last_ne();
  }
 
  T &put(const T &item)
  {
    return append(item);
  }
 
  T &put(T &&item)
  {
    return append(std::forward<T>(item));
  }
 
  T get()
  {
    return remove_first();
  }
 
  T &rear()
  {
    return get_last();
  }
 
  T &front()
  {
    return get_first();
  }
 
  T &push(const T &item)
  {
    return insert(item);
  }
 
  T &push(T &&item)
  {
    return insert(std::forward<T>(item));
  }
 
  T pop()
  {
    return remove_first();
  }
 
  T &top() const
  {
    return get_first();
  }
 
  void remove(T &data) noexcept
  {
    Dnode<T> *p = Dnode<T>::data_to_node(data);
    p->del();
    delete p;
    --num_elem;
  }
 
  void erase(T &data) noexcept
  {
    remove(data);
  }
 
  void swap(DynDlist &l) noexcept
  {
    std::swap(num_elem, l.num_elem);
    this->Dlink::swap(&l);
  }
 
  void split_list_ne(DynDlist &l, DynDlist &r) noexcept
  {
    Dlink::split_list(l, r);
 
    const auto count_nodes = [](const DynDlist &list) noexcept -> size_t
    {
      size_t count = 0;
      for (auto it = list.get_it(); it.has_curr(); it.next_ne())
        ++count;
      return count;
    };
 
    l.num_elem = count_nodes(l);
    r.num_elem = count_nodes(r);
    num_elem = 0;
  }
 
  void split_list(DynDlist &l, DynDlist &r)
  {
    ah_domain_error_if((not l.is_empty()) or (not r.is_empty())) << "lists are not empty";
    split_list_ne(l, r);
  }
 
  void split(DynDlist &l, DynDlist &r)
  {
    split_list(l, r);
  }
 
  class Iterator : public Dnode<T>::Iterator
  {
    DynDlist *list_ptr;  // Pointer to list
    long pos;            // Position of the current element in the sequence
 
    using Base = typename Dnode<T>::Iterator;
 
  public:
    using Set_Type = DynDlist;
 
    using Item_Type = T;
 
    [[nodiscard]] long get_pos() const noexcept
    {
      return pos;
    }
 
    void next_ne() noexcept
    {
      Dnode<T>::Iterator::next_ne();
      pos++;
    }
 
    void next()
    {
      Dnode<T>::Iterator::next();
      pos++;
    }
 
    void prev()
    {
      Dnode<T>::Iterator::prev();
      pos--;
    }
 
    void reset_first() noexcept
    {
      Dnode<T>::Iterator::reset_first();
      pos = 0;
    }
 
    void reset_last() noexcept
    {
      Dnode<T>::Iterator::reset_last();
      pos = list_ptr->num_elem - 1;
    }
 
    void end() noexcept
    {
      put_itor_at_the_end(*this);
    }
 
    Iterator(const DynDlist<T> &list) noexcept
      : Base(list), list_ptr(&const_cast<DynDlist &>(list)), pos(0)
    {
      // empty
    }
 
    Iterator() noexcept : list_ptr(nullptr)
    { /* empty */
    }
 
    Iterator(const Iterator &) = default;
 
    Iterator &operator=(const Iterator &it) noexcept
    {
      if (this == &it)
        return *this;
      Dnode<T>::Iterator::operator=(it);
      list_ptr = it.list_ptr;
      pos = it.pos;
 
      return *this;
    }
 
    T &get_curr() const
    {
      return Dnode<T>::Iterator::get_curr()->get_data();
    }
 
    T &get_curr_ne() const noexcept
    {
      return Dnode<T>::Iterator::get_curr_ne()->get_data();
    }
 
    void insert(const T &item)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->insert(new Dnode<T>(item));
      ++list_ptr->num_elem;
    }
 
    void insert(T &&item)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->insert(new Dnode<T>(std::forward<T>(item)));
      ++list_ptr->num_elem;
    }
 
    void append(const T &item)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->append(new Dnode<T>(item));
      ++list_ptr->num_elem;
    }
 
    void append(T &&item)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->append(new Dnode<T>(std::forward<T>(item)));
      ++list_ptr->num_elem;
    }
 
    void insert_list(DynDlist &list)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->insert_list(&list);
      list_ptr->num_elem += list.num_elem;
      list.num_elem = 0;
 
      assert(list.is_empty());
    }
 
    void append_list(DynDlist &list)
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T>::Iterator::get_curr()->append_list(&list);
      list_ptr->num_elem += list.num_elem;
      list.num_elem = 0;
 
      assert(list.is_empty());
    }
 
    T del()
    {
      ah_overflow_error_if(not this->has_curr()) << "DynDlist Iterator has not current";
 
      Dnode<T> *ptr = Dnode<T>::Iterator::get_curr();
      T ret_val = ptr->get_data();
      Dnode<T>::Iterator::next();
      ptr->del();
      delete ptr;
      --list_ptr->num_elem;
      return ret_val;
    }
  };
 
  DynDlist<T> &operator=(const DynDlist &list)
  {
    if (this == &list)
      return *this;
 
    empty();
 
    for (Iterator itor(const_cast<DynDlist &>(list)); itor.has_curr(); itor.next_ne())
      this->append(itor.get_curr());
 
    return *this;
  }
 
  DynDlist(const DynDlist &list) : DynDlist()
  {
    assert(this->is_empty());
 
    for (Iterator itor(const_cast<DynDlist &>(list)); itor.has_curr(); itor.next_ne())
      this->append(itor.get_curr());
  }
 
  DynDlist(DynDlist<T> &&list) noexcept : DynDlist()
  {
    swap(list);
  }
 
  DynDlist<T> &operator=(DynDlist &&list) noexcept
  {
    swap(list);
    return *this;
  }
 
  T &operator[](const size_t n) const
  {
    auto it = this->get_it();
    for (size_t i = 0; i < n && it.has_curr(); ++i)
      it.next_ne();
 
    ah_out_of_range_error_if(not it.has_curr()) << "DynDlist index out of range";
 
    return it.get_curr();
  }
 
  DynDlist &reverse() noexcept
  {
    Dlink::reverse();
    return *this;
  }
 
  DynDlist &rev() noexcept
  {
    return reverse();
  }
 
  DynDlist<T> reverse() const
  {
    DynDlist<T> ret;
    for (auto it = this->get_it(); it.has_curr(); it.next_ne())
      ret.insert(it.get_curr());
    return ret;
  }
 
  DynDlist<T> rev() const
  {
    return reverse();
  }
};
 
}  // end namespace Aleph
 
#endif /* TPL_DYNDLIST_H */