Changeset - r79:d73c2e8b25cb
« 76:fc178a
80:15968e »
gravatar
kpeter (Peter Kovacs)
kpeter@inf.elte.hu
More exact concept checking for map concepts.
0 1 0
default
1 file changed with 52 insertions and 49 deletions:
lemon/concepts/maps.h
52
49
↑ Collapse diff ↑
lemon/concepts/maps.h
Ignore white space 12 line context
... ... 
@@ -26,176 +26,179 @@
26 26 
///\file
27 27 
///\brief Map concepts checking classes for testing and documenting.
28 28 

			




	29
	29
	
		
namespace lemon {


			




	30
	30
	
		

			




	31
	31
	
		
  namespace concepts {


			




	32
	
	
		
  


			




	
	32
	
		

			




	33
	33
	
		
    /// \addtogroup concept


			




	34
	34
	
		
    /// @{


			




	35
	35
	
		

			




	36
	36
	
		
    /// Readable map concept


			




	37
	37
	
		

			




	38
	38
	
		
    /// Readable map concept.


			




	39
	39
	
		
    ///


			




	40
	40
	
		
    template<typename K, typename T>


			




	41
	41
	
		
    class ReadMap


			




	42
	42
	
		
    {


			




	43
	43
	
		
    public:


			




	44
	44
	
		
      /// The key type of the map.


			




	45
	
	
		
      typedef K Key;    


			




	
	45
	
		
      typedef K Key;


			




	46
	46
	
		
      /// The value type of the map. (The type of objects associated with the keys).


			




	47
	47
	
		
      typedef T Value;


			




	48
	48
	
		

			




	49
	
	
		
      /// Returns the value associated with a key.


			




	
	49
	
		
      /// Returns the value associated with the given key.


			




	50
	50
	
		

			




	51
	
	
		
      /// Returns the value associated with a key.


			




	52
	
	
		
      /// \bug Value shouldn't need to be default constructible.


			




	53
	
	
		
      ///


			




	54
	
	
		
      Value operator[](const Key &) const {return Value();}


			




	
	51
	
		
      /// Returns the value associated with the given key.


			




	
	52
	
		
      /// \bug Value shouldn't need to be default constructible. 


			




	
	53
	
		
      Value operator[](const Key &) const { return Value(); }


			




	55
	54
	
		

			




	56
	55
	
		
      template<typename _ReadMap>


			




	57
	56
	
		
      struct Constraints {


			




	58
	57
	
		
	void constraints() {


			




	59
	58
	
		
	  Value val = m[key];


			




	60
	59
	
		
	  val = m[key];


			




	61
	
	
		
	  typename _ReadMap::Value own_val = m[own_key]; 


			




	62
	
	
		
	  own_val = m[own_key]; 


			




	
	60
	
		
	  typename _ReadMap::Value own_val = m[own_key];


			




	
	61
	
		
	  own_val = m[own_key];


			




	63
	62
	
		

			




	
	63
	
		
	  ignore_unused_variable_warning(key);


			




	64
	64
	
		
	  ignore_unused_variable_warning(val);


			




	
	65
	
		
	  ignore_unused_variable_warning(own_key);


			




	65
	66
	
		
	  ignore_unused_variable_warning(own_val);


			




	66
	
	
		
	  ignore_unused_variable_warning(key);


			




	67
	67
	
		
	}


			




	68
	
	
		
	Key& key;


			




	69
	
	
		
	typename _ReadMap::Key& own_key;


			




	70
	
	
		
	_ReadMap& m;


			




	
	68
	
		
	const Key& key;


			




	
	69
	
		
	const typename _ReadMap::Key& own_key;


			




	
	70
	
		
	const _ReadMap& m;


			




	71
	71
	
		
      };


			




	72
	
	
		
      


			




	
	72
	
		

			




	73
	73
	
		
    };


			




	74
	74
	
		

			




	75
	75
	
		

			




	76
	76
	
		
    /// Writable map concept


			




	77
	
	
		
    


			




	
	77
	
		

			




	78
	78
	
		
    /// Writable map concept.


			




	79
	79
	
		
    ///


			




	80
	80
	
		
    template<typename K, typename T>


			




	81
	81
	
		
    class WriteMap


			




	82
	82
	
		
    {


			




	83
	83
	
		
    public:


			




	84
	84
	
		
      /// The key type of the map.


			




	85
	
	
		
      typedef K Key;    


			




	
	85
	
		
      typedef K Key;


			




	86
	86
	
		
      /// The value type of the map. (The type of objects associated with the keys).


			




	87
	87
	
		
      typedef T Value;


			




	88
	88
	
		

			




	89
	
	
		
      /// Sets the value associated with a key.


			




	90
	
	
		
      void set(const Key &,const Value &) {}


			




	
	89
	
		
      /// Sets the value associated with the given key.


			




	
	90
	
		
      void set(const Key &, const Value &) {}


			




	91
	91
	
		

			




	92
	
	
		
      ///Default constructor


			




	
	92
	
		
      /// Default constructor.


			




	93
	93
	
		
      WriteMap() {}


			




	94
	94
	
		

			




	95
	95
	
		
      template <typename _WriteMap>


			




	96
	96
	
		
      struct Constraints {


			




	97
	97
	
		
	void constraints() {


			




	98
	
	
		
	  // No constraints for constructor.


			




	99
	98
	
		
	  m.set(key, val);


			




	100
	99
	
		
	  m.set(own_key, own_val);


			




	
	100
	
		

			




	101
	101
	
		
	  ignore_unused_variable_warning(key);


			




	102
	102
	
		
	  ignore_unused_variable_warning(val);


			




	103
	103
	
		
	  ignore_unused_variable_warning(own_key);


			




	104
	104
	
		
	  ignore_unused_variable_warning(own_val);


			




	105
	105
	
		
	}


			




	106
	
	
		

			




	107
	
	
		
	Value& val;


			




	108
	
	
		
	typename _WriteMap::Value own_val;


			




	109
	
	
		
	Key& key;


			




	110
	
	
		
	typename _WriteMap::Key& own_key;


			




	
	106
	
		
	const Key& key;


			




	
	107
	
		
	const Value& val;


			




	
	108
	
		
	const typename _WriteMap::Key& own_key;


			




	
	109
	
		
	const typename _WriteMap::Value own_val;


			




	111
	110
	
		
	_WriteMap& m;


			




	112
	
	
		

			




	113
	111
	
		
      };


			




	114
	112
	
		
    };


			




	115
	113
	
		

			




	116
	114
	
		
    /// Read/writable map concept


			




	117
	
	
		
    


			




	
	115
	
		

			




	118
	116
	
		
    /// Read/writable map concept.


			




	119
	117
	
		
    ///


			




	120
	118
	
		
    template<typename K, typename T>


			




	121
	119
	
		
    class ReadWriteMap : public ReadMap<K,T>,


			




	122
	120
	
		
			 public WriteMap<K,T>


			




	123
	121
	
		
    {


			




	124
	122
	
		
    public:


			




	125
	123
	
		
      /// The key type of the map.


			




	126
	
	
		
      typedef K Key;    


			




	
	124
	
		
      typedef K Key;


			




	127
	125
	
		
      /// The value type of the map. (The type of objects associated with the keys).


			




	128
	126
	
		
      typedef T Value;


			




	129
	127
	
		

			




	130
	
	
		
      /// Returns the value associated with a key.


			




	131
	
	
		
      Value operator[](const Key &) const {return Value();}


			




	132
	
	
		
      /// Sets the value associated with a key.


			




	133
	
	
		
      void set(const Key & ,const Value &) {}


			




	
	128
	
		
      /// Returns the value associated with the given key.


			




	
	129
	
		
      Value operator[](const Key &) const { return Value(); }


			




	
	130
	
		

			




	
	131
	
		
      /// Sets the value associated with the given key.


			




	
	132
	
		
      void set(const Key &, const Value &) {}


			




	134
	133
	
		

			




	135
	134
	
		
      template<typename _ReadWriteMap>


			




	136
	135
	
		
      struct Constraints {


			




	137
	136
	
		
	void constraints() {


			




	138
	137
	
		
	  checkConcept<ReadMap<K, T>, _ReadWriteMap >();


			




	139
	138
	
		
	  checkConcept<WriteMap<K, T>, _ReadWriteMap >();


			




	140
	139
	
		
	}


			




	141
	140
	
		
      };


			




	142
	141
	
		
    };


			




	143
	
	
		
  


			




	144
	
	
		
  


			




	
	142
	
		

			




	
	143
	
		

			




	145
	144
	
		
    /// Dereferable map concept


			




	146
	
	
		
    


			




	
	145
	
		

			




	147
	146
	
		
    /// Dereferable map concept.


			




	148
	147
	
		
    ///


			




	149
	
	
		
    /// \todo Rethink this concept.


			




	150
	148
	
		
    template<typename K, typename T, typename R, typename CR>


			




	151
	149
	
		
    class ReferenceMap : public ReadWriteMap<K,T>


			




	152
	150
	
		
    {


			




	153
	151
	
		
    public:


			




	154
	152
	
		
      /// Tag for reference maps.


			




	155
	153
	
		
      typedef True ReferenceMapTag;


			




	156
	154
	
		
      /// The key type of the map.


			




	157
	
	
		
      typedef K Key;    


			




	
	155
	
		
      typedef K Key;


			




	158
	156
	
		
      /// The value type of the map. (The type of objects associated with the keys).


			




	159
	157
	
		
      typedef T Value;


			




	160
	158
	
		
      /// The reference type of the map.


			




	161
	159
	
		
      typedef R Reference;


			




	162
	160
	
		
      /// The const reference type of the map.


			




	163
	161
	
		
      typedef CR ConstReference;


			




	164
	162
	
		

			




	165
	163
	
		
    protected:


			




	166
	164
	
		
      Value tmp;


			




	167
	165
	
		
    public:


			




	168
	166
	
		

			




	169
	
	
		
      ///Returns a reference to the value associated with a key.


			




	
	167
	
		
      /// Returns a reference to the value associated with the given key.


			




	170
	168
	
		
      Reference operator[](const Key &) { return tmp; }


			




	171
	
	
		
      ///Returns a const reference to the value associated with a key.


			




	
	169
	
		

			




	
	170
	
		
      /// Returns a const reference to the value associated with the given key.


			




	172
	171
	
		
      ConstReference operator[](const Key &) const { return tmp; }


			




	173
	
	
		
      /// Sets the value associated with a key.


			




	
	172
	
		

			




	
	173
	
		
      /// Sets the value associated with the given key.


			




	174
	174
	
		
      void set(const Key &k,const Value &t) { operator[](k)=t; }


			




	175
	175
	
		

			




	176
	176
	
		
      template<typename _ReferenceMap>


			




	177
	177
	
		
      struct Constraints {


			




	178
	178
	
		
	void constraints() {


			




	179
	179
	
		
	  checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();


			




	
	180
	
		
	  ref = m[key];


			




	180
	181
	
		
	  m[key] = val;


			




	181
	
	
		
	  val  = m[key];


			




	182
	182
	
		
	  m[key] = ref;


			




	183
	
	
		
	  ref = m[key];


			




	
	183
	
		
	  m[key] = cref;


			




	
	184
	
		
	  own_ref = m[own_key];


			




	184
	185
	
		
	  m[own_key] = own_val;


			




	185
	
	
		
	  own_val  = m[own_key];


			




	186
	186
	
		
	  m[own_key] = own_ref;


			




	187
	
	
		
	  own_ref = m[own_key];	  	  


			




	
	187
	
		
	  m[own_key] = own_cref;


			




	
	188
	
		
	  m[key] = m[own_key];


			




	
	189
	
		
	  m[own_key] = m[key];


			




	188
	190
	
		
	}


			




	189
	
	
		

			




	190
	
	
		
	typename _ReferenceMap::Key& own_key;


			




	
	191
	
		
	const Key& key;


			




	
	192
	
		
	Value& val;


			




	
	193
	
		
	Reference ref;


			




	
	194
	
		
	ConstReference cref;


			




	
	195
	
		
	const typename _ReferenceMap::Key& own_key;


			




	191
	196
	
		
	typename _ReferenceMap::Value& own_val;


			




	192
	197
	
		
	typename _ReferenceMap::Reference own_ref;


			




	193
	
	
		
	Key& key;


			




	194
	
	
		
	Value& val;


			




	195
	
	
		
	Reference ref;


			




	
	198
	
		
	typename _ReferenceMap::ConstReference own_cref;


			




	196
	199
	
		
	_ReferenceMap& m;


			




	197
	200
	
		
      };


			




	198
	201
	
		
    };


			




	199
	202
	
		

			




	200
	203
	
		
    // @}


			




	201
	204
	
		

			




        

    






    
    



    


    

     
    
0 comments (0 inline)