RhodeCode

  ///

  class Exception : public std::exception {

  public:

    virtual ~Exception() throw() {}

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

      return "lemon::Exception";

    }

  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 ~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();

      }

  /// \brief Format error

  ///

  class FormatError : public Exception {

  protected:

    std::string _message;

  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 ~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;

    }

        _what.clear();

        std::ostringstream oss;

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

          oss << " (";

          oss << ")";

        }

        _what = oss.str();

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

  if (!(*os)) {

    delete os;

  }

  return GraphToEps<DefaultGraphToEpsTraits<G> >

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

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

  if (!(*os)) {

    delete os;

  }

  return GraphToEps<DefaultGraphToEpsTraits<G> >

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

        _filename(fn), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \brief Constructor

        _filename(fn), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {

    }

    /// \brief Destructor

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

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

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

          }

        }

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

        Node n;

        if (!_use_nodes) {

            _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()) {

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

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

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

          }

        }

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

        Arc a;

        if (!_use_arcs) {

            _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()) {

        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);

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

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

          std::ostringstream msg;

          throw FormatError(msg.str());

        }

      }

    /// 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;

          _reader_bits::readToken(line, caption);

          if (line >> c)

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

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

        _filename(fn), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Constructor

        _filename(fn), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Destructor

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

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

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

          }

        }

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

        Node n;

        if (!_use_nodes) {

            _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()) {

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

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

            std::ostringstream msg;

            throw FormatError(msg.str());

          }

          map_index[i] = jt->second;

          }

        }

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

        Edge e;

        if (!_use_edges) {

            _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()) {

        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);

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

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

          std::ostringstream msg;

          throw FormatError(msg.str());

        }

      }

          _reader_bits::readToken(line, caption);

          if (line >> c)

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

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

    SectionReader(const std::string& fn)

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

        _filename(fn) {

    }

    /// \brief Constructor

    SectionReader(const char* fn)

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

        _filename(fn) {

    }

    /// \brief Destructor

          _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);

    /// file.

    LgfContents(const std::string& fn)

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

    }

    /// \brief Constructor

    /// file.

    LgfContents(const char* fn)

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

    }

    /// \brief Destructor

    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

    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

    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

    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

    /// 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) {

    }

    /// \brief Destructor