RhodeCode

namespace lemon {

  /// \addtogroup exceptions

  /// @{

  /// \brief Generic exception class.

  ///

  /// Base class for exceptions used in LEMON.

  ///

  class Exception : public std::exception {

  public:

    virtual ~Exception() throw() {}

    virtual const char* what() const throw() {

      return "lemon::Exception";

    }

  };

  /// \brief Input-Output error

  ///

  /// This exception is thrown when a file operation cannot be

  /// succeeded.

  class IoError : public Exception {

  protected:

    std::string _message;

    std::string _file;

    mutable std::string _what;

  public:

    /// Copy constructor

      message(error._message);

      file(error._file);

    }

    /// Constructor

      IoError::message(message);

    }

    /// Constructor

      IoError::message(message);

    }

    /// Constructor

      IoError::message(message);

      IoError::file(file);

    }

    /// Constructor

      IoError::message(message);

      IoError::file(file);

    }

    /// Virtual destructor

    virtual ~IoError() throw() {}

    /// Set the error message

      try {

        _message = message;

      } catch (...) {}

    }

    /// Set the error message

      try {

        _message = message;

      } catch (...) {}

    }

    /// Set the file name

      try {

        _file = file;

      } catch (...) {}

    }

    /// Returns the error message

      return _message;

    }

    /// \brief Returns the filename

    ///

      return _file;

    }

    /// \brief Returns a short error message

    ///

    virtual const char* what() const throw() {

      try {

        _what.clear();

        std::ostringstream oss;

        oss << "lemon:IoError" << ": ";

        }

        _what = oss.str();

      }

      catch (...) {}

      if (!_what.empty()) return _what.c_str();

      else return "lemon:IoError";

    }

  };

  /// \brief Format error

  ///

  class FormatError : public Exception {

  protected:

    std::string _message;

    std::string _file;

    int _line;

    mutable std::string _what;

  public:

    /// Copy constructor

      message(error._message);

      file(error._file);

      line(error._line);

    }

    /// Constructor

      FormatError::message(message);

      _line = 0;

    }

    /// Constructor

      FormatError::message(message);

      _line = 0;

    }

    /// Constructor

      FormatError::message(message);

      FormatError::file(file);

      FormatError::line(line);

    }

    /// Constructor

      FormatError::message(message);

      FormatError::file(file);

      FormatError::line(line);

    }

    /// Virtual destructor

    virtual ~FormatError() throw() {}

    /// Set the line number

    /// Set the error message

      try {

        _message = message;

      } catch (...) {}

    }

    /// Set the error message

      try {

        _message = message;

      } catch (...) {}

    }

    /// Set the file name

      try {

        _file = file;

      } catch (...) {}

    }

    /// \brief Returns the line number

    ///

    /// Returns the line number or zero if it was not specified.

    /// Returns the error message

      return _message;

    }

    /// \brief Returns the filename

    ///

      return _file;

    }

    /// \brief Returns a short error message

    ///

    /// Returns a short error message which contains the message, the

    /// file name and the line number.

    virtual const char* what() const throw() {

      try {

        _what.clear();

        std::ostringstream oss;

        oss << "lemon:FormatError" << ": ";

          oss << " (";

          oss << ")";

        }

        _what = oss.str();

      }

      catch (...) {}

      if (!_what.empty()) return _what.c_str();

      else return "lemon:FormatError";

    }

  };

  /// @}

///This function does the same as

///\ref graphToEps(G &g,std::ostream& os)

///but it writes its output into the file \c file_name

///instead of a stream.

///\sa graphToEps(G &g, std::ostream& os)

template<class G>

GraphToEps<DefaultGraphToEpsTraits<G> >

graphToEps(G &g,const char *file_name)

{

  std::ostream* os = new std::ofstream(file_name);

  if (!(*os)) {

    delete os;

  }

  return GraphToEps<DefaultGraphToEpsTraits<G> >

    (DefaultGraphToEpsTraits<G>(g,*os,true));

}

///Generates an EPS file from a graph

///\ingroup eps_io

///This function does the same as

///\ref graphToEps(G &g,std::ostream& os)

///but it writes its output into the file \c file_name

///instead of a stream.

///\sa graphToEps(G &g, std::ostream& os)

template<class G>

GraphToEps<DefaultGraphToEpsTraits<G> >

graphToEps(G &g,const std::string& file_name)

{

  std::ostream* os = new std::ofstream(file_name.c_str());

  if (!(*os)) {

    delete os;

  }

  return GraphToEps<DefaultGraphToEpsTraits<G> >

    (DefaultGraphToEpsTraits<G>(g,*os,true));

}

} //END OF NAMESPACE LEMON

#endif // LEMON_GRAPH_TO_EPS_H

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \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),

        _filename(fn), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \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),

        _filename(fn), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \brief Destructor

    ~DigraphReader() {

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

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

        delete it->second;

      }

      for (typename ArcMaps::iterator it = _arc_maps.begin();

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

        delete it->second;

            msg << "Multiple occurence of node map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

          ++index;

        }

        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {

          std::map<std::string, int>::iterator jt =

            maps.find(_node_maps[i].first);

          if (jt == maps.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

        }

        {

          std::map<std::string, int>::iterator jt = maps.find("label");

          if (jt != maps.end()) {

            label_index = jt->second;

          } else {

            label_index = -1;

          }

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

        line.putback(c);

        std::vector<std::string> tokens(map_num);

        for (int i = 0; i < map_num; ++i) {

          if (!_reader_bits::readToken(line, tokens[i])) {

            std::ostringstream msg;

            msg << "Column not found (" << i + 1 << ")";

            throw FormatError(msg.str());

          }

        }

        if (line >> std::ws >> c)

        Node n;

        if (!_use_nodes) {

          n = _digraph.addNode();

          if (label_index != -1)

            _node_index.insert(std::make_pair(tokens[label_index], n));

        } else {

          if (label_index == -1)

          typename std::map<std::string, Node>::iterator it =

            _node_index.find(tokens[label_index]);

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Node with label not found: " << tokens[label_index];

            throw FormatError(msg.str());

          }

          n = it->second;

        }

        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {

          _node_maps[i].second->set(n, tokens[map_index[i]]);

            msg << "Multiple occurence of arc map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

          ++index;

        }

        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {

          std::map<std::string, int>::iterator jt =

            maps.find(_arc_maps[i].first);

          if (jt == maps.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

        }

        {

          std::map<std::string, int>::iterator jt = maps.find("label");

          if (jt != maps.end()) {

            label_index = jt->second;

          } else {

            label_index = -1;

          }

        if (!_reader_bits::readToken(line, target_token))

          throw FormatError("Target not found");

        std::vector<std::string> tokens(map_num);

        for (int i = 0; i < map_num; ++i) {

          if (!_reader_bits::readToken(line, tokens[i])) {

            std::ostringstream msg;

            msg << "Column not found (" << i + 1 << ")";

            throw FormatError(msg.str());

          }

        }

        if (line >> std::ws >> c)

        Arc a;

        if (!_use_arcs) {

          typename NodeIndex::iterator it;

          it = _node_index.find(source_token);

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Item not found: " << source_token;

            throw FormatError(msg.str());

          }

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Item not found: " << target_token;

            throw FormatError(msg.str());

          }

          Node target = it->second;

          a = _digraph.addArc(source, target);

          if (label_index != -1)

            _arc_index.insert(std::make_pair(tokens[label_index], a));

        } else {

          if (label_index == -1)

          typename std::map<std::string, Arc>::iterator it =

            _arc_index.find(tokens[label_index]);

          if (it == _arc_index.end()) {

            std::ostringstream msg;

            msg << "Arc with label not found: " << tokens[label_index];

            throw FormatError(msg.str());

          }

          a = it->second;

        }

        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {

          _arc_maps[i].second->set(a, tokens[map_index[i]]);

      std::set<std::string> read_attr;

      char c;

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

        line.putback(c);

        std::string attr, token;

        if (!_reader_bits::readToken(line, attr))

          throw FormatError("Attribute name not found");

        if (!_reader_bits::readToken(line, token))

          throw FormatError("Attribute value not found");

        if (line >> c)

        {

          std::set<std::string>::iterator it = read_attr.find(attr);

          if (it != read_attr.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          read_attr.insert(attr);

        }

        {

          typename Attributes::iterator it = _attributes.lower_bound(attr);

          while (it != _attributes.end() && it->first == attr) {

            it->second->set(token);

            ++it;

          }

        }

      }

      if (readSuccess()) {

        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;

          throw FormatError(msg.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 nodes_done = _skip_nodes;

      bool arcs_done = _skip_arcs;

      bool attributes_done = false;

      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)

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

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

              readNodes();

              nodes_done = true;

            }

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

                     !arcs_done) {

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

              readArcs();

              arcs_done = true;

            }

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

    /// Construct an 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),

        _filename(fn), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Constructor

    ///

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

    /// file.

    GraphReader(const char* fn, Graph& graph)

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

        _filename(fn), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Destructor

    ~GraphReader() {

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

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

        delete it->second;

      }

      for (typename EdgeMaps::iterator it = _edge_maps.begin();

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

        delete it->second;

            msg << "Multiple occurence of node map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

          ++index;

        }

        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {

          std::map<std::string, int>::iterator jt =

            maps.find(_node_maps[i].first);

          if (jt == maps.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

        }

        {

          std::map<std::string, int>::iterator jt = maps.find("label");

          if (jt != maps.end()) {

            label_index = jt->second;

          } else {

            label_index = -1;

          }

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

        line.putback(c);

        std::vector<std::string> tokens(map_num);

        for (int i = 0; i < map_num; ++i) {

          if (!_reader_bits::readToken(line, tokens[i])) {

            std::ostringstream msg;

            msg << "Column not found (" << i + 1 << ")";

            throw FormatError(msg.str());

          }

        }

        if (line >> std::ws >> c)

        Node n;

        if (!_use_nodes) {

          n = _graph.addNode();

          if (label_index != -1)

            _node_index.insert(std::make_pair(tokens[label_index], n));

        } else {

          if (label_index == -1)

          typename std::map<std::string, Node>::iterator it =

            _node_index.find(tokens[label_index]);

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Node with label not found: " << tokens[label_index];

            throw FormatError(msg.str());

          }

          n = it->second;

        }

        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {

          _node_maps[i].second->set(n, tokens[map_index[i]]);

            msg << "Multiple occurence of edge map: " << map;

            throw FormatError(msg.str());

          }

          maps.insert(std::make_pair(map, index));

          ++index;

        }

        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {

          std::map<std::string, int>::iterator jt =

            maps.find(_edge_maps[i].first);

          if (jt == maps.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

        }

        {

          std::map<std::string, int>::iterator jt = maps.find("label");

          if (jt != maps.end()) {

            label_index = jt->second;

          } else {

            label_index = -1;

          }

        if (!_reader_bits::readToken(line, target_token))

          throw FormatError("Node v not found");

        std::vector<std::string> tokens(map_num);

        for (int i = 0; i < map_num; ++i) {

          if (!_reader_bits::readToken(line, tokens[i])) {

            std::ostringstream msg;

            msg << "Column not found (" << i + 1 << ")";

            throw FormatError(msg.str());

          }

        }

        if (line >> std::ws >> c)

        Edge e;

        if (!_use_edges) {

          typename NodeIndex::iterator it;

          it = _node_index.find(source_token);

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Item not found: " << source_token;

            throw FormatError(msg.str());

          }

          if (it == _node_index.end()) {

            std::ostringstream msg;

            msg << "Item not found: " << target_token;

            throw FormatError(msg.str());

          }

          Node target = it->second;

          e = _graph.addEdge(source, target);

          if (label_index != -1)

            _edge_index.insert(std::make_pair(tokens[label_index], e));

        } else {

          if (label_index == -1)

          typename std::map<std::string, Edge>::iterator it =

            _edge_index.find(tokens[label_index]);

          if (it == _edge_index.end()) {

            std::ostringstream msg;

            msg << "Edge with label not found: " << tokens[label_index];

            throw FormatError(msg.str());

          }

          e = it->second;

        }

        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {

          _edge_maps[i].second->set(e, tokens[map_index[i]]);

      std::set<std::string> read_attr;

      char c;

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

        line.putback(c);

        std::string attr, token;

        if (!_reader_bits::readToken(line, attr))

          throw FormatError("Attribute name not found");

        if (!_reader_bits::readToken(line, token))

          throw FormatError("Attribute value not found");

        if (line >> c)

        {

          std::set<std::string>::iterator it = read_attr.find(attr);

          if (it != read_attr.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          read_attr.insert(attr);

        }

        {

          typename Attributes::iterator it = _attributes.lower_bound(attr);

          while (it != _attributes.end() && it->first == attr) {

            it->second->set(token);

            ++it;

          }

        }

      }

      if (readSuccess()) {

        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;

          throw FormatError(msg.str());

        }

      }

    }

  public:

    /// \name Execution of the reader

    /// @{

    /// \brief Start the batch processing

    ///

      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)

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

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

              readNodes();

              nodes_done = true;

            }

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

                     !edges_done) {

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

              readEdges();

              edges_done = true;

            }

    ///

    /// Construct a section reader, which reads from the given input

    /// stream.

    SectionReader(std::istream& is)

      : _is(&is), local_is(false) {}

    /// \brief Constructor

    ///

    /// Construct a section reader, which reads from the given file.

    SectionReader(const std::string& fn)

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

        _filename(fn) {

    }

    /// \brief Constructor

    ///

    /// Construct a section reader, which reads from the given file.

    SectionReader(const char* fn)

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

        _filename(fn) {

    }

    /// \brief Destructor

    ~SectionReader() {

      for (Sections::iterator it = _sections.begin();

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

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

      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)

          if (extra_sections.find(section) != extra_sections.end()) {

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          Sections::iterator it = _sections.find(section);

          if (it != _sections.end()) {

            extra_sections.insert(section);

            it->second->process(*_is, line_num);

          }

          readLine();

          skipSection();

        } catch (FormatError& error) {

          error.line(line_num);

          error.file(_filename);

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// input stream.

    LgfContents(std::istream& is)

      : _is(&is), local_is(false) {}

    /// \brief Constructor

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// file.

    LgfContents(const std::string& fn)

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

    }

    /// \brief Constructor

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// file.

    LgfContents(const char* fn)

      : _is(new std::ifstream(fn)), local_is(true) {

    }

    /// \brief Destructor

    ~LgfContents() {

      if (local_is) delete _is;

    }

  private:

    LgfContents(const LgfContents&);

    LgfContents& operator=(const LgfContents&);

    /// output stream.

    DigraphWriter(std::ostream& is, const Digraph& digraph)

      : _os(&is), local_os(false), _digraph(digraph),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

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

      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

    DigraphWriter(const char* fn, const Digraph& digraph)

      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \brief Destructor

    ~DigraphWriter() {

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

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

        delete it->second;

      }

      for (typename ArcMaps::iterator it = _arc_maps.begin();

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

        delete it->second;

    /// output stream.

    GraphWriter(std::ostream& is, const Graph& graph)

      : _os(&is), local_os(false), _graph(graph),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

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

      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

    GraphWriter(const char* fn, const Graph& graph)

      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Destructor

    ~GraphWriter() {

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

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

        delete it->second;

      }

      for (typename EdgeMaps::iterator it = _edge_maps.begin();

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

        delete it->second;

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes to the given output

    /// stream.

    SectionWriter(std::ostream& os)

      : _os(&os), local_os(false) {}

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes into the given file.

    SectionWriter(const std::string& fn)

      : _os(new std::ofstream(fn.c_str())), local_os(true) {

    }

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes into the given file.

    SectionWriter(const char* fn)

      : _os(new std::ofstream(fn)), local_os(true) {