RhodeCode

          }

        }

        if (is) is.putback(c);

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

      }

    };

  }

  template <typename Digraph>

  class DigraphReader;

  template <typename 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

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

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

    }

  private:

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

      }

      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

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

      }

      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

      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

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

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

        delete it->second;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

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

    }

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

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

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

        delete it->second;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

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

    }

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

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

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

          target.addFront(it);

        }

      }

    };

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

  }

      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;