root/lang/cplusplus/boost-supplement/trunk/boost_supplement/graph/read_lgl.hpp @ 17467

#ifndef BOOST_SUPPLEMENT_GRAPH_READ_LGL_HPP_INCLUDED
#define BOOST_SUPPLEMENT_GRAPH_READ_LGL_HPP_INCLUDED 1

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/property_map.hpp>
#include <boost/tokenizer.hpp>

#include <boost_supplement/graph/detail/line_input_iterator.hpp>

#include <map>

namespace boost_supplement {
namespace detail {

template<class Graph, class VertexNameMap, class EdgeWeightMap>
class lgl_reader 
{
private:
  typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
  typedef std::map<std::string, Vertex> NameVertexMap;
  typedef boost::tokenizer< boost::char_separator<char> > tokenizer;

  const boost::char_separator<char> SEP;
  Graph* m_graph;
  VertexNameMap m_vnm;
  EdgeWeightMap m_ewm;
  NameVertexMap m_nvm;
  std::string m_base;

  Vertex name_to_vertex(std::string const& n)
    {
      typename NameVertexMap::iterator i = m_nvm.find(n);
      if (i == m_nvm.end()) {
        Vertex u = add_vertex(*m_graph);
        m_vnm[u] = n;
        m_nvm[n] = u;
        return u;
      }
      return i->second;
    }

  void process_line(std::string const& line)
    {
      using namespace std;
      using namespace boost;

      tokenizer tokens(line, SEP);
      tokenizer::iterator tok_iter = tokens.begin();

      string tok1(*tok_iter++);
      if ("#" == tok1) {
        if (tok_iter == tokens.end()) {
          // TODO: Syntax error
          return;
        }
        m_base = *tok_iter;
      }
      else {
        Vertex u = name_to_vertex(m_base);
        Vertex v = name_to_vertex(tok1);
        if (tok_iter == tokens.end()) {
          add_edge(u, v, *m_graph);
        }
        else {
          string tok2(*tok_iter);
          double w = atof(tok2.c_str());
          // if (has_w && w > cutoff) continue;
          add_edge(u, v, *m_graph);
          m_ewm[edge(u, v, *m_graph).first] = w;
        }
      }
    }
  
public:
  lgl_reader(Graph& g, VertexNameMap n, EdgeWeightMap w)
    : SEP(" "),
      m_graph(&g),
      m_vnm(n),
      m_ewm(w),
      m_base("")
    {}

  template<class InputStream>
  bool read(InputStream& is)
    {
      m_graph->clear();
      for (line_input_iterator<InputStream> line_iter(is);
           line_iter != line_input_iterator<InputStream>();
           ++line_iter) {
        process_line(*line_iter);
      }

      return true;
    }
};

} // detail

template<class InputStream, class Graph,
         class VertexNameMap, class EdgeWeightMap>
bool read_lgl(InputStream& is, Graph& g,
              VertexNameMap& vnm, EdgeWeightMap& ewm)
{
  detail::lgl_reader<Graph, VertexNameMap, EdgeWeightMap>
    reader(g, vnm, ewm);
  return reader.read(is);
}

template<class InputStream, class Graph>
bool read_lgl(InputStream& is, Graph& g)
{
  using namespace boost;
  typedef typename property_map<Graph, vertex_name_t>::type VNM;
  typedef typename property_map<Graph, edge_weight_t>::type EWM;

  VNM n = get(vertex_name, g);
  EWM w = get(edge_weight, g);
  return read_lgl(is, g, n, w);
}

} // boost_supplement

#endif // ifndef BOOST_SUPPLEMENT_GRAPH_READ_LGL_HPP_INCLUDED