slink_nc.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 SLINK_NC_H
# define SLINK_NC_H

# include <aleph.H>

namespace Aleph
{
  class Slink_Nc
  {
  protected:
    Slink_Nc * next;
  
  public:
    Slink_Nc() : next(nullptr) { /* empty */ }

    Slink_Nc(const Slink_Nc &) : next(nullptr) { /* empty */ }

    ~Slink_Nc() { /* empty */ }

    Slink_Nc & operator = (const Slink_Nc & link)
    {
      if (&link == this)
        return *this;

      if (not is_empty())
        throw std::invalid_argument("link is not empty");

      next = nullptr; 
    }

    void reset()
    {
      assert(this not_eq nullptr);
      next = nullptr;
    }

    bool is_empty() const
    {
      assert(this not_eq nullptr);
      return next == nullptr;
    }

    Slink_Nc *& get_next()
    {
      assert(this not_eq nullptr);
      return next;
    }

    void insert(Slink_Nc * p)
    {
      assert(this not_eq nullptr);
      assert(p not_eq nullptr);
      assert(p->is_empty());
      p->next = next;
      next = p;
    }

    Slink_Nc * remove_next()
    {
      assert(this not_eq nullptr);
      Slink_Nc * ret_val = next;
      next = ret_val->next;
      ret_val->reset();
      return ret_val;
    }

    class Iterator
    {
      Slink_Nc * head;
      Slink_Nc * curr;
    
    public:
      
      Iterator() : head(nullptr), curr(nullptr) { /* Empty */ }

      Iterator(Slink_Nc * head_ptr) : head(head_ptr), curr(head->get_next())
      { 
        // empty
      }

      Iterator(Slink_Nc & _head) : head(&_head), curr(head->get_next())
      { 
        // empty
      }

      Iterator(Slink_Nc * head_ptr, Slink_Nc * curr_ptr)
        : head(head_ptr), curr(curr_ptr)
      {
        // empty
      }

      void reset_first() 
      {
        assert(curr != nullptr and head != nullptr);
        curr = head->get_next();
      }

      void set(Slink_Nc * new_curr) 
      {
        assert(curr != nullptr and head != nullptr);
        curr = new_curr;
      }

      void reset(Slink_Nc * new_head)
      {
        head = new_head;
        curr = head->get_next();;
      }

      bool has_curr() const 
      {
        assert(head != nullptr);
        return curr != nullptr;
      }

      Slink_Nc * get_curr_ne() noexcept
      {
        assert(curr != nullptr and head != nullptr);
        return curr;
      }

      Slink_Nc * get_curr()  
      {
        if (not has_curr())
          throw std::overflow_error("Not element in list");
        return get_curr_ne();
      }

      bool is_in_first() const { return curr == head->next; }

      void next_ne() noexcept
      {
        curr = curr->get_next();
      }

      void next() throw(std::exception, std::overflow_error)
      {
        if (not has_curr())
          throw std::overflow_error("Not next element in list");
        next_ne();
      }

      bool operator == (const Iterator & it) const { return curr == it.curr; }

      bool operator != (const Iterator & it) const { return curr != it.curr; }
    
      bool verify(Slink_Nc * l) const { return head == l; }

      bool verify(const Iterator & it) const { return head == it.head; }
    };
    
  };
}

# endif