tpl_dnode.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_DNODE_H
# define TPL_DNODE_H

# include <type_traits>
# include <ahFunction.H>
# include <dlink.H>

using namespace Aleph;

namespace Aleph {

template <typename T> class Dnode : public Dlink 
{
private:

  T data;

public:

  Dnode<T> *& get_next() const noexcept { return (Dnode<T>*&) next; }

  Dnode<T> *& get_prev() const noexcept { return (Dnode<T>*&) prev; }

  Dnode<T>* remove_prev() noexcept { return (Dnode<T>*) Dlink::remove_prev(); }

  Dnode<T>* remove_next() noexcept { return (Dnode<T>*) Dlink::remove_next(); }

  Dnode<T> *& get_first_ne() const noexcept { return get_next(); } 

  Dnode<T> *& get_last_ne() const noexcept { return get_prev(); }

  Dnode<T> *& get_first() const
  {
    if (this->is_empty())
      throw std::underflow_error("Dnode is empty");
    return get_first_ne();
  } 

  Dnode<T> *& get_last() const
  {
    if (this->is_empty())
      throw std::underflow_error("Dnode is empty");
    return get_last_ne();
  }

  Dnode<T>* remove_last_ne() noexcept 
  { 
    return static_cast<Dnode<T>*>(Dlink::remove_prev()); 
  }

  Dnode<T>* remove_first_ne() noexcept
  {
    return static_cast<Dnode<T>*>(Dlink::remove_next()); 
  }

  Dnode<T>* remove_last()
  {
    if (this->is_empty())
      throw std::underflow_error("Dnode is empty");
    return remove_last_ne();
  }

  Dnode<T>* remove_first()
  {
    if (this->is_empty())
      throw std::underflow_error("Dnode is empty");
    return remove_first_ne();
  }
  
  Dnode() noexcept 
  {
    static_assert(std::is_default_constructible<T>::value, 
                  "No default constructor for T");
  }

  Dnode(const T & item) noexcept(noexcept(T(item))) : data(item) 
  {
    static_assert(std::is_copy_constructible<T>::value, 
                  "No copy constructor for T");
  }

  Dnode(T && item) noexcept(noexcept(std::swap(data, item)))
  {
    static_assert(std::is_move_constructible<T>::value,
                  "No move constructor for T");
    std::swap(data, item);
  }

  Dnode & swap(Dnode & p) noexcept(noexcept(std::swap(data, p.data)))
  {
    
    Dlink::swap(p);
    std::swap(data, p.data);
    return *this;
  }

  Dnode(const Dnode & node) noexcept(std::is_nothrow_copy_assignable<T>::value)
  : Dlink(node), data(node.data) 
  {
    static_assert(std::is_copy_constructible<T>::value, 
                  "No copy constructor for T");
  }

  Dnode(Dnode && node) noexcept(noexcept(std::forward<T>(node.data)))
  : Dlink(node), data(std::forward<T>(node.data))
  {
    /* empty */ 
  }

  Dnode & operator = (const Dnode & p) 
  noexcept(std::is_nothrow_copy_assignable<T>::value)
  {
     static_assert(std::is_copy_assignable<T>::value,
                  "No copy assign for T");
    data = p.data;
    return *this;
  }

  Dnode & operator = (Dnode && p) 
  noexcept(std::is_nothrow_move_assignable<T>::value)
  {
    std::swap(data, p.data);
    return *this;
  }

  T & get_data() noexcept { return data; }

  const T & get_data() const noexcept { return data; }

  using key_type = T;

  T & get_key() noexcept { return data; }

  const T & get_key() const noexcept { return data; }

  static Dnode * data_to_node(T & data) noexcept
  {
    Dnode * zero = 0;
    long offset = (long) &(zero->data);
    unsigned long  addr = (unsigned long) (&data);
    return (Dnode*) (addr - offset);
  }

  class Iterator : public Dlink::Iterator
  {
  public:
    
    using Set_Type = Dnode<T>;
    
    using Item_Type = Dnode<T>*;

    using Base = Dlink::Iterator;

    using Base::Base;

    Dnode<T> * get_curr_ne() const noexcept
    {
      return static_cast<Dnode<T>*>(this->Dlink::Iterator::get_curr_ne()); 
    }

    Dnode<T> * get_curr() const 
    {
      return static_cast<Dnode<T>*>(this->Dlink::Iterator::get_curr()); 
    }

    Dnode * del() 
    { return static_cast<Dnode*>(Dlink::Iterator::del()); }
  };
};

template <typename T> Dnode<T> * Dlink::to_dnode() noexcept
{
  return static_cast<Dnode<T>*>(this);
}

template <typename T> const Dnode<T> * Dlink::to_dnode() const noexcept
{
  return static_cast<const Dnode<T>*>(this);
}

template <typename T> T & Dlink::to_data() noexcept
{
  return to_dnode<T>()->get_data();
}

template <typename T> const T & Dlink::to_data() const noexcept
{
  return to_dnode<T>()->get_data();
}


}

# endif /* TPL_DNODE_H */