Changeset 987:87f7c54892df in lemon-0.x for src/lemon/concept/maps.h

Timestamp:

11/13/04 18:07:10 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Naming changes:

• ValueType? -> Value
• KeyType? -> Key
• ReferenceType? ->Reference
• PointerType? -> Pointer

File:

• src/lemon/concept/maps.h (modified) (10 diffs)

src/lemon/concept/maps.h

@@ -37 +37 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Returns the value associated with a key.
-      ValueType operator[](const KeyType &k) const {return ValueType();}
+      Value operator[](const Key &k) const {return Value();}
 
       ///Default constructor
@@ -55 +55 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) {}
+      void set(const Key &k,const Value &t) {}
 
       ///Default constructor
@@ -73 +73 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Returns the value associated with a key.
-      ValueType operator[](const KeyType &k) const {return ValueType();}
+      Value operator[](const Key &k) const {return Value();}
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) {}
+      void set(const Key &k,const Value &t) {}
 
       ///Default constructor
@@ -93 +93 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
     protected:
-      ValueType tmp;
-    public:
-      typedef ValueType& ReferenceType;
+      Value tmp;
+    public:
+      typedef Value& Reference;
       /// Map's const reference type.
-      typedef const ValueType& ConstReferenceType;
+      typedef const Value& ConstReference;
 
       ///Returns a reference to the value associated to a key.
-      ReferenceType operator[](const KeyType &i) { return tmp; }
+      Reference operator[](const Key &i) { return tmp; }
       ///Returns a const reference to the value associated to a key.
-      ConstReferenceType operator[](const KeyType &i) const
+      ConstReference operator[](const Key &i) const
       { return tmp; }
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) { operator[](k)=t; }
+      void set(const Key &k,const Value &t) { operator[](k)=t; }
 
       ///Default constructor
@@ -150 +150 @@
     template<typename ReadMap>
     struct ReadMapConcept {
-      typedef typename ReadMap::KeyType KeyType;
-      typedef typename ReadMap::ValueType ValueType;
+      typedef typename ReadMap::Key Key;
+      typedef typename ReadMap::Value Value;
 
       void constraints() {
         // No constraints for constructor.
 
-        // What are the requirement for the ValueType?
+        // What are the requirement for the Value?
         // CopyConstructible? Assignable? None of these?
-        ValueType v = m[k];
+        Value v = m[k];
         v = m[k];
 
@@ -166 +166 @@
 
       ReadMap m;
-      KeyType k;
+      Key k;
     };
 
     template<typename WriteMap>
     struct WriteMapConcept {
-      typedef typename WriteMap::KeyType KeyType;
-      typedef typename WriteMap::ValueType ValueType;
+      typedef typename WriteMap::Key Key;
+      typedef typename WriteMap::Value Value;
 
       void constraints() {
@@ -181 +181 @@
 
       WriteMap m;
-      KeyType k;
-      ValueType v;
+      Key k;
+      Value v;
     };
 
@@ -195 +195 @@
     template<typename ReferenceMap>
     struct ReferenceMapConcept {
-      typedef typename ReferenceMap::KeyType KeyType;
-      typedef typename ReferenceMap::ValueType ValueType;
-      typedef typename ReferenceMap::ReferenceType ReferenceType;
+      typedef typename ReferenceMap::Key Key;
+      typedef typename ReferenceMap::Value Value;
+      typedef typename ReferenceMap::Reference Reference;
 
       // What for is this?
-      typedef typename ReferenceMap::ConstReferenceType ConstReferenceType;
+      typedef typename ReferenceMap::ConstReference ConstReference;
 
       void constraints() {
@@ -208 +208 @@
         // Or should we require real reference?
         // Like this:
-        // ValueType &vv = m[k];
+        // Value &vv = m[k];
         // ignore_unused_variable_warning(vv);
       }
 
       ReferenceMap m;
-      KeyType k;
-      ValueType v;
+      Key k;
+      Value v;
     };
 
@@ -236 +236 @@
       const GraphMap &c;
       const Graph &g;
-      const typename GraphMap::ValueType &t;
+      const typename GraphMap::Value &t;
     };