tpl_slist.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_SLIST_H
# define TPL_SLIST_H

# include <ahDefs.H>
# include <tpl_snode.H>

using namespace Aleph;

namespace Aleph {

  template <typename T> class Slist : public Snode<T>
  {

  public:

    typedef Snode<T> Node;

    Slist() { /* empty */ }

    void insert_first(Node * node)
    {
      assert(node not_eq nullptr);
      assert(node->is_empty());

      this->insert_next(node);
    }

    Node * remove_first_ne() noexcept
    {
      return this->remove_next();
    }

    Node * remove_first()
    {
      if (this->is_empty())
        throw std::underflow_error ("list is empty");

      return this->remove_next();
    }

    Node * get_first()
    {
      if (this->is_empty())
        throw std::underflow_error ("list is empty");

      return this->get_next();
    }

    class Iterator
    {

    private:

      Slist * list;
      Node  * current;

    public:
      typedef Snode<T> Set_Type;
      typedef Snode<T> * Item_Type;

      Iterator(Slist & _list) : list(&_list), current(list->get_first()) {}

      bool has_curr() const { return current != list; }

      Node * get_curr()
      {
        if (not this->has_curr())
          throw std::overflow_error ("");

        return current;
      }
      void next()

      {
        if (not this->has_curr())
          throw std::overflow_error ("");

        current = current->get_next();
      }
      void reset_first() { current = list->get_next(); }
      Iterator & operator = (Node * node)
      {
        if (this == node)
          return *this;

        current = node;
        return *this;
      }
    };
  };

} // end namespace Aleph

# endif /* TPL_SLIST_H */