io_graph.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef IO_GRAPH_H
#define IO_GRAPH_H
 
#include <fstream>
#include <iostream>
#include <memory>
#include <tpl_graph.H>
#include <ah-graph-concepts.H>
#include <ah-errors.H>
 
namespace Aleph
{
 
template <class GT>
struct Dft_Store_Node
{
  void operator()(std::ofstream & output, GT & g, typename GT::Node * p)
  {
    (void)g;
    output.write(reinterpret_cast<const char*>(&p->get_info()), 
                 sizeof(typename GT::Node_Type));
  }
 
  void operator()(std::ostream & output, GT & g, typename GT::Node * p)
  {
    (void)g;
    output << p->get_info() << std::endl;
  }
};
 
template <class GT>
struct Dft_Store_Arc
{
  void operator()(std::ofstream & output, GT & g, typename GT::Arc * a)
  {
    (void)g;
    output.write(reinterpret_cast<const char*>(&a->get_info()), 
                 sizeof(typename GT::Arc_Type));
  }
 
  void operator()(std::ostream & output, GT & g, typename GT::Arc * a)
  {
    (void)g;
    output << a->get_info() << std::endl;
  }
};
 
template <class GT>
struct Dft_Load_Node
{
  void operator()(std::ifstream & input, GT & g, typename GT::Node * p)
  {
    (void)g;
    input.read(reinterpret_cast<char*>(&p->get_info()), 
               sizeof(typename GT::Node_Type));
  }
 
  void operator()(std::istream & input, GT & g, typename GT::Node * p)
  {
    (void)g;
    input >> p->get_info();
  }
};
 
template <class GT>
struct Dft_Load_Arc
{
  void operator()(std::ifstream & input, GT & g, typename GT::Arc * a)
  {
    (void)g;
    input.read(reinterpret_cast<char*>(&a->get_info()), 
               sizeof(typename GT::Arc_Type));
  }
 
  void operator()(std::istream & input, GT & g, typename GT::Arc * a)
  {
    (void)g;
    input >> a->get_info();
  }
};
 
template <AlephGraph 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>,
          NodeFilter<GT> NF = Aleph::Dft_Show_Node<GT>,
          ArcFilter<GT> AF  = Aleph::Dft_Show_Arc<GT>>
class IO_Graph
{
  GT & g;
 
  Load_Node load_node   = Load_Node();
  Store_Node store_node = Store_Node();
  Load_Arc load_arc     = Load_Arc();
  Store_Arc store_arc   = Store_Arc();
 
  NF node_filter = NF();
  AF arc_filter  = AF();
 
  bool verbose_mode = false;
 
public:
 
  void set_verbose(bool v) noexcept { verbose_mode = v; }
 
  [[nodiscard]] bool is_verbose() const noexcept { return verbose_mode; }
 
  void set_load_node(const Load_Node & ln) { load_node = ln; }
 
  void set_store_node(const Store_Node & sn) { store_node = sn; }
 
  void set_load_arc(const Load_Arc & la) { load_arc = la; }
 
  void set_store_arc(const Store_Arc & sa) { store_arc = sa; }
 
  void set_node_filter(const NF & nf) { node_filter = nf; }
 
  void set_arc_filter(const AF & af) { arc_filter = af; }
 
  explicit IO_Graph(GT & __g) noexcept : g(__g) {}
 
  explicit IO_Graph(GT * gptr) noexcept : g(*gptr) {}
 
  void save(std::ofstream & output)
  {
    const size_t num_nodes = g.get_num_nodes();
 
    if (verbose_mode)
      std::cout << "Storing " << num_nodes << " nodes ... ";
 
    output.write(reinterpret_cast<const char*>(&num_nodes), sizeof(num_nodes));
 
    int i = 0;
    DynMapTreap<typename GT::Node*, int> nodes_table;
 
    for (Node_Iterator<GT, NF> it(g, node_filter); it.has_curr();
         it.next_ne(), ++i)
      {
        auto p = it.get_curr();
 
        if (verbose_mode)
          std::cout << i << " ";
 
        store_node(output, g, p);
        nodes_table.insert(p, i);
      }
 
    const size_t num_arcs = g.get_num_arcs();
 
    if (verbose_mode)
      std::cout << " done " << std::endl 
                << "Storing " << num_arcs << " arcs ... " << std::endl;
 
    output.write(reinterpret_cast<const char*>(&num_arcs), sizeof(num_arcs));
 
    for (Arc_Iterator<GT, AF> it(g, arc_filter); it.has_curr(); it.next_ne())
      {
        auto a = it.get_curr();
 
        auto src = g.get_src_node(a);
        auto tgt = g.get_tgt_node(a);
 
        const int src_idx = nodes_table.find(src);
        const int tgt_idx = nodes_table.find(tgt);
 
        output.write(reinterpret_cast<const char*>(&src_idx), sizeof(int));
        output.write(reinterpret_cast<const char*>(&tgt_idx), sizeof(int));
 
        if (verbose_mode)
          std::cout << " " << src_idx << "--" << tgt_idx << " ";
 
        store_arc(output, g, a);
 
        if (verbose_mode)
          std::cout << std::endl;
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl << std::endl;
  }
 
  void load(std::ifstream & input)
  {
    size_t num_nodes;
    input.read(reinterpret_cast<char*>(&num_nodes), sizeof(num_nodes));
    ah_runtime_error_if(not input.good())
      << "Failed to read node count from binary stream";
 
    if (verbose_mode)
      std::cout << "Loading " << num_nodes << " nodes ...";
 
    DynArray<typename GT::Node*> nodes_table(num_nodes);
    if (num_nodes > 0)
      nodes_table.reserve(0, num_nodes - 1);
 
    for (size_t i = 0; i < num_nodes; ++i)
      {
        std::unique_ptr<typename GT::Node> p(new typename GT::Node);
 
        if (verbose_mode)
          std::cout << " " << i;
 
        load_node(input, g, p.get());
        ah_runtime_error_if(not input.good())
          << "Failed to load node " << i << " from binary stream";
 
        typename GT::Node * inserted = g.insert_node(p.release());
        nodes_table.access(i) = inserted;
      }
 
    size_t num_arcs;
    input.read(reinterpret_cast<char*>(&num_arcs), sizeof(num_arcs));
    ah_runtime_error_if(not input.good())
      << "Failed to read arc count from binary stream";
 
    if (verbose_mode)
      std::cout << " done " << std::endl
                << "Loading " << num_arcs << " arcs ... " << std::endl;
 
    for (size_t i = 0; i < num_arcs; ++i)
      {
        int src_idx;
        input.read(reinterpret_cast<char*>(&src_idx), sizeof(int));
        ah_runtime_error_if(not input.good())
          << "Failed to read source index for arc " << i;
 
        auto src = nodes_table.access(src_idx);
 
        int tgt_idx;
        input.read(reinterpret_cast<char*>(&tgt_idx), sizeof(int));
        ah_runtime_error_if(not input.good())
          << "Failed to read target index for arc " << i;
 
        auto tgt = nodes_table.access(tgt_idx);
        auto a = g.insert_arc(src, tgt);
 
        if (verbose_mode)
          std::cout << " " << src_idx << "--" << tgt_idx << " ";
 
        load_arc(input, g, a);
        ah_runtime_error_if(not input.good())
          << "Failed to load arc " << i << " data";
 
        if (verbose_mode)
          std::cout << std::endl;
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl << std::endl;
  }
 
  void save_in_text_mode(std::ostream & output)
  {
    const size_t num_nodes = g.get_num_nodes();
    const size_t num_arcs  = g.get_num_arcs();
    
    output << num_nodes << std::endl
           << num_arcs << std::endl;
 
    if (verbose_mode)
      std::cout << "Storing " << num_nodes << " nodes ... ";
 
    int i = 0;
    DynMapTreap<typename GT::Node*, int> nodes_table;
 
    for (Node_Iterator<GT, NF> it(g, node_filter); it.has_curr();
         it.next_ne(), ++i)
      {
        typename GT::Node * p = it.get_curr();
 
        if (verbose_mode)
          std::cout << i << " ";
 
        store_node(output, g, p);
        nodes_table.insert(p, i);
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl 
                << "Storing " << num_arcs << " arcs ... " << std::endl;
 
    for (Arc_Iterator<GT, AF> it(g, arc_filter); it.has_curr(); it.next_ne())
      {
        auto a = it.get_curr();
 
        auto src = g.get_src_node(a);
        auto tgt = g.get_tgt_node(a);
 
        const int src_idx = nodes_table.find(src);
        const int tgt_idx = nodes_table.find(tgt);
 
        output << src_idx << " " << tgt_idx << " ";
 
        if (verbose_mode)
          std::cout << " " << src_idx << "--" << tgt_idx << " ";
 
        store_arc(output, g, a);
 
        if (verbose_mode)
          std::cout << std::endl;
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl << std::endl;
  }
 
  void load_in_text_mode(std::istream & input)
  {
    size_t num_nodes;
    size_t num_arcs;
 
    input >> num_nodes >> num_arcs;
    ah_runtime_error_if(not input.good())
      << "Failed to read node/arc count from text stream";
 
    input.ignore();
 
    if (verbose_mode)
      std::cout << "Loading " << num_nodes << " nodes ...";
 
    DynArray<typename GT::Node*> nodes_table(num_nodes);
    if (num_nodes > 0)
      nodes_table.reserve(0, num_nodes - 1);
 
    for (size_t i = 0; i < num_nodes; ++i)
      {
        std::unique_ptr<typename GT::Node> p(new typename GT::Node);
 
        if (verbose_mode)
          std::cout << " " << i;
 
        load_node(input, g, p.get());
        ah_runtime_error_if(not input.good())
          << "Failed to load node " << i << " from text stream";
 
        typename GT::Node * inserted = g.insert_node(p.release());
        nodes_table.access(i) = inserted;
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl
                << "Loading " << num_arcs << " arcs ... " << std::endl;
 
    for (size_t i = 0; i < num_arcs; ++i)
      {
        int src_idx;
        int tgt_idx;
 
        input >> src_idx >> tgt_idx;
        ah_runtime_error_if(not input.good())
          << "Failed to read arc " << i << " indices from text stream";
 
        auto src = nodes_table.access(src_idx);
        auto tgt = nodes_table.access(tgt_idx);
        auto a = g.insert_arc(src, tgt);
 
        if (verbose_mode)
          std::cout << " " << src_idx << "--" << tgt_idx << " ";
 
        load_arc(input, g, a);
        ah_runtime_error_if(not input.good())
          << "Failed to load arc " << i << " data from text stream";
 
        if (verbose_mode)
          std::cout << std::endl;
      }
 
    if (verbose_mode)
      std::cout << " done " << std::endl << std::endl;
  }
};
 
} // namespace Aleph
 
// Global namespace compatibility
using Aleph::IO_Graph;
using Aleph::Dft_Store_Node;
using Aleph::Dft_Store_Arc;
using Aleph::Dft_Load_Node;
using Aleph::Dft_Load_Arc;
 
#endif // IO_GRAPH_H