RhodeCode

/// <tt>.eps</tt> files demonstrating the capability of \ref

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

#include<lemon/list_graph.h>

 1   3   12

 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

can be regarded as the values of an arc map.

  /// a \e clear() function throws an exception then the remaining

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

  /// reliable. If we want to carry out the node degree in the graph

//   };

// #endif

  template <typename _Graph, typename _Item, typename _Value>

  class DefaultMap

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

  public:

  extern const Color DARK_MAGENTA;

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

  ///their number. The integer range is cyclically mapped to the

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

    public:

    ///

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

        Arc a = _head[s];

    }

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

    ///\ref INVALID otherwise.

    ///int n = 0;

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

    ///this operator. If you change the outgoing arcs of

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

    typedef lemon::Path<Digraph> Path;

  };

  /// To make it easier to use Dfs algorithm

  /// we have created a wizard class.

  /// This \ref DfsWizard class needs default traits,

      typedef T OperationTraits;

    };

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

    ///

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

    ///\ref OperationTraits type.

    template <class T>

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

    typedef lemon::Path<Digraph> Path;

  };

  /// To make it easier to use Dijkstra algorithm

  /// we have created a wizard class.

  /// This \ref DijkstraWizard class needs default traits,

  }

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

  template<typename T>

  class Box {

      Point<T> _bottom_left, _top_right;

      bool _empty;

    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";

    return os;

  }

  ///\ingroup maps

  template<class M>

  class XMap

  {

    M& _map;

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

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

  };

  ///

  ///\ingroup maps

  ///\relates XMap

  template<class M>

  {

    return XMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class ConstXMap

  {

    const M& _map;

    ConstXMap(const M &map) : _map(map) {}

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

  };

  ///

  ///\ingroup maps

  ///\relates ConstXMap

  template<class M>

  {

    return ConstXMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class YMap

  {

    M& _map;

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

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

  };

  ///

  ///\ingroup maps

  ///\relates YMap

  template<class M>

  {

    return YMap<M>(m);

  }

  ///\ingroup maps

  template<class M>

  class ConstYMap

  {

    const M& _map;

    ConstYMap(const M &map) : _map(map) {}

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

  };

  ///

  ///\ingroup maps

  ///\relates ConstYMap

  template<class M>

    return ConstYMap<M>(m);

  }

  ///

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

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

  ///\ingroup maps

    NormSquareMap(const M &map) : _map(map) {}

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

  };

  ///

  ///\ingroup maps

  ///\relates NormSquareMap

  template<class M>

      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}

    };

  }

///Default traits class of \ref GraphToEps.

///

///\c G is the type of the underlying graph.

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

    ///feature.

  /// required by the map %concepts.

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

    typedef V Value;

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

      arcs = 0;

      Snapshot() : _graph(0) {}

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

      }

      ///Make a snapshot of the digraph.

      ///

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

        node_num=_graph->nodes.size();

      Snapshot() : _graph(0) {}

      ///Constructor that immediately makes a snapshot

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

      Snapshot(SmartGraph &graph) {

        graph.saveSnapshot(*this);

      }

      ///Make a snapshot of the graph.

      ///

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

    ///@{

    ///Reset and stop the time counters

    ///@}

  };

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

  ///This example shows its usage.

  ///\code

  {

    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

  ///

  class NoTimeReport