lemon/concepts/maps.h
author Alpar Juttner <alpar@cs.elte.hu>
Mon, 17 Mar 2008 19:21:27 +0000
changeset 93 f857981306ea
parent 74 9394072da54f
child 94 a4688e4138ec
permissions -rw-r--r--
Merge
     1 /* -*- C++ -*-
     2  *
     3  * This file is a part of LEMON, a generic C++ optimization library
     4  *
     5  * Copyright (C) 2003-2008
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
     8  *
     9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 #ifndef LEMON_CONCEPT_MAPS_H
    20 #define LEMON_CONCEPT_MAPS_H
    21 
    22 #include <lemon/bits/utility.h>
    23 #include <lemon/concept_check.h>
    24 
    25 ///\ingroup concept
    26 ///\file
    27 ///\brief Map concepts checking classes for testing and documenting.
    28 
    29 namespace lemon {
    30 
    31   namespace concepts {
    32 
    33     /// \addtogroup concept
    34     /// @{
    35 
    36     /// Readable map concept
    37 
    38     /// Readable map concept.
    39     ///
    40     template<typename K, typename T>
    41     class ReadMap
    42     {
    43     public:
    44       /// The key type of the map.
    45       typedef K Key;
    46       /// The value type of the map. (The type of objects associated with the keys).
    47       typedef T Value;
    48 
    49       /// Returns the value associated with the given key.
    50 
    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(); }
    54 
    55       template<typename _ReadMap>
    56       struct Constraints {
    57 	void constraints() {
    58 	  Value val = m[key];
    59 	  val = m[key];
    60 	  typename _ReadMap::Value own_val = m[own_key];
    61 	  own_val = m[own_key];
    62 
    63 	  ignore_unused_variable_warning(key);
    64 	  ignore_unused_variable_warning(val);
    65 	  ignore_unused_variable_warning(own_key);
    66 	  ignore_unused_variable_warning(own_val);
    67 	}
    68 	const Key& key;
    69 	const typename _ReadMap::Key& own_key;
    70 	const _ReadMap& m;
    71       };
    72 
    73     };
    74 
    75 
    76     /// Writable map concept
    77 
    78     /// Writable map concept.
    79     ///
    80     template<typename K, typename T>
    81     class WriteMap
    82     {
    83     public:
    84       /// The key type of the map.
    85       typedef K Key;
    86       /// The value type of the map. (The type of objects associated with the keys).
    87       typedef T Value;
    88 
    89       /// Sets the value associated with the given key.
    90       void set(const Key &, const Value &) {}
    91 
    92       /// Default constructor.
    93       WriteMap() {}
    94 
    95       template <typename _WriteMap>
    96       struct Constraints {
    97 	void constraints() {
    98 	  m.set(key, val);
    99 	  m.set(own_key, own_val);
   100 
   101 	  ignore_unused_variable_warning(key);
   102 	  ignore_unused_variable_warning(val);
   103 	  ignore_unused_variable_warning(own_key);
   104 	  ignore_unused_variable_warning(own_val);
   105 	}
   106 	const Key& key;
   107 	const Value& val;
   108 	const typename _WriteMap::Key& own_key;
   109 	const typename _WriteMap::Value own_val;
   110 	_WriteMap& m;
   111       };
   112     };
   113 
   114     /// Read/writable map concept
   115 
   116     /// Read/writable map concept.
   117     ///
   118     template<typename K, typename T>
   119     class ReadWriteMap : public ReadMap<K,T>,
   120 			 public WriteMap<K,T>
   121     {
   122     public:
   123       /// The key type of the map.
   124       typedef K Key;
   125       /// The value type of the map. (The type of objects associated with the keys).
   126       typedef T Value;
   127 
   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 &) {}
   133 
   134       template<typename _ReadWriteMap>
   135       struct Constraints {
   136 	void constraints() {
   137 	  checkConcept<ReadMap<K, T>, _ReadWriteMap >();
   138 	  checkConcept<WriteMap<K, T>, _ReadWriteMap >();
   139 	}
   140       };
   141     };
   142 
   143 
   144     /// Dereferable map concept
   145 
   146     /// Dereferable map concept.
   147     ///
   148     template<typename K, typename T, typename R, typename CR>
   149     class ReferenceMap : public ReadWriteMap<K,T>
   150     {
   151     public:
   152       /// Tag for reference maps.
   153       typedef True ReferenceMapTag;
   154       /// The key type of the map.
   155       typedef K Key;
   156       /// The value type of the map. (The type of objects associated with the keys).
   157       typedef T Value;
   158       /// The reference type of the map.
   159       typedef R Reference;
   160       /// The const reference type of the map.
   161       typedef CR ConstReference;
   162 
   163     protected:
   164       Value tmp;
   165     public:
   166 
   167       /// Returns a reference to the value associated with the given key.
   168       Reference operator[](const Key &) { return tmp; }
   169 
   170       /// Returns a const reference to the value associated with the given key.
   171       ConstReference operator[](const Key &) const { return tmp; }
   172 
   173       /// Sets the value associated with the given key.
   174       void set(const Key &k,const Value &t) { operator[](k)=t; }
   175 
   176       template<typename _ReferenceMap>
   177       struct Constraints {
   178 	void constraints() {
   179 	  checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
   180 	  ref = m[key];
   181 	  m[key] = val;
   182 	  m[key] = ref;
   183 	  m[key] = cref;
   184 	  own_ref = m[own_key];
   185 	  m[own_key] = own_val;
   186 	  m[own_key] = own_ref;
   187 	  m[own_key] = own_cref;
   188 	  m[key] = m[own_key];
   189 	  m[own_key] = m[key];
   190 	}
   191 	const Key& key;
   192 	Value& val;
   193 	Reference ref;
   194 	ConstReference cref;
   195 	const typename _ReferenceMap::Key& own_key;
   196 	typename _ReferenceMap::Value& own_val;
   197 	typename _ReferenceMap::Reference own_ref;
   198 	typename _ReferenceMap::ConstReference own_cref;
   199 	_ReferenceMap& m;
   200       };
   201     };
   202 
   203     // @}
   204 
   205   } //namespace concepts
   206 
   207 } //namespace lemon
   208 
   209 #endif // LEMON_CONCEPT_MAPS_H