RhodeCode

/// graphToEps(), and showing how to draw directed graphs,

/// how to handle parallel egdes, how to change the properties (like

/// color, shape, size, title etc.) of nodes and arcs individually

///

/// \include graph_to_eps_demo.cc

 2   3   18

\endcode

also store the edge set of an undirected graph. In such case there is

a conventional method for store arc maps in the file, if two columns

has the same caption with \c '+' and \c '-' prefix, then these columns

  /// observeres will not be notified and the fulfilled additions will

  /// be rolled back by calling the \e erase() or \e clear()

  /// functions. Thence the \e erase() and \e clear() should not throw

  /// exception which detach the observer from the notifier.

  ///

  /// There are some place when the alteration observing is not completly

// #endif

  template <typename _Graph, typename _Item, typename _Value>

  class DefaultMap

    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {

  /// Dark cyan color constant

  extern const Color DARK_CYAN;

  ///This map assigns one of the predefined \ref Color "Color"s to

  ///each <tt>int</tt>. It is possible to change the colors as well as

    /// \brief Class describing the concept of graph maps

    ///

    /// This class describes the common interface of the graph maps

    /// associate data to graph descriptors (nodes or arcs).

    template <typename _Graph, typename _Item, typename _Value>

    class GraphMap : public ReadWriteMap<_Item, _Value> {

    ///\note This is a dynamic data structure, therefore the data

    ///structure is updated after each graph alteration. Thus although

    ///this data structure is theoretically faster than \ref ArcLookUp

    ///them.

    Arc operator()(Node s, Node t, Arc p = INVALID) const  {

      if (p == INVALID) {

    ///Find an arc between two nodes.

    ///\param s The source node.

    ///\param t The target node.

    ///\return An arc from \c s to \c t if there exists,

    ///for(Arc a = ae(u,v); a != INVALID; a=ae(u,v,a)) n++;

    ///\endcode

    ///

    ///consecutive arcs are found in constant time.

    ///

    ///\warning If you change the digraph, refresh() must be called before using

    typedef lemon::Path<Digraph> Path;

  };

  /// To make it easier to use Dfs algorithm

  /// we have created a wizard class.

    };

    /// \brief \ref named-templ-param "Named parameter" for setting

    ///

    ///\ref named-templ-param "Named parameter" for setting

    ///\ref OperationTraits type.

    typedef lemon::Path<Digraph> Path;

  };

  /// To make it easier to use Dijkstra algorithm

  /// we have created a wizard class.

  /// A class to calculate or store the bounding box of plain vectors

  template<typename T>

  class Box {

      Point<T> _bottom_left, _top_right;

    return os;

  }

  ///\ingroup maps

  template<class M>

  class XMap

  {

    void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}

  };

  ///

  ///\ingroup maps

  ///\relates XMap

    return XMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class ConstXMap

  {

    Value operator[](Key k) const {return _map[k].x;}

  };

  ///

  ///\ingroup maps

  ///\relates ConstXMap

    return ConstXMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class YMap

  {

    void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}

  };

  ///

  ///\ingroup maps

  ///\relates YMap

    return YMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class ConstYMap

  {

    Value operator[](Key k) const {return _map[k].y;}

  };

  ///

  ///\ingroup maps

  ///\relates ConstYMap

  }

  ///

  ///Map of the \ref Point::normSquare() "normSquare()"

  ///of a \ref Point "Point"-map.

    Value operator[](Key k) const {return _map[k].normSquare();}

  };

  ///

  ///\ingroup maps

  ///\relates NormSquareMap

    };

  }

///Default traits class of \ref GraphToEps.

///

    /// Change the source of \c a to \c n

    ///

    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain

    ///invalidated.

    ///

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

  template<typename K, typename V>

  class MapBase {

  public:

    typedef K Key;

    /// \brief The value type of the map.

    /// (The type of objects associated with the keys).

    /// \brief Constructor

    ///

    /// Constructor

    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}

    /// \brief The subscript operator.

    /// \brief Constructor

    ///

    /// Constructor

    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}

    /// \brief The subscript operator.

    /// \brief Constructor

    ///

    /// Constructor

    explicit ForwardMap(const Graph& graph) : _graph(graph) {}

    /// \brief The subscript operator.

    /// \brief Constructor

    ///

    /// Constructor

    explicit BackwardMap(const Graph& graph) : _graph(graph) {}

    /// \brief The subscript operator.

    /// \brief Return true when the path is empty.

    int empty() const { return len == 0; }

    void clear() {

      len = 0;

      if (arcs) delete[] arcs;

      ///Constructor that immediately makes a snapshot

      ///This constructor immediately makes a snapshot of the digraph.

      Snapshot(SmartDigraph &graph) : _graph(&graph) {

        node_num=_graph->nodes.size();

        arc_num=_graph->arcs.size();

      ///

      ///This function can be called more than once. In case of a repeated

      ///call, the previous snapshot gets lost.

      void save(SmartDigraph &graph)

      {

        _graph=&graph;

      ///Constructor that immediately makes a snapshot

      ///This constructor immediately makes a snapshot of the digraph.

      Snapshot(SmartGraph &graph) {

        graph.saveSnapshot(*this);

      }

      ///

      ///This function can be called more than once. In case of a repeated

      ///call, the previous snapshot gets lost.

      void save(SmartGraph &graph)

      {

        graph.saveSnapshot(*this);

    ///\name Control the state of the timer

    ///Basically a Timer can be either running or stopped,

    ///but it provides a bit finer control on the execution.

    ///of recursive functions.

    ///@{

    ///@}

  };

  ///Same as \ref Timer but prints a report on destruction.

  ///This example shows its usage.

    std::string _title;

    std::ostream &_os;

  public:

    ///\param title This text will be printed before the ellapsed time.

    ///\param os The stream to print the report to.

    ///\param run Sets whether the timer should start immediately.

    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)

      : Timer(run), _title(title), _os(os){}

    ~TimeReport()

    {

      _os << _title << *this << std::endl;

    }

  };

  ///\sa TimeReport

  ///