io_graph.H

# ifndef IO_GRAPH_H
# define IO_GRAPH_H

# include <fstream>
# include <iostream>
# include <tpl_graph.H>

extern bool verbose; // comunmente definida en main

namespace Aleph { 


  template <class GT>
struct Dft_Store_Node
{
  void operator () (ofstream & output, GT &, typename GT::Node * p)
  {
    output.write((char*) &p->get_info(), sizeof(typename GT::Node_Type));
  }

  void operator () (ostream & output, GT &, typename GT::Node * p)
  {
    output << p->get_info() << endl;
  }
};

  template <class GT>
struct Dft_Store_Arc
{
  void operator () (ofstream & output, GT &, typename GT::Arc * a)
  {
    output.write((char*) &a->get_info(), sizeof(typename GT::Arc_Type));
  }

  void operator () (ostream & output, GT &, typename GT::Arc * a)
  {
    output << a->get_info() << endl;
  }
};

  template <class GT>
struct Dft_Load_Node
{
  void operator () (ifstream & input, GT &, typename GT::Node * p)
  {
    input.read((char*) &p->get_info(), sizeof(typename GT::Node_Type));
  }

  void operator () (istream & input, GT &, typename GT::Node * p)
  {
    input >> p->get_info();
  }
};

  template <class GT>
struct Dft_Load_Arc
{
  void operator () (ifstream & input, GT &, typename GT::Arc * a)
  {
    input.read((char*) &a->get_info(), sizeof(typename GT::Arc_Type));
  }

  void operator () (istream & input, GT &, typename GT::Arc * a)
  {
    input >> a->get_info();
  }
};

template <class GT, 
          class Load_Node  = Dft_Load_Node<GT>,
          class Store_Node = Dft_Store_Node<GT>,
          class Load_Arc   = Dft_Load_Arc<GT>,
          class Store_Arc  = Dft_Store_Arc<GT>,
          class NF         = Aleph::Dft_Show_Node<GT>, // Filtro de nodos
          class AF         = Aleph::Dft_Show_Arc<GT> > // Filtro de arcos
class IO_Graph
{

  GT & g;

public:

  IO_Graph(GT & __g) : g(__g) { /* empty */ }

  IO_Graph(GT * gptr) : g(*gptr) { /* empty */ }

  void save(ofstream & output)
  {
        // guarda cantidad de nodos
    const size_t num_nodes = g.get_num_nodes();

    if (verbose)
      cout << "Storing " << num_nodes << " nodes ... ";

    output.write((const char*) &num_nodes, sizeof(num_nodes));

    int i = 0; // contador de nodos. Lleva los índices en la tabla

        // tabla de pares <ptr nodo, orden de isnerción>
    DynMapTreap<typename GT::Node *, int> nodes_table;

    for (Node_Iterator<GT,NF> it(g); it.has_current(); it.next(), ++i)
      {
        typename GT::Node * p = it.get_current();

        if (verbose)
          cout << i << " ";

        Store_Node () (output, g, p);

        nodes_table.insert(p, i);
      }

    const size_t num_arcs = g.get_num_arcs();

    if (verbose)
      cout << " done " << endl 
           << "Storing " << num_arcs << " arcs ... " << endl;

    output.write((const char*) &num_arcs, sizeof(num_arcs));

    for (Arc_Iterator<GT,AF> it(g); it.has_current(); it.next())
      {
        typename GT::Arc * a = it.get_current();

        typename GT::Node * src = g.get_src_node(a);
        typename GT::Node * tgt = g.get_tgt_node(a);

        const int & src_idx = nodes_table.find(src);
        const int & tgt_idx = nodes_table.find(tgt);

            // guarda índices de nodos origen y destino respectivamente
        output.write((const char*) &src_idx, sizeof(int));
        output.write((const char*) &tgt_idx, sizeof(int));

        if (verbose)
          cout << " " << src_idx << "--" << tgt_idx << " ";

        Store_Arc () (output, g, a);

        if (verbose)
          cout << endl;
      }
    
    if (verbose)
      cout << " done " << endl << endl;
  }

  void load(ifstream & input)
  {
    // lee cantidad de nodos
    size_t num_nodes;
    input.read((char *) &num_nodes, sizeof(num_nodes));

    if (verbose)
      cout << "Loading " << num_nodes << " nodes ...";

    DynArray<typename GT::Node*> nodes_table(num_nodes);
    nodes_table.reserve(0, num_nodes - 1);

    for (size_t i = 0; i < num_nodes; ++i)
      {
        typename GT::Node * p = new typename GT::Node;

        if (verbose)
          cout << " " << i;

        Load_Node () (input, g, p);

        p = g.insert_node(p);
        nodes_table.access(i) = p;
      }

    size_t num_arcs;
    input.read((char *) &num_arcs, sizeof(num_arcs));

    if (verbose)
      cout << " done " << endl 
           << "Loading " << num_arcs << " arcs ... " << endl;

    for (int i = 0; i < num_arcs; ++i)
      {
        int src_idx;
        input.read((char*) &src_idx, sizeof(int));
        typename GT::Node * src = nodes_table.access(src_idx);

        int tgt_idx;
        input.read((char*) &tgt_idx, sizeof(int));
        typename GT::Node * tgt = nodes_table.access(tgt_idx);

        typename GT::Arc * a = g.insert_arc(src, tgt);

        if (verbose)
          cout << " " << src_idx << "--" << tgt_idx << " ";

        Load_Arc () (input, g, a);

        if (verbose)
          cout << endl;
      }

    if (verbose)
      cout << " done " << endl << endl;
  }

  void save_in_text_mode(ostream & output)
  {
        // guarda cantidad de nodos
    const size_t num_nodes = g.get_num_nodes();
    const size_t num_arcs  = g.get_num_arcs();
    output << num_nodes << endl
           << num_arcs << endl;

    if (verbose)
      cout << "Storing " << num_nodes << " nodes ... ";

    int i = 0; // contador de nodos. Lleva los índices en la tabla

        // tabla de pares <ptr nodo, orden de inserción>
    DynMapTreap<typename GT::Node *, int> nodes_table;

    for (Node_Iterator<GT,NF> it(g); it.has_current(); it.next(), ++i)
      {
        typename GT::Node * p = it.get_current();

        if (verbose)
          cout << i << " ";

        Store_Node () (output, g, p);

        nodes_table.insert(p, i);
      }

    if (verbose)
      cout << " done " << endl 
           << "Storing " << num_arcs << " arcs ... " << endl;

    for (Arc_Iterator<GT,AF> it(g); it.has_current(); it.next())
      {
        typename GT::Arc * a = it.get_current();

        typename GT::Node * src = g.get_src_node(a);
        typename GT::Node * tgt = g.get_tgt_node(a);

        const int & src_idx = nodes_table.find(src);
        const int & tgt_idx = nodes_table.find(tgt);

            // guarda índices de nodos origen y destino respectivamente
        output << src_idx << " " << tgt_idx << " ";

        if (verbose)
          cout << " " << src_idx << "--" << tgt_idx << " ";

        Store_Arc () (output, g, a);

        if (verbose)
          cout << endl;
      }

    if (verbose)
      cout << " done " << endl << endl;
  }


  void load_in_text_mode(istream & input)
  {
    // lee cantidad de nodos
    size_t num_nodes;
    size_t num_arcs;
    
    input >> num_nodes >> num_arcs;

    if (verbose)
      cout << "Loading " << num_nodes << " nodes ...";

    DynArray<typename GT::Node*> nodes_table(num_nodes);
    nodes_table.reserve(0, num_nodes - 1);

    for (size_t i = 0; i < num_nodes; ++i)
      {
        typename GT::Node * p = new typename GT::Node;

        if (verbose)
          cout << " " << i;

        Load_Node () (input, g, p);

        p = g.insert_node(p);
        nodes_table.access(i) = p;
      }

    if (verbose)
      cout << " done " << endl 
           << "Loading " << num_arcs << " arcs ... " << endl;

    for (int i = 0; i < num_arcs; ++i)
      {
        int src_idx;
        int tgt_idx;

        input >> src_idx >> tgt_idx;

        typename GT::Node * src = nodes_table.access(src_idx);
        typename GT::Node * tgt = nodes_table.access(tgt_idx);

        typename GT::Arc * a = g.insert_arc(src, tgt);

        if (verbose)
          cout << " " << src_idx << "--" << tgt_idx << " ";

        Load_Arc () (input, g, a);

        if (verbose)
          cout << " " << endl;
      }

    if (verbose)
      cout << " done " << endl << endl;
  }
};

} // end namespace Aleph

# endif // IO_GRAPH_H