RhodeCode

  /// \ingroup graphs

  ///

  /// \brief A full digraph class.

  ///

  /// This is a simple and fast directed full graph implementation.

  /// From each node go arcs to each node (including the source node),

  /// therefore the number of the arcs in the digraph is the square of

  /// the node number. This digraph type is completely static, so you

  /// can neither add nor delete either arcs or nodes, and it needs

  /// constant space in memory.

  ///

  ///

  /// The \c FullDigraph and \c FullGraph classes are very similar,

  /// but there are two differences. While this class conforms only

  /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph

  /// class conforms to the \ref concepts::Graph "Graph" concept,

  /// moreover \c FullGraph does not contain a loop arc for each

  /// node as \c FullDigraph does.

  ///

  /// \sa FullGraph

  class FullDigraph : public ExtendedFullDigraphBase {

  public:

  /// \ingroup graphs

  ///

  /// \brief An undirected full graph class.

  ///

  /// This is a simple and fast undirected full graph

  /// implementation. From each node go edge to each other node,

  /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.

  /// This graph type is completely static, so you can neither

  /// add nor delete either edges or nodes, and it needs constant

  /// space in memory.

  ///

  ///

  /// The \c FullGraph and \c FullDigraph classes are very similar,

  /// but there are two differences. While the \c FullDigraph class

  /// conforms only to the \ref concepts::Digraph "Digraph" concept,

  /// this class conforms to the \ref concepts::Graph "Graph" concept,

  /// moreover \c FullGraph does not contain a loop arc for each

  /// node as \c FullDigraph does.

  ///

  /// \sa FullDigraph

  class FullGraph : public ExtendedFullGraphBase {

  public:

  /// A short example about the basic usage:

  ///\code

  /// GridGraph graph(rows, cols);

  /// GridGraph::NodeMap<int> val(graph);

  /// for (int i = 0; i < graph.width(); ++i) {

  ///   for (int j = 0; j < graph.height(); ++j) {

  ///     val[graph(i, j)] = i + j;

  ///   }

  /// }

  ///\endcode

  ///

  /// This graph type fully conforms to the \ref concepts::Graph

  class GridGraph : public ExtendedGridGraphBase {

  public:

    typedef ExtendedGridGraphBase Parent;

    /// \brief Map to get the indices of the nodes as dim2::Point<int>.

    ///

    /// Map to get the indices of the nodes as dim2::Point<int>.

    class IndexMap {

    public:

      /// \brief The key type of the map

      typedef GridGraph::Node Key;

  /// \brief Hypercube graph class

  ///

  /// This class implements a special graph type. The nodes of the graph

  /// are indiced with integers with at most \c dim binary digits.

  /// Two nodes are connected in the graph if and only if their indices

  /// differ only on one position in the binary form.

  ///

  /// \note The type of the indices is chosen to \c int for efficiency

  /// reasons. Thus the maximum dimension of this implementation is 26

  /// (assuming that the size of \c int is 32 bit).

  ///

  /// This graph type fully conforms to the \ref concepts::Graph

  class HypercubeGraph : public ExtendedHypercubeGraphBase {

  public:

    typedef ExtendedHypercubeGraphBase Parent;

    /// \brief Constructs a hypercube graph with \c dim dimensions.

    ///

    /// Constructs a hypercube graph with \c dim dimensions.

    HypercubeGraph(int dim) { construct(dim); }

    /// \brief The number of dimensions.

    ///

  ///A general directed graph structure.

  ///\ref ListDigraph is a simple and fast <em>directed graph</em>

  ///implementation based on static linked lists that are stored in

  ///\c std::vector structures.

  ///

  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it

  ///also provides several useful additional functionalities.

  ///Most of the member functions and nested classes are documented

  ///only in the concept class.

  ///

  ///\sa concepts::Digraph

  class ListDigraph : public ExtendedListDigraphBase {

  private:

    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.

    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.

    ///

    ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};

    ///\brief Assignment of ListDigraph to another one is \e not allowed.

    ///Use copyDigraph() instead.

  ///A general undirected graph structure.

  ///\ref ListGraph is a simple and fast <em>undirected graph</em>

  ///implementation based on static linked lists that are stored in

  ///\c std::vector structures.

  ///

  ///It conforms to the \ref concepts::Graph "Graph concept" and it

  ///also provides several useful additional functionalities.

  ///Most of the member functions and nested classes are documented

  ///only in the concept class.

  ///

  ///\sa concepts::Graph

  class ListGraph : public ExtendedListGraphBase {

  private:

    ///ListGraph is \e not copy constructible. Use copyGraph() instead.

    ///ListGraph is \e not copy constructible. Use copyGraph() instead.

    ///

    ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};

    ///\brief Assignment of ListGraph to another one is \e not allowed.

    ///Use copyGraph() instead.

  };

  typedef DigraphExtender<SmartDigraphBase> ExtendedSmartDigraphBase;

  ///\ingroup graphs

  ///

  ///\brief A smart directed graph class.

  ///

  ///This is a simple and fast digraph implementation.

  ///It is also quite memory efficient, but at the price

  ///that <b> it does support only limited (only stack-like)

  ///node and arc deletions</b>.

  ///

  ///\sa concepts::Digraph.

  class SmartDigraph : public ExtendedSmartDigraphBase {

  public:

    typedef ExtendedSmartDigraphBase Parent;

  private:

    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.

    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.

  };

  typedef GraphExtender<SmartGraphBase> ExtendedSmartGraphBase;

  /// \ingroup graphs

  ///

  /// \brief A smart undirected graph class.

  ///

  /// This is a simple and fast graph implementation.

  /// It is also quite memory efficient, but at the price

  /// that <b> it does support only limited (only stack-like)

  /// node and arc deletions</b>.

  ///

  /// \sa concepts::Graph.

  class SmartGraph : public ExtendedSmartGraphBase {

  private:

    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.

    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.

    ///

    SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};

    ///\brief Assignment of SmartGraph to another one is \e not allowed.

    ///Use GraphCopy() instead.