Context Navigation

← Previous Change
Next Change →

graph_component.h

Timestamp:

11/13/04 22:37:54 (19 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1379

Message:

XyzConcept? moved to Xyz::Constraints
use checkConcept in the next way:

checkConcept<ErasableGraph?, ListGraph?>();
checkConcept<ReadWriteMap?<Node, Node>, PredMap?>;

File:

: 1 edited

src/lemon/concept/graph_component.h (modified) (16 diffs)

Legend:

: Unmodified
: Added
: Removed

src/lemon/concept/graph_component.h

-                      r987
+                      r989
     /// with character 'n' and for Edge with 'e'.
     template<char Ch>
+    template<char _selector>
     class GraphItem {
     public:
+      /// Default constructor.
+      /// @warning The default constructor sets the item
+      /// to an undefined value.
       GraphItem() {}
+      /// Copy constructor.
+      /// Copy constructor.
+      ///
+      GraphItem(GraphItem const&) {}
+      /// Invalid constructor \& conversion.
+      /// This constructor initializes the item to be invalid.
+      /// \sa Invalid for more details.
       GraphItem(Invalid) {}
+      // We explicitely list these:
+      GraphItem(GraphItem const&) {}
+      /// Assign operator for nodes.
+      /// The nodes are assignable.
+      ///
       GraphItem& operator=(GraphItem const&) { return *this; }
+      /// Equality operator.
+      /// Two iterators are equal if and only if they represents the
+      /// same node in the graph or both are invalid.
       bool operator==(GraphItem) const { return false; }
+      /// Inequality operator.
+      /// \sa operator==(const Node& n)
+      ///
       bool operator!=(GraphItem) const { return false; }
       // Technical requirement. Do we really need this?
+      bool operator<(GraphItem) const { return false; }
+    };
+    template<typename GI>
+    struct GraphItemConcept {
+      void constraints() {
+        GI i1;
+        GI i2 = i1;
+        GI i3 = INVALID;
+        i1 = i2 = i3;
+        bool b;
+        b = (ia == ib) && (ia != ib) && (ia < ib);
+        b = (ia == INVALID) && (ib != INVALID);
+      }
+      const GI &ia;
+      const GI &ib;
+    };
+    template<typename Iter, typename Graph, typename BaseItem>
+    struct GraphIteratorConcept {
+      void constraints() {
+        function_requires< GraphItemConcept<Iter> >();
+        Iter it1(g);
+        /// \todo Do we need NodeIt(Node) kind of constructor?
+        //      Iter it2(bj);
+        Iter it2;
+        it2 = ++it1;
+        ++it2 = it1;
+        ++(++it1);
+        /// \bug This should be: is_base_and_derived<BaseItem, Iter>
+        BaseItem bi = it1;
+        bi = it2;
+      }
+      BaseItem bj;
+      Graph g;
+    };
+    template<typename Iter, typename Graph>
+    struct GraphIncIteratorConcept {
+      typedef typename Graph::Node Node;
+      typedef typename Graph::Edge Edge;
+      void constraints() {
+        function_requires< GraphItemConcept<Iter> >();
+        Iter it1(graph, node);
+        /// \todo Do we need OutEdgeIt(Edge) kind of constructor?
+        //      Iter it2(edge);
+        Iter it2;
+        it2 = ++it1;
+        ++it2 = it1;
+        ++(++it1);
+        Edge e = it1;
+        e = it2;
+      }
+      Edge edge;
+      Node node;
+      Graph graph;
+    };
+      //      bool operator<(GraphItem) const { return false; }
+      template<typename _GraphItem>
+      struct Constraints {
+        void constraints() {
+          _GraphItem i1;
+          _GraphItem i2 = i1;
+          _GraphItem i3 = INVALID;
+          i1 = i2 = i3;
+          bool b;
+          //      b = (ia == ib) && (ia != ib) && (ia < ib);
+          b = (ia == ib) && (ia != ib);
+          b = (ia == INVALID) && (ib != INVALID);
+        }
+        const _GraphItem &ia;
+        const _GraphItem &ib;
+      };
+    };
     /// An empty base graph class.
 …
       /// This class represents the Nodes of the graph.
       ///
+      class Node {
+      public:
+        /// Default constructor.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
+        Node() {}
+        /// Copy constructor.
+        /// Copy constructor.
+        ///
+        Node(const Node&) {}
+        /// Invalid constructor \& conversion.
+        /// This constructor initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
+        Node(Invalid) {}
+        /// Assign operator for nodes.
+        /// The nodes are assignable.
+        ///
+        Node& operator=(const Node&) { return *this;}
+        /// Equality operator.
+        /// Two iterators are equal if and only if they represents the
+        /// same node in the graph or both are invalid.
+        bool operator==(const Node&) const { return true;}
+        /// Inequality operator.
+        /// \sa operator==(const Node& n)
+        ///
+        bool operator!=(const Node&) const { return true;}
+        /// Comparison operator.
+        /// This is a strict ordering between the nodes.
+        ///
+        /// This ordering can be different from the iterating order of nodes.
+        /// \todo Possibly we don't need it.
+        bool operator<(const Node&) const { return true;}
+      };
+      typedef GraphItem<'n'> Node;
       /// Edge class of the graph.
 …
       /// This class represents the Edges of the graph.
       ///
+      class Edge {
+      public:
+        /// Default constructor.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
+        Edge() {}
+        /// Copy constructor.
+        /// Copy constructor.
+        ///
+        Edge(const Edge&) {}
+        /// Invalid constructor \& conversion.
+        /// This constructor initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
+        Edge(Invalid) {}
+        /// Assign operator for edges.
+        /// The edges are assignable.
+        ///
+        Edge& operator=(const Edge&) { return *this;}
+        /// Equality operator.
+        /// Two iterators are equal if and only if they represents the
+        /// same edge in the graph or both are invalid.
+        bool operator==(const Edge&) const { return true;}
+        /// Inequality operator.
+        /// \sa operator==(const Edge& n)
+        ///
+        bool operator!=(const Edge&) const { return true;}
+        /// Comparison operator.
+        /// This is a strict ordering between the edges.
+        ///
+        /// This ordering can be different from the iterating order of edges.
+        /// \todo Possibly we don't need it.
+        bool operator<(const Edge&) const { return true;}
+      };
+      typedef GraphItem<'e'> Edge;
       ///Gives back the target node of an edge.
 …
       ///
       Node source(const Edge&) const { return INVALID;}
+    };
+    /// Concept check structure for BaseGraph.
+    /// Concept check structure for BaseGraph.
+    ///
+    template <typename Graph>
+    struct BaseGraphComponentConcept {
+      typedef typename Graph::Node Node;
+      typedef typename Graph::Edge Edge;
+      void constraints() {
+        function_requires< GraphItemConcept<Node> >();
+        function_requires< GraphItemConcept<Edge> >();
+        {
+          Node n;
+          Edge e;
+          n = graph.source(e);
+          n = graph.target(e);
+        }
+      }
+      const Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        typedef typename _Graph::Node Node;
+        typedef typename _Graph::Edge Edge;
+        void constraints() {
+          checkConcept<GraphItem<'n'>, Node>();
+          checkConcept<GraphItem<'e'>, Edge>();
+          {
+            Node n;
+            Edge e;
+            n = graph.source(e);
+            n = graph.target(e);
+          }
+        }
+        const _Graph& graph;
+      };
     };
 …
       ///
       void nextOut(Edge&) const {}
+    };
+    /// Concept check structure for IterableBaseGraph.
+    /// Concept check structure for IterableBaseGraph.
+    ///
+    template <typename Graph>
+    struct BaseIterableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node;
+        typename Graph::Edge edge;
+        {
+          graph.first(node);
+          graph.next(node);
+        }
+        {
+          graph.first(edge);
+          graph.next(edge);
+        }
+        {
+          graph.firstIn(edge, node);
+          graph.nextIn(edge);
+        }
+        {
+          graph.firstOut(edge, node);
+          graph.nextOut(edge);
+        }
+      }
+      const Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept< BaseGraphComponent, _Graph >();
+          typename _Graph::Node node;
+          typename _Graph::Edge edge;
+          {
+            graph.first(node);
+            graph.next(node);
+          }
+          {
+            graph.first(edge);
+            graph.next(edge);
+          }
+          {
+            graph.firstIn(edge, node);
+            graph.nextIn(edge);
+          }
+          {
+            graph.firstOut(edge, node);
+            graph.nextOut(edge);
+          }
+        }
+        const _Graph& graph;
+      };
     };
 …
     /// The most of the base graphs should be conform to this concept.
     /// The id's are unique and immutable.
     class IDableGraphComponent : virtual public BaseGraphComponent {
     public:
 …
       ///
       int id(const Edge&) const { return -1;}
+    };
+    /// Concept check structure for IdableBaseGraph.
+    /// Concept check structure for IdableBaseGraph.
+    ///
+    template <typename Graph>
+    struct IDableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node;
+        int nid = graph.id(node);
+        nid = graph.id(node);
+        typename Graph::Edge edge;
+        int eid = graph.id(edge);
+        eid = graph.id(edge);
+      }
+      const Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept< BaseGraphComponent, _Graph >();
+          typename _Graph::Node node;
+          int nid = graph.id(node);
+          nid = graph.id(node);
+          typename _Graph::Edge edge;
+          int eid = graph.id(edge);
+          eid = graph.id(edge);
+        }
+        const _Graph& graph;
+      };
     };
 …
       ///
       int maxId(Edge = INVALID) const { return -1;}
+    };
+    /// Concept check structure for MaxIdableBaseGraph.
+    /// Concept check structure for MaxIdableBaseGraph.
+    ///
+    template <typename Graph>
+    struct MaxIDableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        int nid = graph.maxId(typename Graph::Node());
+        ignore_unused_variable_warning(nid);
+        int eid = graph.maxId(typename Graph::Edge());
+        ignore_unused_variable_warning(eid);
+      }
+      const Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph>();
+          int nid = graph.maxId(typename _Graph::Node());
+          ignore_unused_variable_warning(nid);
+          int eid = graph.maxId(typename _Graph::Edge());
+          ignore_unused_variable_warning(eid);
+        }
+        const _Graph& graph;
+      };
     };
 …
+      }
+    };
+    /// Concept check structure for ExtendableBaseGraph.
+    /// Concept check structure for ExtendableBaseGraph.
+    ///
+    template <typename Graph>
+    struct BaseExtendableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node_a, node_b;
+        node_a = graph.addNode();
+        typename Graph::Edge edge;
+        edge = graph.addEdge(node_a, node_b);
+      }
+      Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph >();
+          typename _Graph::Node node_a, node_b;
+          node_a = graph.addNode();
+          typename _Graph::Edge edge;
+          edge = graph.addEdge(node_a, node_b);
+        }
+        _Graph& graph;
+      };
     };
 …
       void erase(const Edge&) {}
+    };
+    /// Concept check structure for ErasableBaseGraph.
+    /// Concept check structure for ErasableBaseGraph.
+    ///
+    template <typename Graph>
+    struct BaseErasableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node;
+        graph.erase(node);
+        typename Graph::Edge edge;
+        graph.erase(edge);
+      }
+      Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph>();
+          typename _Graph::Node node;
+          graph.erase(node);
+          typename _Graph::Edge edge;
+          graph.erase(edge);
+        }
+        _Graph& graph;
+      };
     };
 …
       ///
       void clear() {}
+    };
+    /// Concept check function for ErasableBaseGraph.
+    /// Concept check function for ErasableBaseGraph.
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept< BaseGraphComponent, _Graph>();
+          graph.clear();
+        }
+        _Graph& graph;
+      };
+    };
+    /// Skeleton class for graph NodeIt and EdgeIt
+    /// Skeleton class for graph NodeIt and EdgeIt.
     ///
+    template <typename Graph>
+    struct BaseClearableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        graph.clear();
+      }
+      Graph& graph;
+    };
+    class IterableGraphComponent :
+      virtual public BaseIterableGraphComponent {
+    template <typename _Graph, typename _Item>
+    class GraphIterator : public _Item {
+    public:
+      /// \todo Don't we need the Item type as typedef?
+      /// Default constructor.
+      /// @warning The default constructor sets the iterator
+      /// to an undefined value.
+      GraphIterator() {}
+      /// Copy constructor.
+      /// Copy constructor.
+      ///
+      GraphIterator(GraphIterator const&) {}
+      /// Sets the iterator to the first item.
+      /// Sets the iterator to the first item of \c the graph.
+      ///
+      explicit GraphIterator(const _Graph&) {}
+      /// Invalid constructor \& conversion.
+      /// This constructor initializes the item to be invalid.
+      /// \sa Invalid for more details.
+      GraphIterator(Invalid) {}
+      /// Assign operator for items.
+      /// The items are assignable.
+      ///
+      GraphIterator& operator=(GraphIterator const&) { return *this; }
+      /// Next item.
+      /// Assign the iterator to the next item.
+      ///
+      GraphIterator& operator++() { return *this; }
+      //        Node operator*() const { return INVALID; }
+      /// Equality operator
+      /// Two iterators are equal if and only if they point to the
+      /// same object or both are invalid.
+      bool operator==(const GraphIterator&) const { return true;}
+      /// Inequality operator
+      /// \sa operator==(Node n)
+      ///
+      bool operator!=(const GraphIterator&) const { return true;}
+      template<typename _GraphIterator>
+      struct Constraints {
+        void constraints() {
+          //      checkConcept< Item, _GraphIterator >();
+          _GraphIterator it1(g);
+          /// \todo Do we need NodeIt(Node) kind of constructor?
+          //    _GraphIterator it2(bj);
+          _GraphIterator it2;
+          it2 = ++it1;
+          ++it2 = it1;
+          ++(++it1);
+          /// \bug This should be: is_base_and_derived<BaseItem, _GraphIterator>
+          _Item bi = it1;
+          bi = it2;
+        }
+        _Graph& g;
+      };
+    };
+    /// Skeleton class for graph InEdgeIt and OutEdgeIt
+    /// \note Because InEdgeIt and OutEdgeIt may not inherit from the same
+    /// base class, the _selector is a additional template parameter. For
+    /// InEdgeIt you should instantiate it with character 'i' and for
+    /// OutEdgeIt with 'o'.
+    /// \todo check the name of the concept GraphIncEdgeIterator
+    template <typename _Graph, char _selector>
+    class GraphIncEdgeIterator : public _Graph::Edge {
+    public:
+      /// Default constructor.
+      /// @warning The default constructor sets the iterator
+      /// to an undefined value.
+      GraphIncEdgeIterator() {}
+      /// Copy constructor.
+      /// Copy constructor.
+      ///
+      GraphIncEdgeIterator(GraphIncEdgeIterator const&) {}
+      /// Sets the iterator to the first edge incoming into or outgoing from the node.
+      /// Sets the iterator to the first edge incoming into or outgoing from the node.
+      ///
+      explicit GraphIncEdgeIterator(const _Graph&, const typename _Graph::Node&) {}
+      /// Invalid constructor \& conversion.
+      /// This constructor initializes the item to be invalid.
+      /// \sa Invalid for more details.
+      GraphIncEdgeIterator(Invalid) {}
+      /// Assign operator for nodes.
+      /// The nodes are assignable.
+      ///
+      GraphIncEdgeIterator& operator=(GraphIncEdgeIterator const&) { return *this; }
+      /// Next edge.
+      /// Assign the iterator to the next node.
+      ///
+      GraphIncEdgeIterator& operator++() { return *this; }
+      //        Node operator*() const { return INVALID; }
+      /// Equality operator
+      /// Two iterators are equal if and only if they point to the
+      /// same object or both are invalid.
+      bool operator==(const GraphIncEdgeIterator&) const { return true;}
+      /// Inequality operator
+      /// \sa operator==(Node n)
+      ///
+      bool operator!=(const GraphIncEdgeIterator&) const { return true;}
+      template <typename _GraphIncEdgeIterator>
+      struct Constraints {
+        typedef typename _Graph::Node Node;
+        typedef typename _Graph::Edge Edge;
+        void constraints() {
+          checkConcept<GraphItem<'e'>, _GraphIncEdgeIterator>();
+          _GraphIncEdgeIterator it1(graph, node);
+          /// \todo Do we need OutEdgeIt(Edge) kind of constructor?
+          //    _GraphIncEdgeIterator it2(edge);
+          _GraphIncEdgeIterator it2;
+          it2 = ++it1;
+          ++it2 = it1;
+          ++(++it1);
+          Edge e = it1;
+          e = it2;
+        }
+        Edge& edge;
+        Node& node;
+        _Graph& graph;
+      };
+    };
+    /// An empty iterable base graph class.
+    /// This class provides beside the core graph features
+    /// iterator based iterable interface for the graph structure.
+    /// This concept is part of the StaticGraphConcept.
+    class IterableGraphComponent : virtual public BaseGraphComponent {
     public:
 …
       typedef BaseGraphComponent::Edge Edge;
+      class NodeIt : public Node {
+      public:
+        NodeIt() {}
+        NodeIt(Invalid) {}
+        // explicit NodeIt(Node) {}
+        explicit NodeIt(const Graph&) {}
+        NodeIt& operator++() { return *this; }
+        //      Node operator*() const { return INVALID; }
+        bool operator==(const NodeIt&) const { return true;}
+        bool operator!=(const NodeIt&) const { return true;}
+      };
+      class EdgeIt : public Edge {
+      public:
+        EdgeIt() {}
+        EdgeIt(Invalid) {}
+        // explicit EdgeIt(Edge) {}
+        explicit EdgeIt(const Graph&) {}
+        EdgeIt& operator++() { return *this; }
+        //      Edge operator*() const { return INVALID; }
+        bool operator==(const EdgeIt&) const { return true;}
+        bool operator!=(const EdgeIt&) const { return true;}
+      };
+      class InEdgeIt : public Edge {
+      public:
+        InEdgeIt() {}
+        InEdgeIt(Invalid) {}
+        // explicit InEdgeIt(Edge) {}
+        explicit InEdgeIt(const Graph&, const Node&) {}
+        InEdgeIt& operator++() { return *this; }
+        //      Edge operator*() const { return INVALID; }
+        bool operator==(const InEdgeIt&) const { return true;}
+        bool operator!=(const InEdgeIt&) const { return true;}
+      };
+      class OutEdgeIt : public Edge {
+      public:
+        OutEdgeIt() {}
+        OutEdgeIt(Invalid) {}
+        // explicit OutEdgeIt(Edge) {}
+        explicit OutEdgeIt(const Graph&, const Node&) {}
+        OutEdgeIt& operator++() { return *this; }
+        //      Edge operator*() const { return INVALID; }
+        bool operator==(const OutEdgeIt&) const { return true;}
+        bool operator!=(const OutEdgeIt&) const { return true;}
+      };
+      /// This iterator goes through each node.
+      /// This iterator goes through each node.
+      ///
+      typedef GraphIterator<Graph, Node> NodeIt;
+      /// This iterator goes through each node.
+      /// This iterator goes through each node.
+      ///
+      typedef GraphIterator<Graph, Edge> EdgeIt;
+      /// This iterator goes trough the incoming edges of a node.
+      /// This iterator goes trough the \e inccoming edges of a certain node
+      /// of a graph.
+      typedef GraphIncEdgeIterator<Graph, 'i'> InEdgeIt;
+      /// This iterator goes trough the outgoing edges of a node.
+      /// This iterator goes trough the \e outgoing edges of a certain node
+      /// of a graph.
+      typedef GraphIncEdgeIterator<Graph, 'o'> OutEdgeIt;
     };
     template <typename Graph>
     struct IterableGraphComponentConcept {
+    template <typename _Graph>
+    struct Constraints {
       void constraints() {
+        function_requires< BaseIterableGraphComponentConcept<Graph> >();
+        typedef typename Graph::Node Node;
+        typedef typename Graph::NodeIt NodeIt;
+        typedef typename Graph::Edge Edge;
+        typedef typename Graph::EdgeIt EdgeIt;
+        typedef typename Graph::InEdgeIt InEdgeIt;
+        typedef typename Graph::OutEdgeIt OutEdgeIt;
+        checkConcept< BaseGraphComponent, _Graph>();
+        checkConcept<GraphIterator<_Graph, typename _Graph::Edge>, typename _Graph::EdgeIt >();
+        checkConcept<GraphIterator<_Graph, typename _Graph::Node>, typename _Graph::NodeIt >();
+        checkConcept<GraphIncEdgeIterator<_Graph, 'i'>, typename _Graph::InEdgeIt >();
+        checkConcept<GraphIncEdgeIterator<_Graph, 'o'>, typename _Graph::OutEdgeIt >();
+      }
+    };
+    template <typename Graph, typename Item, typename _Value>
+    class GraphMap : public ReadWriteMap<Item, _Value> {
+    protected:
+      GraphMap() {}
+    public:
+      explicit GraphMap(const Graph&) {}
+      GraphMap(const Graph&, const _Value&) {}
+      GraphMap(const GraphMap&) {}
+      GraphMap& operator=(const GraphMap&) { return *this;}
+      template<typename _Map>
+      struct Constraints {
+        void constraints() {
+          checkConcept<ReadWriteMap<Item, _Value>, _Map >();
+          // Construction with a graph parameter
+          _Map a(g);
+          // Constructor with a graph and a default value parameter
+          _Map a2(g,t);
+          // Copy constructor. Do we need it?
+          _Map b=c;
+          // Copy operator. Do we need it?
+          a=b;
+          ignore_unused_variable_warning(a2);
+        }
+        const _Map &c;
+        const Graph &g;
+        const typename GraphMap::Value &t;
+      };
+    };
+    /// An empty mappable base graph class.
+        function_requires< GraphIteratorConcept<NodeIt, Graph, Node> >();
+        function_requires< GraphIteratorConcept<EdgeIt, Graph, Edge> >();
+        function_requires< GraphIncIteratorConcept<OutEdgeIt, Graph> >();
+        function_requires< GraphIncIteratorConcept<InEdgeIt, Graph> >();
+      }
+    };
+    /// This class provides beside the core graph features
+    /// map interface for the graph structure.
+    /// This concept is part of the StaticGraphConcept.
     class MappableGraphComponent : virtual public BaseGraphComponent {
     public:
 …
       typedef BaseGraphComponent::Edge Edge;
+      /// ReadWrite map of the nodes.
+      /// ReadWrite map of the nodes.
+      ///
       template <typename _Value>
+      class NodeMap : public ReferenceMap<Node, _Value> {
+      class NodeMap : public GraphMap<Graph, Node, _Value> {
+      private:
+        NodeMap();
       public:
+        NodeMap(const Graph&) {}
+        // \todo call the right parent class constructor
+        explicit NodeMap(const Graph&) {}
         NodeMap(const Graph&, const _Value&) {}
         NodeMap(const NodeMap&) {}
         NodeMap& operator=(const NodeMap&) { return *this;}
+      };
+      };
+      /// ReadWrite map of the edges.
+      /// ReadWrite map of the edges.
+      ///
       template <typename _Value>
+      class EdgeMap : public ReferenceMap<Edge, _Value> {
+      class EdgeMap : public GraphMap<Graph, Edge, _Value> {
+      private:
+        EdgeMap();
       public:
+        EdgeMap(const Graph&) {}
+        // \todo call the right parent class constructor
+        explicit EdgeMap(const Graph&) {}
         EdgeMap(const Graph&, const _Value&) {}
         EdgeMap(const EdgeMap&) {}
         EdgeMap& operator=(const EdgeMap&) { return *this;}
+      };
+    };
+    template <typename Graph>
+    struct MappableGraphComponentConcept {
+      struct Type {
+        int value;
+        Type() : value(0) {}
+        Type(int _v) : value(_v) {}
+      };
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        { // int map test
+          typedef typename Graph::template NodeMap<int> IntNodeMap;
+          function_requires<GraphMapConcept<IntNodeMap,Graph> >();
+        } { // bool map test
+          typedef typename Graph::template NodeMap<bool> BoolNodeMap;
+          function_requires<GraphMapConcept<BoolNodeMap,Graph> >();
+        } { // Type map test
+          typedef typename Graph::template NodeMap<Type> TypeNodeMap;
+          function_requires<GraphMapConcept<TypeNodeMap,Graph> >();
+        }
+        { // int map test
+          typedef typename Graph::template EdgeMap<int> IntEdgeMap;
+          function_requires<GraphMapConcept<IntEdgeMap,Graph> >();
+        } { // bool map test
+          typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;
+          function_requires<GraphMapConcept<BoolEdgeMap,Graph> >();
+        } { // Type map test
+          typedef typename Graph::template EdgeMap<Type> TypeEdgeMap;
+          function_requires<GraphMapConcept<TypeEdgeMap,Graph> >();
+        }
+      }
+      Graph& graph;
+      };
+      template <typename _Graph>
+      struct Constraints {
+        struct Type {
+          int value;
+          Type() : value(0) {}
+          Type(int _v) : value(_v) {}
+        };
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph>();
+          { // int map test
+            typedef typename _Graph::template NodeMap<int> IntNodeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Node, int>, IntNodeMap >();
+          } { // bool map test
+            typedef typename _Graph::template NodeMap<bool> BoolNodeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Node, bool>, BoolNodeMap >();
+          } { // Type map test
+            typedef typename _Graph::template NodeMap<Type> TypeNodeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Node, Type>, TypeNodeMap >();
+          }
+          { // int map test
+            typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>, IntEdgeMap >();
+          } { // bool map test
+            typedef typename _Graph::template EdgeMap<bool> BoolEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, bool>, BoolEdgeMap >();
+          } { // Type map test
+            typedef typename _Graph::template EdgeMap<Type> TypeEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, Type>, TypeEdgeMap >();
+          }
+        }
+        _Graph& graph;
+      };
     };
 …
+      }
+    };
+    template <typename Graph>
+    struct ExtendableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node_a, node_b;
+        node_a = graph.addNode();
+        typename Graph::Edge edge;
+        edge = graph.addEdge(node_a, node_b);
+      }
+      Graph& graph;
+    };
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph >();
+          typename _Graph::Node node_a, node_b;
+          node_a = graph.addNode();
+          typename _Graph::Edge edge;
+          edge = graph.addEdge(node_a, node_b);
+        }
+        _Graph& graph;
+      };
+    };
     class ErasableGraphComponent : virtual public BaseGraphComponent {
     public:
 …
       void erase(const Edge&) {}
+    };
+    template <typename Graph>
+    struct ErasableGraphComponentConcept {
+      void constraints() {
+        function_requires< BaseGraphComponentConcept<Graph> >();
+        typename Graph::Node node;
+        graph.erase(node);
+        typename Graph::Edge edge;
+        graph.erase(edge);
+      }
+      Graph& graph;
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseGraphComponent, _Graph >();
+          typename _Graph::Node node;
+          graph.erase(node);
+          typename _Graph::Edge edge;
+          graph.erase(edge);
+        }
+        _Graph& graph;
+      };
     };
 …
       void clear() {}
+    };
     template <typename Graph>
     struct ClearableGraphComponentConcept {
+      void constraints() {
         function_requires< BaseGraphComponentConcept<Graph> >();
         graph.clear();
+      }
       Graph& graph;
+      template <typename _Graph>
+      struct ClearableGraphComponentConcept {
+        void constraints() {
+          checkConcept< BaseGraphComponent, _Graph >();
+          graph.clear();
+        }
+        _Graph& graph;
+      };
     };

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 989:ca95f8b5c931 in lemon-0.x for src/lemon/concept/graph_component.h

Legend:

src/lemon/concept/graph_component.h

Download in other formats: