RhodeCode

  ///Default traits class of Bfs class.

  ///Default traits class of Bfs class.

  template<class GR>

  struct BfsDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  ///\ingroup search

  ///This class provides an efficient implementation of the %BFS algorithm.

  ///

  ///\ref ListDigraph. The value of GR is not used directly by Bfs, it

  ///is only passed to \ref BfsDefaultTraits.

  ///The default traits class is

  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".

  ///See \ref BfsDefaultTraits for the documentation of

  ///a Bfs traits class.

#ifdef DOXYGEN

  template <typename GR,

	    typename TR>

  ///Default traits class of Bfs function.

  ///Default traits class of Bfs function.

  template<class GR>

  struct BfsWizardDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  /// \brief Default traits class of BfsVisit class.

  ///

  /// Default traits class of BfsVisit class.

  template<class _Digraph>

  struct BfsVisitDefaultTraits {

    /// \brief The digraph type the algorithm runs on. 

  /// The %BfsVisit class provides an alternative interface to the Bfs

  /// class. It works with callback mechanism, the BfsVisit object calls

  /// on every bfs event the \c Visitor class member functions. 

  ///

  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it

  /// is only passed to \ref BfsDefaultTraits.

  /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty Visitor which

  /// does not observe the Bfs events. If you want to observe the bfs

  /// events you should implement your own Visitor class.

  /// algorithm. The default traits class is

  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".

  /// See \ref BfsVisitDefaultTraits for the documentation of

  /// a Bfs visit traits class.

#ifdef DOXYGEN

  template <typename _Digraph, typename _Visitor, typename _Traits>

#else

  template <typename _Digraph = ListDigraph,

  ///priorities in such a way that finding the item with minimum priority is

  ///efficient. \c Compare specifies the ordering of the priorities. In a heap

  ///one can change the priority of an item, add or erase an item, etc.

  ///

  ///to handle the cross references.

  ///default is \c std::less<_Prio>.

  ///

  ///\sa FibHeap

  ///\sa Dijkstra

  /// be watched in any way.

  ///

  /// \param _Container The container which is observed.

  /// \param _Item The item type which is obserbved.

  template <typename _Container, typename _Item>

  class AlterationNotifier {

  public:

    ///

    /// The build() and clear() members are to notify the observer

    /// about the container is built from an empty container or

    /// is cleared to an empty container. 

    class ObserverBase {

    protected:

      typedef AlterationNotifier Notifier;

///\file

///\brief Classes to compute with Bezier curves.

///

///Up to now this file is used internally by \ref graph_to_eps.h

#include<lemon/dim2.h>

namespace lemon {

  /// The VectorMap template class is graph map structure what

  /// automatically updates the map when a key is added to or erased from

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

  ///

  template <typename _Graph, typename _Item, typename _Value>

  class VectorMap 

    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {

  private:

///\ingroup misc

///\file

///\brief Tools to manage RGB colors.

namespace lemon {

    /// a digraph.

    ///

    /// A skeleton structure for representing directed paths in a

    /// digraph.  

    ///

    /// In a sense, the path can be treated as a list of arcs. The

    /// lemon path type stores just this list. As a consequence it

    /// cannot enumerate the nodes in the path and the zero length

    /// Lemon such algorithms gives back a path dumper what can

    /// assigned to a real path and the dumpers can be implemented as

    /// an adaptor class to the predecessor map.

    ///

    /// The paths can be constructed from any path type by a

    /// template constructor or a template assignment operator.

    /// 

  ///Default traits class of Dfs class.

  ///Default traits class of Dfs class.

  template<class GR>

  struct DfsDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  ///\ingroup search

  ///This class provides an efficient implementation of the %DFS algorithm.

  ///

  ///\ref ListDigraph. The value of GR is not used directly by Dfs, it

  ///is only passed to \ref DfsDefaultTraits.

  ///The default traits class is

  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".

  ///See \ref DfsDefaultTraits for the documentation of

  ///a Dfs traits class.

#ifdef DOXYGEN

  template <typename GR,

	    typename TR>

#else

  ///Default traits class of Dfs function.

  ///Default traits class of Dfs function.

  template<class GR>

  struct DfsWizardDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  /// \brief Default traits class of DfsVisit class.

  ///

  /// Default traits class of DfsVisit class.

  template<class _Digraph>

  struct DfsVisitDefaultTraits {

    /// \brief The digraph type the algorithm runs on. 

  /// The %DfsVisit class provides an alternative interface to the Dfs

  /// class. It works with callback mechanism, the DfsVisit object calls

  /// on every dfs event the \c Visitor class member functions. 

  ///

  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it

  /// is only passed to \ref DfsDefaultTraits.

  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty Visitor which

  /// does not observe the Dfs events. If you want to observe the dfs

  /// events you should implement your own Visitor class.

  /// algorithm. The default traits class is

  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".

  /// See \ref DfsVisitDefaultTraits for the documentation of

  /// a Dfs visit traits class.

  ///Default traits class of Dijkstra class.

  ///Default traits class of Dijkstra class.

  template<class GR, class LM>

  struct DijkstraDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  ///\ref concepts::ReadMap::Value "Value" of the length map.

  ///

  ///It is also possible to change the underlying priority heap.

  ///

  ///is \ref ListDigraph. The value of GR is not used directly by

  ///Dijkstra, it is only passed to \ref DijkstraDefaultTraits.

  ///arcs. It is read once for each arc, so the map may involve in

  ///relatively time consuming process to compute the arc length if

  ///it is necessary. The default map type is \ref

  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".  The value

  ///of LM is not used directly by Dijkstra, it is only passed to \ref

  ///various data types used by the algorithm.  The default traits

  ///class is \ref DijkstraDefaultTraits

  ///"DijkstraDefaultTraits<GR,LM>".  See \ref

  ///DijkstraDefaultTraits for the documentation of a Dijkstra traits

  ///class.

#ifdef DOXYGEN

  template <typename GR, typename LM, typename TR>

#else

  ///Default traits class of Dijkstra function.

  ///Default traits class of Dijkstra function.

  template<class GR, class LM>

  struct DijkstraWizardDefaultTraits

  {

    ///The digraph type the algorithm runs on. 

  };

  ///Sets the map of the arc widths

  ///Sets the map of the arc widths

  template<class X> GraphToEps<ArcWidthsTraits<X> > arcWidths(const X &x)

  {

    dontPrint=true;

    return GraphToEps<ArcWidthsTraits<X> >(ArcWidthsTraits<X>(*this,x));

  };

  ///Sets the map of the arc colors

  ///Sets the map of the arc colors

  ///

  ///\sa Palette

  template<class X> GraphToEps<ArcColorsTraits<X> >

  arcColors(const X &x)

  ///\sa findArc()

  ///\sa ArcLookUp

  ///\sa AllArcLookUp

  ///\sa DynArcLookUp

  template <typename _Graph>

  class ConArcIt : public _Graph::Arc {

  public:

  /// }

  ///\endcode

  ///

  ///\sa findEdge()

  template <typename _Graph>

  class ConEdgeIt : public _Graph::Edge {

  public:

  ///

  /// The values of the map can be accessed

  /// with stl compatible forward iterator.

  ///

  ///

  /// \see IterableValueMap

  template <typename _Graph, typename _Item, typename _Value>

  class InvertableMap : protected DefaultMap<_Graph, _Item, _Value> {

  /// this type (e.g. nodes) (so the id of a node can change if you delete an

  /// other node, i.e. this id is mutable).  </ul> This map can be inverted

  /// with its member class \c InverseMap, or with the \c operator() member.

  ///

  /// Edge.

  template <typename _Graph, typename _Item>

  class DescriptorMap : protected DefaultMap<_Graph, _Item, int> {

  /// \brief Returns the source of the given arc.

  ///

  /// The SourceMap gives back the source Node of the given arc. 

  /// \see TargetMap

  template <typename Digraph>

  class SourceMap {

  public:

  /// \brief Returns the target of the given arc.

  ///

  /// The TargetMap gives back the target Node of the given arc. 

  /// \see SourceMap

  template <typename Digraph>

  class TargetMap {

  public:

  /// \brief Returns the "forward" directed arc view of an edge.

  ///

  /// Returns the "forward" directed arc view of an edge.

  /// \see BackwardMap

  template <typename Graph>

  class ForwardMap {

  public:

  /// \brief Returns the "backward" directed arc view of an edge.

  ///

  /// Returns the "backward" directed arc view of an edge.

  /// \see ForwardMap

  template <typename Graph>

  class BackwardMap {

  public:

  ///time bound for arc lookups. This class also guarantees the

  ///optimal time bound in a constant factor for any distribution of

  ///queries.

  ///

  ///

  ///\sa ArcLookUp  

  ///\sa AllArcLookUp  

  template<class G>

  ///refresh(Node)) this data structure

  ///whenever the digraph changes. This is a time consuming (superlinearly

  ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).

  ///

  ///

  ///\sa DynArcLookUp

  ///\sa AllArcLookUp  

  template<class G>

  ///refresh(Node)) this data structure

  ///whenever the digraph changes. This is a time consuming (superlinearly

  ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).

  ///

  ///

  ///\sa DynArcLookUp

  ///\sa ArcLookUp  

  template<class G>

  /// \brief A structure for representing directed paths in a digraph.

  ///

  /// A structure for representing directed path in a digraph.

  ///

  /// In a sense, the path can be treated as a list of arcs. The

  /// lemon path type stores just this list. As a consequence, it

  /// cannot enumerate the nodes of the path and the source node of

  /// \brief A structure for representing directed paths in a digraph.

  ///

  /// A structure for representing directed path in a digraph.

  ///

  /// In a sense, the path can be treated as a list of arcs. The

  /// lemon path type stores just this list. As a consequence it

  /// cannot enumerate the nodes in the path and the zero length paths

  /// \brief A structure for representing directed paths in a digraph.

  ///

  /// A structure for representing directed path in a digraph.

  ///

  /// In a sense, the path can be treated as a list of arcs. The

  /// lemon path type stores just this list. As a consequence it

  /// cannot enumerate the nodes in the path and the zero length paths

  /// \brief A structure for representing directed paths in a digraph.

  ///

  /// A structure for representing directed path in a digraph.

  ///

  /// In a sense, the path can be treated as a list of arcs. The

  /// lemon path type stores just this list. As a consequence it

  /// cannot enumerate the nodes in the path and the source node of

  ///an important extra feature that its maps are real \ref

  ///concepts::ReferenceMap "reference map"s.

  ///

  ///\sa concepts::Digraph.

  class SmartDigraph : public ExtendedSmartDigraphBase {

  public:

    typedef ExtendedSmartDigraphBase Parent;

  /// they can be pushed to a stream.

  ///

  /// In most cases, perhaps the \ref Timer or the \ref TimeReport

  /// class is what you want to use instead.

  class TimeStamp

  {

    double utime;

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

  ///

  ///\todo This shouldn't be Unix (Linux) specific.

  ///\sa TimeReport

  class Timer

  {

    int _running; //Timer is running iff _running>0; (_running>=0 always holds)

    TimeStamp start_time; //This is the relativ start-time if the timer