RhodeCode

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    ///The type of the map that indicates which nodes are processed.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a \ref ProcessedMap.

    int _curr_dist;

    void create_maps()

    {

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    int _list_front, _list_back;

    void create_maps() {

      if(!_reached) {

    /// Returns whether the given directed arc has the same orientation

    /// as the corresponding edge.

    static bool direction(const Arc &a) { return a.forward; }

  /// the map. This map type uses the std::vector to store the values.

  ///

  /// \tparam _Item The item type of the graph items.

  /// \tparam _Value The value type of the map.

  template <typename _Graph, typename _Item, typename _Value>

  class VectorMap

///\brief Basic utilities for concept checking.

///

#ifndef LEMON_CONCEPT_CHECK_H

///\brief Classes for representing paths in digraphs.

///

#ifndef LEMON_CONCEPT_PATH_H

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    ///The type of the map that indicates which nodes are processed.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a \ref ProcessedMap.

    int _stack_head;

    void create_maps()

    {

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    int _stack_head;

    void create_maps() {

      if(!_reached) {

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///By default it is a NullMap.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a \ref ProcessedMap.

    bool local_heap;

    void create_maps()

    {

    /// \param g is the digraph, to which we would like to define the

    /// HeapCrossRef.

    static HeapCrossRef *createHeapCrossRef(const Digraph &g)

    {

    ///\param g is the digraph, to which we would like to define the

    ///\ref PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    ///By default it is a NullMap.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a \ref ProcessedMap.

  /// The \ref DijkstraWizardBase is a class to be the default traits of the

  /// \ref DijkstraWizard class.

  template<class GR,class LM>

  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>

    ///\e

    mutable std::auto_ptr<std::ostringstream> buf;

  ///it draws the graph.

  void run() {

    const double EPSILON=1e-9;

    if(dontPrint) return;

      for(ArcIt e(g);e!=INVALID;++e)

        max_w=std::max(double(_arcWidths[e]),max_w);

      if(max_w>EPSILON) {

        _arcWidthScale/=max_w;

      for(NodeIt n(g);n!=INVALID;++n)

        max_s=std::max(double(_nodeSizes[n]),max_s);

      if(max_s>EPSILON) {

        _nodeScale/=max_s;

      }

      else {

        double sc= std::min((A4HEIGHT-2*A4BORDER)/bb.width(),

                  (A4WIDTH-2*A4BORDER)/bb.height());

            dvec(mycoords[g.target(*i)]-mycoords[g.source(*i)]);

          double l=std::sqrt(dvec.normSquare());

          dim2::Point<double> d(dvec/std::max(l,EPSILON));

          dim2::Point<double> m;

    ///be invalidated.

    ///

    ///Snapshot feature.

    Node split(Node n, bool connect = true) {

      Node b = addNode();

  ///

  /// \sa CombineMap

  template <typename M1, typename M2>

  class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {

  ///

  /// \sa ComposeMap

  template<typename M1, typename M2, typename F,

           typename V = typename F::result_type>

    /// \note The Cartesian form of the Box-Muller

    /// transformation is used to generate a random normal distribution.

    double gauss()

    {

    ///\warning This functionality cannot be used together with the Snapshot

    ///feature.

    Node split(Node n, bool connect = true)

    {

  ///function, consider the usage of \ref TimeReport instead.

  ///

  ///\sa TimeReport

  class Timer

  ///\sa Timer

  ///\sa NoTimeReport

  class TimeReport : public Timer

  {

///floating point numbers.

///

namespace lemon {