RhodeCode

            ++line_num;

          } else if (!isWhiteSpace(c)) {

            getline(is, line);

            ++line_num;

          }

        }

        if (is) is.putback(c);

        else if (is.eof()) is.clear();

      }

    };

  }

  template <typename Digraph>

  class DigraphReader;

  template <typename Digraph>

  DigraphReader<Digraph> digraphReader(Digraph& digraph,

  template <typename Digraph>

  template <typename Digraph>

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" reader for directed graphs

  ///

  /// This utility reads an \ref lgf-format "LGF" file.

  ///

  /// The reading method does a batch processing. The user creates a

  /// reader object, then various reading rules can be added to the

  /// reader, and eventually the reading is executed with the \c run()

  /// member function. A map reading rule can be added to the reader

  /// with the \c nodeMap() or \c arcMap() members. An optional

  /// converter parameter can also be added as a standard functor

  /// converting from \c std::string to the value type of the map. If it

  /// is set, it will determine how the tokens in the file should be

  /// converted to the value type of the map. If the functor is not set,

        delete it->second;

      }

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

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

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

    }

  private:

                                                  const std::string& fn);

    DigraphReader(DigraphReader& other)

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

        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),

        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {

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

      }

      if (!arcs_done) {

        throw FormatError("Section @arcs not found");

      }

      if (!attributes_done && !_attributes.empty()) {

        throw FormatError("Section @attributes not found");

      }

    }

    /// @}

  };

  template <typename Graph>

  class GraphReader;

  template <typename Graph>

  template <typename Graph>

  template <typename Graph>

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" reader for undirected graphs

  ///

  /// This utility reads an \ref lgf-format "LGF" file.

  ///

  /// It can be used almost the same way as \c DigraphReader.

  /// The only difference is that this class can handle edges and

  /// edge maps as well as arcs and arc maps.

  ///

  /// The columns in the \c \@edges (or \c \@arcs) section are the

  /// edge maps. However, if there are two maps with the same name

  /// prefixed with \c '+' and \c '-', then these can be read into an

  /// arc map.  Similarly, an attribute can be read into an arc, if

  /// it's value is an edge label prefixed with \c '+' or \c '-'.

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

        delete it->second;

      }

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

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

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

    }

  private:

    GraphReader(GraphReader& other)

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

        _use_nodes(other._use_nodes), _use_edges(other._use_edges),

        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {

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

      }

      if (!edges_done) {

        throw FormatError("Section @edges not found");

      }

      if (!attributes_done && !_attributes.empty()) {

        throw FormatError("Section @attributes not found");

      }

    }

    /// @}

  };

  class SectionReader;

  SectionReader sectionReader(std::istream& is);

  SectionReader sectionReader(const std::string& fn);

  SectionReader sectionReader(const char* fn);

  /// \ingroup lemon_io

  ///

  /// \brief Section reader class

  ///

  /// In the \ref lgf-format "LGF" file extra sections can be placed,

  /// which contain any data in arbitrary format. Such sections can be

  /// read with this class. A reading rule can be added to the class

  /// with two different functions. With the \c sectionLines() function a

  /// functor can process the section line-by-line, while with the \c

  /// sectionStream() member the section can be read from an input

    public:

      StreamSection(const Functor& functor) : _functor(functor) {}

      virtual ~StreamSection() {}

      virtual void process(std::ostream& os) {

        _functor(os);

      }

    };

  }

  template <typename Digraph>

  class DigraphWriter;

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" writer for directed graphs

  ///

  /// This utility writes an \ref lgf-format "LGF" file.

  ///

  /// The writing method does a batch processing. The user creates a

  /// writer object, then various writing rules can be added to the

  /// writer, and eventually the writing is executed with the \c run()

  /// member function. A map writing rule can be added to the writer

  /// with the \c nodeMap() or \c arcMap() members. An optional

  /// converter parameter can also be added as a standard functor

  /// converting from the value type of the map to \c std::string. If it

  /// is set, it will determine how the value type of the map is written to

  /// the output stream. If the functor is not set, then a default

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

        delete it->second;

      }

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

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

        delete it->second;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

                                                  std::ostream& os);

                                                  const std::string& fn);

                                                  const char *fn);

    DigraphWriter(DigraphWriter& other)

      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),

        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {

      other._os = 0;

      other.local_os = 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);

      } else {

        createArcIndex();

      }

      writeAttributes();

    }

    /// \brief Give back the stream of the writer

    ///

    /// Give back the stream of the writer.

    std::ostream& ostream() {

      return *_os;

    }

    /// @}

  };

  template <typename Graph>

  class GraphWriter;

  template <typename Graph>

  GraphWriter<Graph> graphWriter(const Graph& graph,

  template <typename Graph>

  template <typename Graph>

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" writer for directed graphs

  ///

  /// This utility writes an \ref lgf-format "LGF" file.

  ///

  /// It can be used almost the same way as \c DigraphWriter.

  /// The only difference is that this class can handle edges and

  /// edge maps as well as arcs and arc maps.

  ///

  /// The arc maps are written into the file as two columns, the

  /// caption of the columns are the name of the map prefixed with \c

  /// '+' and \c '-'. The arcs are written into the \c \@attributes

  /// section as a \c '+' or a \c '-' prefix (depends on the direction

  /// of the arc) and the label of corresponding edge.

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

        delete it->second;

      }

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

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

        delete it->second;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

                                            std::ostream& os);

                                            const std::string& fn);

                                            const char *fn);

    GraphWriter(GraphWriter& other)

      : _os(other._os), local_os(other.local_os), _graph(other._graph),

        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {

      other._os = 0;

      other.local_os = 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);

      } else {

        createEdgeIndex();

      }

      writeAttributes();

    }

    /// \brief Give back the stream of the writer

    ///

    /// Give back the stream of the writer

    std::ostream& ostream() {

      return *_os;

    }

    /// @}

  };

  class SectionWriter;

  SectionWriter sectionWriter(std::istream& is);

  SectionWriter sectionWriter(const std::string& fn);

  SectionWriter sectionWriter(const char* fn);

  /// \ingroup lemon_io

  ///

  /// \brief Section writer class

  ///

  /// In the \ref lgf-format "LGF" file extra sections can be placed,

  /// which contain any data in arbitrary format. Such sections can be

  /// written with this class. A writing rule can be added to the

  /// class with two different functions. With the \c sectionLines()

  /// function a generator can write the section line-by-line, while

  /// with the \c sectionStream() member the section can be written to

    };

    template <typename Path, typename Enable = void>

    struct BuildTagIndicator {

      static const bool value = false;

    };

    template <typename Path>

    struct BuildTagIndicator<

      Path,

      typename enable_if<typename Path::BuildTag, void>::type

    > {

      static const bool value = true;

    };

    template <typename Target, typename Source,

      static void copy(Target& target, const Source& source) {

        target.clear();

        for (typename Source::ArcIt it(source); it != INVALID; ++it) {

          target.addBack(it);

        }

      }

    };

    template <typename Target, typename Source>

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.build(source);

      }

    };

    template <typename Target, typename Source>

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.buildRev(source);

      }

    };

  }

  /// \brief Make a copy of a path.

  ///

  ///  This function makes a copy of a path.

  template <typename Target, typename Source>

  void copyPath(Target& target, const Source& source) {

    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();

    _path_bits::PathCopySelector<Target, Source>::copy(target, source);

  }

  /// \brief Check the consistency of a path.

  ///

  /// This function checks that the target of each arc is the same

  /// as the source of the next one.

    };

    template <typename Result, typename Word>

    struct Mapping<Result, Word, false> {

      static Result map(RandomCore<Word>& rnd, const Result& bound) {

        Word max = Word(bound - 1);

        Word mask = Masker<Word, (std::numeric_limits<Result>::digits + 1) / 2>

          ::mask(max);

        Word num;

        do {

          num = rnd() & mask;

        } while (num > max);

        return num;

      }

    };

    struct ShiftMultiplier {

      static const Result multiplier() {

        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();

        res *= res;

        if ((exp & 1) == 1) res *= static_cast<Result>(0.5);

        return res;

      }

    };

    template <typename Result>

      static const Result multiplier() {

        return static_cast<Result>(1.0);

      }

    };

    template <typename Result>

      static const Result multiplier() {

        return static_cast<Result>(1.0/1048576.0);

      }

    };

    template <typename Result>

      static const Result multiplier() {

      }

    };

    template <typename Result>

      static const Result multiplier() {

        return static_cast<Result>(1.0/9007199254740992.0);

      }

    };

    template <typename Result>

      static const Result multiplier() {

        return static_cast<Result>(1.0/18446744073709551616.0);

      }

    };

    template <typename Result, int exp>

    struct Shifting {

      static Result shift(const Result& result) {

        return result * ShiftMultiplier<Result, exp>::multiplier();

      }

    };

    template <typename Result, typename Word,

              int rest = std::numeric_limits<Result>::digits, int shift = 0,

              bool last = rest <= std::numeric_limits<Word>::digits>

    struct RealConversion{

      static const int bits = std::numeric_limits<Word>::digits;

      static Result convert(RandomCore<Word>& rnd) {

          shift(static_cast<Result>(rnd() >> (bits - rest)));

      }

    };

    template <typename Result, typename Word, int rest, int shift>

    struct RealConversion<Result, Word, rest, shift, false> {

      static const int bits = std::numeric_limits<Word>::digits;

      static Result convert(RandomCore<Word>& rnd) {

          shift(static_cast<Result>(rnd())) +

          RealConversion<Result, Word, rest-bits, shift + bits>::

          convert(rnd);

      }

    };

    template <typename Result, typename Word>

    struct Initializer {

      template <typename Iterator>

      static void init(RandomCore<Word>& rnd, Iterator begin, Iterator end) {

        std::vector<Word> ws;

        for (Iterator it = begin; it != end; ++it) {

          ws.push_back(Word(*it));

        }

        rnd.initState(ws.begin(), ws.end());