[906] | 1 | /* -*- C++ -*- |
---|
[921] | 2 | * src/lemon/skeletons/maps.h - Part of LEMON, a generic C++ optimization library |
---|
[906] | 3 | * |
---|
| 4 | * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
---|
| 5 | * (Egervary Combinatorial Optimization Research Group, EGRES). |
---|
| 6 | * |
---|
| 7 | * Permission to use, modify and distribute this software is granted |
---|
| 8 | * provided that this copyright notice appears in all copies. For |
---|
| 9 | * precise terms see the accompanying LICENSE file. |
---|
| 10 | * |
---|
| 11 | * This software is provided "AS IS" with no warranty of any kind, |
---|
| 12 | * express or implied, and with no claim as to its suitability for any |
---|
| 13 | * purpose. |
---|
| 14 | * |
---|
| 15 | */ |
---|
| 16 | |
---|
[921] | 17 | #ifndef LEMON_MAPSKELETON_H |
---|
| 18 | #define LEMON_MAPSKELETON_H |
---|
[186] | 19 | |
---|
[946] | 20 | #include <lemon/concept_check.h> |
---|
| 21 | |
---|
[794] | 22 | ///\ingroup skeletons |
---|
[242] | 23 | ///\file |
---|
| 24 | ///\brief Map concepts checking classes for testing and documenting. |
---|
| 25 | |
---|
[921] | 26 | namespace lemon { |
---|
[282] | 27 | |
---|
| 28 | namespace skeleton { |
---|
[186] | 29 | |
---|
[794] | 30 | /// \addtogroup skeletons |
---|
| 31 | /// @{ |
---|
| 32 | |
---|
[282] | 33 | /// Readable map concept |
---|
| 34 | template<typename K, typename T> |
---|
[732] | 35 | class ReadMap |
---|
[282] | 36 | { |
---|
| 37 | public: |
---|
| 38 | /// Map's key type. |
---|
| 39 | typedef K KeyType; |
---|
| 40 | /// Map's value type. (The type of objects associated with the keys). |
---|
| 41 | typedef T ValueType; |
---|
[186] | 42 | |
---|
[282] | 43 | /// Returns the value associated with a key. |
---|
| 44 | ValueType operator[](const KeyType &k) const {return ValueType();} |
---|
[186] | 45 | |
---|
[732] | 46 | ///Default constructor |
---|
| 47 | ReadMap() {} |
---|
[282] | 48 | }; |
---|
| 49 | |
---|
| 50 | |
---|
| 51 | /// Writable map concept |
---|
| 52 | template<typename K, typename T> |
---|
[732] | 53 | class WriteMap |
---|
[282] | 54 | { |
---|
| 55 | public: |
---|
| 56 | /// Map's key type. |
---|
| 57 | typedef K KeyType; |
---|
| 58 | /// Map's value type. (The type of objects associated with the keys). |
---|
| 59 | typedef T ValueType; |
---|
| 60 | |
---|
| 61 | /// Sets the value associated with a key. |
---|
| 62 | void set(const KeyType &k,const ValueType &t) {} |
---|
| 63 | |
---|
[732] | 64 | ///Default constructor |
---|
| 65 | WriteMap() {} |
---|
[282] | 66 | }; |
---|
| 67 | |
---|
[809] | 68 | ///Read/Writable map concept |
---|
[282] | 69 | template<typename K, typename T> |
---|
[732] | 70 | class ReadWriteMap : public ReadMap<K,T>, |
---|
| 71 | public WriteMap<K,T> |
---|
[282] | 72 | { |
---|
| 73 | public: |
---|
| 74 | /// Map's key type. |
---|
| 75 | typedef K KeyType; |
---|
| 76 | /// Map's value type. (The type of objects associated with the keys). |
---|
| 77 | typedef T ValueType; |
---|
| 78 | |
---|
| 79 | /// Returns the value associated with a key. |
---|
| 80 | ValueType operator[](const KeyType &k) const {return ValueType();} |
---|
| 81 | /// Sets the value associated with a key. |
---|
| 82 | void set(const KeyType &k,const ValueType &t) {} |
---|
| 83 | |
---|
[732] | 84 | ///Default constructor |
---|
| 85 | ReadWriteMap() {} |
---|
[282] | 86 | }; |
---|
[186] | 87 | |
---|
| 88 | |
---|
[282] | 89 | ///Dereferable map concept |
---|
| 90 | template<typename K, typename T> |
---|
[732] | 91 | class ReferenceMap : public ReadWriteMap<K,T> |
---|
[282] | 92 | { |
---|
| 93 | public: |
---|
| 94 | /// Map's key type. |
---|
| 95 | typedef K KeyType; |
---|
| 96 | /// Map's value type. (The type of objects associated with the keys). |
---|
| 97 | typedef T ValueType; |
---|
[732] | 98 | |
---|
| 99 | protected: |
---|
| 100 | ValueType tmp; |
---|
| 101 | public: |
---|
[282] | 102 | typedef ValueType& ReferenceType; |
---|
| 103 | /// Map's const reference type. |
---|
| 104 | typedef const ValueType& ConstReferenceType; |
---|
[186] | 105 | |
---|
[282] | 106 | ///Returns a reference to the value associated to a key. |
---|
[732] | 107 | ReferenceType operator[](const KeyType &i) { return tmp; } |
---|
[282] | 108 | ///Returns a const reference to the value associated to a key. |
---|
[732] | 109 | ConstReferenceType operator[](const KeyType &i) const |
---|
| 110 | { return tmp; } |
---|
[282] | 111 | /// Sets the value associated with a key. |
---|
| 112 | void set(const KeyType &k,const ValueType &t) { operator[](k)=t; } |
---|
[186] | 113 | |
---|
[732] | 114 | ///Default constructor |
---|
| 115 | ReferenceMap() {} |
---|
[282] | 116 | }; |
---|
[794] | 117 | |
---|
[946] | 118 | |
---|
| 119 | template<typename Item, typename T, typename Graph> |
---|
| 120 | class GraphMap : public ReadWriteMap<Item, T> { |
---|
| 121 | // I really, really don't like the idea that every graph should have |
---|
| 122 | // reference maps! --klao |
---|
| 123 | |
---|
| 124 | private: |
---|
| 125 | // We state explicitly that graph maps have no default constructor? |
---|
| 126 | GraphMap(); |
---|
| 127 | |
---|
| 128 | public: |
---|
| 129 | explicit GraphMap(Graph const&) {} |
---|
| 130 | // value for initializing |
---|
| 131 | GraphMap(Graph const&, T) {} |
---|
| 132 | |
---|
| 133 | // this probably should be required: |
---|
| 134 | GraphMap(GraphMap const&) {} |
---|
| 135 | GraphMap& operator=(GraphMap const&) { return *this; } |
---|
| 136 | |
---|
| 137 | // but this is a absolute no-op! We should provide a more generic |
---|
| 138 | // graph-map-copy operation. |
---|
| 139 | // |
---|
| 140 | // template<typename TT> |
---|
| 141 | // GraphMap(GraphMap<TT> const&); |
---|
| 142 | // |
---|
| 143 | // template<typename TT> |
---|
| 144 | // GraphMap& operator=(const GraphMap<TT>&); |
---|
| 145 | }; |
---|
| 146 | |
---|
| 147 | |
---|
| 148 | /**************** Concept-checking classes ****************/ |
---|
| 149 | |
---|
| 150 | template<typename ReadMap> |
---|
| 151 | struct ReadMapConcept { |
---|
| 152 | typedef typename ReadMap::KeyType KeyType; |
---|
| 153 | typedef typename ReadMap::ValueType ValueType; |
---|
| 154 | |
---|
| 155 | void constraints() { |
---|
| 156 | // No constraints for constructor. |
---|
| 157 | |
---|
| 158 | // What are the requirement for the ValueType? |
---|
| 159 | // CopyConstructible? Assignable? None of these? |
---|
| 160 | ValueType v = m[k]; |
---|
| 161 | v = m[k]; |
---|
| 162 | |
---|
| 163 | // FIXME: |
---|
| 164 | ignore_unused_variable_warning(v); |
---|
| 165 | } |
---|
| 166 | |
---|
| 167 | ReadMap m; |
---|
| 168 | KeyType k; |
---|
| 169 | }; |
---|
| 170 | |
---|
| 171 | template<typename WriteMap> |
---|
| 172 | struct WriteMapConcept { |
---|
| 173 | typedef typename WriteMap::KeyType KeyType; |
---|
| 174 | typedef typename WriteMap::ValueType ValueType; |
---|
| 175 | |
---|
| 176 | void constraints() { |
---|
| 177 | // No constraints for constructor. |
---|
| 178 | |
---|
| 179 | m.set(k, v); |
---|
| 180 | } |
---|
| 181 | |
---|
| 182 | WriteMap m; |
---|
| 183 | KeyType k; |
---|
| 184 | ValueType v; |
---|
| 185 | }; |
---|
| 186 | |
---|
| 187 | template<typename ReadWriteMap> |
---|
| 188 | struct ReadWriteMapConcept { |
---|
| 189 | void constraints() { |
---|
| 190 | function_requires< ReadMapConcept<ReadWriteMap> >(); |
---|
| 191 | function_requires< WriteMapConcept<ReadWriteMap> >(); |
---|
| 192 | } |
---|
| 193 | }; |
---|
| 194 | |
---|
| 195 | template<typename ReferenceMap> |
---|
| 196 | struct ReferenceMapConcept { |
---|
| 197 | typedef typename ReferenceMap::KeyType KeyType; |
---|
| 198 | typedef typename ReferenceMap::ValueType ValueType; |
---|
| 199 | typedef typename ReferenceMap::ReferenceType ReferenceType; |
---|
| 200 | |
---|
| 201 | // What for is this? |
---|
| 202 | typedef typename ReferenceMap::ConstReferenceType ConstReferenceType; |
---|
| 203 | |
---|
| 204 | void constraints() { |
---|
| 205 | function_requires< ReadWriteMapConcept<ReferenceMap> >(); |
---|
| 206 | |
---|
| 207 | m[k] = v; |
---|
| 208 | // Or should we require real reference? |
---|
| 209 | // Like this: |
---|
| 210 | // ValueType &vv = m[k]; |
---|
| 211 | // ignore_unused_variable_warning(vv); |
---|
| 212 | } |
---|
| 213 | |
---|
| 214 | ReferenceMap m; |
---|
| 215 | KeyType k; |
---|
| 216 | ValueType v; |
---|
| 217 | }; |
---|
| 218 | |
---|
| 219 | /// \todo GraphMapConceptCheck |
---|
| 220 | |
---|
| 221 | template<typename GraphMap, typename Graph> |
---|
| 222 | struct GraphMapConcept { |
---|
| 223 | void constraints() { |
---|
| 224 | function_requires< ReadWriteMapConcept<GraphMap> >(); |
---|
| 225 | // Construction with a graph parameter |
---|
| 226 | GraphMap a(g); |
---|
| 227 | // Ctor with a graph and a default value parameter |
---|
| 228 | GraphMap a2(g,t); |
---|
| 229 | // Copy ctor. Do we need it? |
---|
| 230 | GraphMap b=c; |
---|
| 231 | // Copy operator. Do we need it? |
---|
| 232 | a=b; |
---|
| 233 | |
---|
| 234 | ignore_unused_variable_warning(a2); |
---|
| 235 | } |
---|
| 236 | const GraphMap &c; |
---|
| 237 | const Graph &g; |
---|
| 238 | const typename GraphMap::ValueType &t; |
---|
| 239 | }; |
---|
| 240 | |
---|
| 241 | |
---|
[794] | 242 | // @} |
---|
| 243 | |
---|
[732] | 244 | } //namespace skeleton |
---|
[921] | 245 | } //namespace lemon |
---|
| 246 | #endif // LEMON_MAPSKELETON_H |
---|