RhodeCode

    typedef std::map<std::string, Node> NodeIndex;

    NodeIndex _node_index;

    typedef std::map<std::string, Arc> ArcIndex;

    ArcIndex _arc_index;

    typedef std::vector<std::pair<std::string, 

      _reader_bits::MapStorageBase<Node>*> > NodeMaps;    

    NodeMaps _node_maps; 

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;

    ArcMaps _arc_maps;

    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*> 

      Attributes;

    Attributes _attributes;

    typedef std::map<std::string, _reader_bits::Section*> Sections;

    Sections _sections;

    bool _use_nodes;

    bool _use_arcs;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// input stream.

    DigraphReader(std::istream& is, Digraph& digraph) 

      : _is(&is), local_is(false), _digraph(digraph),

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// file.

    DigraphReader(const std::string& fn, Digraph& digraph) 

      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// file.

    DigraphReader(const char* fn, Digraph& digraph) 

      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),

    /// \brief Copy constructor

    ///

    /// The copy constructor transfers all data from the other reader,

    /// therefore the copied reader will not be usable more. 

    DigraphReader(DigraphReader& other) 

      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),

      other._is = 0;

      other.local_is = false;

      _node_index.swap(other._node_index);

      _arc_index.swap(other._arc_index);

      _node_maps.swap(other._node_maps);

      _arc_maps.swap(other._arc_maps);

      _attributes.swap(other._attributes);

      _nodes_caption = other._nodes_caption;

      _arcs_caption = other._arcs_caption;

      _attributes_caption = other._attributes_caption;

      _sections.swap(other._sections);

    }

    /// \brief Destructor

    ~DigraphReader() {

      for (typename NodeMaps::iterator it = _node_maps.begin(); 

	   it != _node_maps.end(); ++it) {

	delete it->second;

      }

      _writer_bits::DefaultConverter<typename Map::Value> converter;

      for (ArcIt a(_digraph); a != INVALID; ++a) {

	_arc_index.insert(std::make_pair(converter(map[a]), a));

      }

      return *this;

    }

    /// \brief Use previously constructed arc set

    ///

    /// Use previously constructed arc set, and specify the arc

    /// label map and a functor which converts the label map values to

    /// std::string.

    template <typename Map, typename Converter>

    DigraphReader& useArcs(const Map& map, 

			    const Converter& converter = Converter()) {

      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();

      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member"); 

      _use_arcs = true;

      for (ArcIt a(_digraph); a != INVALID; ++a) {

	_arc_index.insert(std::make_pair(converter(map[a]), a));

      }

      return *this;

    }

    /// @}

  private:

    bool readLine() {

      std::string str;

      while(++line_num, std::getline(*_is, str)) {

	line.clear(); line.str(str);

	char c;

	if (line >> std::ws >> c && c != '#') {

	  line.putback(c);

	  return true;

	}

      }

      return false;

    }

    bool readSuccess() {

      return static_cast<bool>(*_is);

    }

    void skipSection() {

      char c;

      while (readSuccess() && line >> c && c != '@') {

      for (typename Attributes::iterator it = _attributes.begin();

	   it != _attributes.end(); ++it) {

	if (read_attr.find(it->first) == read_attr.end()) {

	  std::ostringstream msg;

	  msg << "Attribute not found in file: " << it->first;

	  throw DataFormatError(msg.str().c_str());

	}	

      }

    }

  public:

    /// \name Execution of the reader    

    /// @{

    /// \brief Start the batch processing

    ///

    /// This function starts the batch processing

    void run() {

      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");

      if (!*_is) {

	throw DataFormatError("Cannot find file");

      }

      bool attributes_done = false;

      std::set<std::string> extra_sections;

      line_num = 0;      

      readLine();

      skipSection();

      while (readSuccess()) {

	try {

	  char c;

	  std::string section, caption;

	  line >> c;

	  _reader_bits::readToken(line, section);

	  _reader_bits::readToken(line, caption);

	  if (line >> c) 

	    throw DataFormatError("Extra character on the end of line");

	  if (section == "nodes" && !nodes_done) {

	    if (_nodes_caption.empty() || _nodes_caption == caption) {

	      readNodes();

	      nodes_done = true;

	    }

	  } else if ((section == "arcs" || section == "edges") && 

    typedef std::map<std::string, Node> NodeIndex;

    NodeIndex _node_index;

    typedef std::map<std::string, Edge> EdgeIndex;

    EdgeIndex _edge_index;

    typedef std::vector<std::pair<std::string, 

      _reader_bits::MapStorageBase<Node>*> > NodeMaps;    

    NodeMaps _node_maps; 

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;

    EdgeMaps _edge_maps;

    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*> 

      Attributes;

    Attributes _attributes;

    typedef std::map<std::string, _reader_bits::Section*> Sections;

    Sections _sections;

    bool _use_nodes;

    bool _use_edges;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct a undirected graph reader, which reads from the given

    /// input stream.

    GraphReader(std::istream& is, Graph& graph) 

      : _is(&is), local_is(false), _graph(graph),

    /// \brief Constructor

    ///

    /// Construct a undirected graph reader, which reads from the given

    /// file.

    GraphReader(const std::string& fn, Graph& graph) 

      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),

    /// \brief Constructor

    ///

    /// Construct a undirected graph reader, which reads from the given

    /// file.

    GraphReader(const char* fn, Graph& graph) 

      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),

    /// \brief Copy constructor

    ///

    /// The copy constructor transfers all data from the other reader,

    /// therefore the copied reader will not be usable more. 

    GraphReader(GraphReader& other) 

      : _is(other._is), local_is(other.local_is), _graph(other._graph),

      other._is = 0;

      other.local_is = false;

      _node_index.swap(other._node_index);

      _edge_index.swap(other._edge_index);

      _node_maps.swap(other._node_maps);

      _edge_maps.swap(other._edge_maps);

      _attributes.swap(other._attributes);

      _nodes_caption = other._nodes_caption;

      _edges_caption = other._edges_caption;

      _attributes_caption = other._attributes_caption;

      _sections.swap(other._sections);

    }

    /// \brief Destructor

    ~GraphReader() {

      for (typename NodeMaps::iterator it = _node_maps.begin(); 

	   it != _node_maps.end(); ++it) {

	delete it->second;

      }

      _writer_bits::DefaultConverter<typename Map::Value> converter;

      for (EdgeIt a(_graph); a != INVALID; ++a) {

	_edge_index.insert(std::make_pair(converter(map[a]), a));

      }

      return *this;

    }

    /// \brief Use previously constructed edge set

    ///

    /// Use previously constructed edge set, and specify the edge

    /// label map and a functor which converts the label map values to

    /// std::string.

    template <typename Map, typename Converter>

    GraphReader& useEdges(const Map& map, 

			    const Converter& converter = Converter()) {

      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();

      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member"); 

      _use_edges = true;

      for (EdgeIt a(_graph); a != INVALID; ++a) {

	_edge_index.insert(std::make_pair(converter(map[a]), a));

      }

      return *this;

    }

    /// @}

  private:

    bool readLine() {

      std::string str;

      while(++line_num, std::getline(*_is, str)) {

	line.clear(); line.str(str);

	char c;

	if (line >> std::ws >> c && c != '#') {

	  line.putback(c);

	  return true;

	}

      }

      return false;

    }

    bool readSuccess() {

      return static_cast<bool>(*_is);

    }

    void skipSection() {

      char c;

      while (readSuccess() && line >> c && c != '@') {

	line.putback(c);

      }

      for (typename Attributes::iterator it = _attributes.begin();

	   it != _attributes.end(); ++it) {

	if (read_attr.find(it->first) == read_attr.end()) {

	  std::ostringstream msg;

	  msg << "Attribute not found in file: " << it->first;

	  throw DataFormatError(msg.str().c_str());

	}	

      }

    }

  public:

    /// \name Execution of the reader    

    /// @{

    /// \brief Start the batch processing

    ///

    /// This function starts the batch processing

    void run() {

      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");

      bool attributes_done = false;

      std::set<std::string> extra_sections;

      line_num = 0;      

      readLine();

      skipSection();

      while (readSuccess()) {

	try {

	  char c;

	  std::string section, caption;

	  line >> c;

	  _reader_bits::readToken(line, section);

	  _reader_bits::readToken(line, caption);

	  if (line >> c) 

	    throw DataFormatError("Extra character on the end of line");

	  if (section == "nodes" && !nodes_done) {

	    if (_nodes_caption.empty() || _nodes_caption == caption) {

	      readNodes();

	      nodes_done = true;

	    }

	  } else if ((section == "edges" || section == "arcs") &&