tpl_indexNode.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_INDEXNODE_H
# define TPL_INDEXNODE_H

# include <tpl_dynSetTree.H>
# include <tpl_graph.H>

using namespace Aleph;

namespace Aleph
{

  template <class GT>
  struct Dft_Node_Cmp
  {
    bool
    operator () (typename GT::Node * p1, typename GT::Node * p2) const
    {
      return p1->get_info() < p2->get_info();
    }
  };

  template <class GT, class Compare = Dft_Node_Cmp<GT>,
            template <class /* Key */, class /* Compare */> class Tree = Treap,
            class SN = Dft_Show_Node<GT> >
  class IndexNode
  {
  private:

    typedef typename GT::Node GT_Node;
    typedef typename GT::Node_Type GT_Node_Type;

    DynSetTree<GT_Node*, Tree, Compare> index;

    GT & g;
    SN & sn;

  public:

    GT_Node * insert(GT_Node * p)
    {
      index.put(p);
      return p;
    }

    GT_Node * insert_in_graph(const GT_Node_Type & info)
    {
      GT_Node * ret_val = g.insert_node(info);

      try
        {
          insert(ret_val);

          return ret_val;
        }
      catch (...)
        {
          g.remove_node(ret_val);
          throw;
        }
    }

    GT_Node * insert_in_graph(GT_Node_Type && info = GT_Node_Type())
    {
      GT_Node * ret_val = g.insert_node(std::forward<GT_Node_Type>(info));

      try
        {
          insert(ret_val);

          return ret_val;
        }
      catch (...)
        {
          g.remove_node(ret_val);
          throw;
        }
    }

    GT_Node * search(GT_Node * p)
    {
      GT_Node ** ret_val = index.search(p);

      if (ret_val == nullptr)
        return nullptr;

      return *ret_val;
    }

    GT_Node * search(const GT_Node_Type & info)
    {
      GT_Node dummy_node(info);
      GT_Node * dummy_node_ptr = &dummy_node;

      return search(dummy_node_ptr);
    }

    void remove(GT_Node * p)
    {
      index.remove(p);
    }

    void remove_from_graph(GT_Node * p)
    {
      index.find(p); // dispara excepción si p no está en el índice
      index.remove(p);
      g.remove_node(p);
    }

    void clear_index()
    {
      index.empty();
    }

    void build_index()
    {
      for (Node_Iterator<GT, SN> it(g, sn); it.has_curr(); it.next_ne())
        {
          GT_Node * p = it.get_curr_ne();
          if (search(p) != p)
            insert(p);
        }
    }

    void clear_graph()
    {
      clear_index();
      g.clear_graph();
    }

  private:

    void init()
    {
      for (Node_Iterator<GT, SN> it(g, sn); it.has_curr(); it.next_ne())
        insert(it.get_curr_ne());
    }

  public:

    IndexNode(GT & __g, SN && __sn = SN()) : g(__g), sn(__sn)
    {
      init();
    }

    IndexNode(GT & __g, SN & __sn) : g(__g), sn(__sn)
    {
      init();
    }

    size_t size() const { return index.size(); }
  };

}

# endif