Changeset 946:c94ef40a22ce in lemon-0.x for src/lemon/skeletons/maps.h

Timestamp:

10/28/04 00:38:50 (20 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

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

Message:

The graph_factory branch (@ 1321) has been merged to trunk.

File:

• src/lemon/skeletons/maps.h (modified) (2 diffs)

src/lemon/skeletons/maps.h

@@ -17 +17 @@
 #ifndef LEMON_MAPSKELETON_H
 #define LEMON_MAPSKELETON_H
+
+#include <lemon/concept_check.h>
 
 ///\ingroup skeletons
@@ -114 +116 @@
     };
 
+
+    template<typename Item, typename T, typename Graph>
+    class GraphMap : public ReadWriteMap<Item, T> {
+      // I really, really don't like the idea that every graph should have
+      // reference maps! --klao
+
+    private:
+      // We state explicitly that graph maps have no default constructor?
+      GraphMap();
+
+    public:
+      explicit GraphMap(Graph const&) {}
+      // value for initializing
+      GraphMap(Graph const&, T) {}
+
+      // this probably should be required:
+      GraphMap(GraphMap const&) {}
+      GraphMap& operator=(GraphMap const&) { return *this; }
+
+      // but this is a absolute no-op! We should provide a more generic
+      // graph-map-copy operation.
+      //
+      // template<typename TT>
+      // GraphMap(GraphMap<TT> const&);
+      //
+      // template<typename TT>
+      // GraphMap& operator=(const GraphMap<TT>&);
+    };
+
+
+    /****************  Concept-checking classes  ****************/
+
+    template<typename ReadMap>
+    struct ReadMapConcept {
+      typedef typename ReadMap::KeyType KeyType;
+      typedef typename ReadMap::ValueType ValueType;
+
+      void constraints() {
+        // No constraints for constructor.
+
+        // What are the requirement for the ValueType?
+        // CopyConstructible? Assignable? None of these?
+        ValueType v = m[k];
+        v = m[k];
+
+        // FIXME:
+        ignore_unused_variable_warning(v);
+      }
+
+      ReadMap m;
+      KeyType k;
+    };
+
+    template<typename WriteMap>
+    struct WriteMapConcept {
+      typedef typename WriteMap::KeyType KeyType;
+      typedef typename WriteMap::ValueType ValueType;
+
+      void constraints() {
+        // No constraints for constructor.
+
+        m.set(k, v);
+      }
+
+      WriteMap m;
+      KeyType k;
+      ValueType v;
+    };
+
+    template<typename ReadWriteMap>
+    struct ReadWriteMapConcept {
+      void constraints() {
+        function_requires< ReadMapConcept<ReadWriteMap> >();
+        function_requires< WriteMapConcept<ReadWriteMap> >();
+      }
+    };
+
+    template<typename ReferenceMap>
+    struct ReferenceMapConcept {
+      typedef typename ReferenceMap::KeyType KeyType;
+      typedef typename ReferenceMap::ValueType ValueType;
+      typedef typename ReferenceMap::ReferenceType ReferenceType;
+
+      // What for is this?
+      typedef typename ReferenceMap::ConstReferenceType ConstReferenceType;
+
+      void constraints() {
+        function_requires< ReadWriteMapConcept<ReferenceMap> >();
+
+        m[k] = v;
+        // Or should we require real reference?
+        // Like this:
+        // ValueType &vv = m[k];
+        // ignore_unused_variable_warning(vv);
+      }
+
+      ReferenceMap m;
+      KeyType k;
+      ValueType v;
+    };
+
+    /// \todo GraphMapConceptCheck
+
+    template<typename GraphMap, typename Graph>
+    struct GraphMapConcept {
+      void constraints() {
+        function_requires< ReadWriteMapConcept<GraphMap> >();
+        // Construction with a graph parameter
+        GraphMap a(g);
+        // Ctor with a graph and a default value parameter
+        GraphMap a2(g,t);
+        // Copy ctor. Do we need it?
+        GraphMap b=c;
+        // Copy operator. Do we need it?
+        a=b;
+
+        ignore_unused_variable_warning(a2);
+      }
+      const GraphMap &c;
+      const Graph &g;
+      const typename GraphMap::ValueType &t;
+    };
+    
+
     // @}