generate_graph.H

/*
  This file is part of Aleph system

  Copyright (c) 2002, 2003, 2004, 2005, 2006
  UNIVERSITY LOS ANDES (ULA) Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA  

  - Center of Studies in Microelectronics & Distributed Systems (CEMISID) 
  - ULA Computer Science Department
  - FUNDACITE Mérida - Ministerio de Ciencia y Tecnología

  PERMISSION TO USE, COPY, MODIFY AND DISTRIBUTE THIS SOFTWARE AND ITS
  DOCUMENTATION IS HEREBY GRANTED, PROVIDED THAT BOTH THE COPYRIGHT
  NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES OF THE
  SOFTWARE, DERIVATIVE WORKS OR MODIFIED VERSIONS, AND ANY PORTIONS
  THEREOF, AND THAT BOTH NOTICES APPEAR IN SUPPORTING DOCUMENTATION.

  Aleph 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.

  UNIVERSIDAD DE LOS ANDES requests users of this software to return to 

  Leandro Leon
  CEMISID 
  Ed La Hechicera 
  3er piso, ala sur
  Facultad de Ingenieria 
  Universidad de Los Andes 
  Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA    or

  lrleon@ula.ve

  any improvements or extensions that they make and grant Universidad 
  de Los Andes (ULA) the rights to redistribute these changes. 

  Aleph is (or was) granted by: 
  - Consejo de Desarrollo Cientifico, Humanistico, Tecnico de la ULA 
    (CDCHT)
  - Fundacite Mérida
*/


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

using namespace std;
using namespace Aleph;


  template <typename GT> inline static 
bool is_there_a_double_arc(GT *                g, 
                           typename GT::Node * src, 
                           typename GT::Node * tgt)
{
  if (not g->is_digraph())
    return false;

  return g->search_arc(src, tgt) != NULL and g->search_arc(tgt, src) != NULL;
}


    template <typename GT>
static int search_node(DynArray<typename GT::Node *> & nodes, 
                 typename GT::Node * p)
{
  return sequential_search(nodes, p, 0, nodes.size() - 1);
}


template <typename GT, 
       class Write_Node, class Write_Arc,
       class Shade_Node, class Shade_Arc> static 
void generate_graphpic(GT &            g, 
                 const double &  xdist,
                 const double &  /* ydist no usado por ahora */,
                 std::ofstream & output)
{
  DynArray<typename GT::Node *> nodes;

  typename GT::Node_Iterator it(g);
  for (int i = 0; it.has_current(); it.next(), ++i)
    {
      typename GT::Node * p = it.get_current_node();

      nodes[i] = p;

      if (Shade_Node() (p).size() != 0)
     output << Shade_Node() (p) << " " << i << endl;
      
      const string text_node = Write_Node () (p);

      if (text_node.size() == 0)
     continue;

      output << "NODE-TEXT " << i << " \"" << text_node << "\" 0 0" << endl;
    }

  for (typename GT::Arc_Iterator it(g); it.has_current(); it.next())
    {
      typename GT::Arc * a = it.get_current_arc();

      typename GT::Node * src = g.get_src_node(a);
      typename GT::Node * tgt = g.get_tgt_node(a);
      
      const int src_idx = search_node <GT> (nodes, src);
      const int tgt_idx = search_node <GT> (nodes, tgt);

      if (is_there_a_double_arc <GT> (&g, src, tgt))
     output << "CURVE-ARC " << src_idx << " " << tgt_idx << " " 
            << xdist/5 << " L" << endl;
      else
     output << "ARC " << src_idx << " " << tgt_idx << endl;
      
      if ( Shade_Arc()(a).size() != 0)
     output << Shade_Arc()(a) << " " 
            << src_idx << " " << tgt_idx << " " << endl;

      const string text_arc = Write_Arc() (a);

      if (text_arc.size() == 0)
     continue;

      output << "ARC-TEXT " <<  src_idx << " " << tgt_idx << " \""
             << text_arc << "\" 0 0 " << endl;
    }  
}

    template <typename GT, 
           class Write_Node, class Write_Arc,
           class Shade_Node, class Shade_Arc>
void generate_cross_graph(GT &            g, 
                 const size_t &  nodes_by_level, 
                 const double &  xdist,
                 const double &  ydist,
                 std::ofstream & output)
{
  if (g.is_digraph())
    output << "cross-net-digraph ";  
  else 
    output << "cross-net-graph "; 

  output << g.get_num_nodes() << " " << nodes_by_level << " " 
         << xdist << " " << ydist << endl 
         << endl;
  
  generate_graphpic<GT, Write_Node, Write_Arc, Shade_Node, Shade_Arc>
    (g, xdist, ydist, output);
}

    template <typename GT, 
           class Write_Node, class Write_Arc,
           class Shade_Node, class Shade_Arc>
void generate_net_graph(GT &            g, 
               const size_t &  nodes_by_level, 
               const double &  xdist,
               const double &  ydist,
               std::ofstream & output)
{
  if (g.is_digraph())
    output << "net-digraph ";  
  else 
    output << "net-graph "; 

  output << g.get_num_nodes() << " " << nodes_by_level << " " 
         << xdist << " " << ydist << endl 
         << endl;
  
  generate_graphpic<GT, Write_Node, Write_Arc, Shade_Node, Shade_Arc>
    (g, xdist, ydist, output);
}

template <typename GT> struct __Shade_Node
{
  string operator () (typename GT::Node *) const
  {
    return "";
  }
};


template <typename GT> struct __Shade_Arc
{
  string operator () (typename GT::Arc *) const
  {
    return "";
  }
};


    template <typename GT, class Write_Node, class Write_Arc>
void generate_cross_graph(GT &            g, 
                          const size_t &  nodes_by_level, 
                          const double &  xdist,
                          const double &  ydist,
                          std::ofstream & output)
{
  generate_cross_graph
    <GT, Write_Node, Write_Arc, __Shade_Node<GT>, __Shade_Arc<GT> >
      (g, nodes_by_level, xdist, ydist, output);
}

    template <typename GT, class Write_Node, class Write_Arc>
void generate_net_graph(GT &            g, 
                          const size_t &  nodes_by_level, 
                          const double &  xdist,
                          const double &  ydist,
                          std::ofstream & output)
{
  generate_net_graph
    <GT, Write_Node, Write_Arc, __Shade_Node<GT>, __Shade_Arc<GT> >
      (g, nodes_by_level, xdist, ydist, output);
}

---