COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/lemon/skeletons/maps.h @ 948:bc86b64f958e

Last change on this file since 948:bc86b64f958e was 946:c94ef40a22ce, checked in by Mihaly Barasz, 16 years ago

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

File size: 6.4 KB
Line 
1/* -*- C++ -*-
2 * src/lemon/skeletons/maps.h - Part of LEMON, a generic C++ optimization library
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
17#ifndef LEMON_MAPSKELETON_H
18#define LEMON_MAPSKELETON_H
19
20#include <lemon/concept_check.h>
21
22///\ingroup skeletons
23///\file
24///\brief Map concepts checking classes for testing and documenting.
25
26namespace lemon {
27
28  namespace skeleton {
29 
30    /// \addtogroup skeletons
31    /// @{
32
33    /// Readable map concept
34    template<typename K, typename T>
35    class ReadMap
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;
42
43      /// Returns the value associated with a key.
44      ValueType operator[](const KeyType &k) const {return ValueType();}
45
46      ///Default constructor
47      ReadMap() {}
48    };
49
50
51    /// Writable map concept
52    template<typename K, typename T>
53    class WriteMap
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
64      ///Default constructor
65      WriteMap() {}
66    };
67
68    ///Read/Writable map concept
69    template<typename K, typename T>
70    class ReadWriteMap : public ReadMap<K,T>,
71                            public WriteMap<K,T>
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
84      ///Default constructor
85      ReadWriteMap() {}
86    };
87 
88 
89    ///Dereferable map concept
90    template<typename K, typename T>
91    class ReferenceMap : public ReadWriteMap<K,T>
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;
98
99    protected:
100      ValueType tmp;
101    public:
102      typedef ValueType& ReferenceType;
103      /// Map's const reference type.
104      typedef const ValueType& ConstReferenceType;
105
106      ///Returns a reference to the value associated to a key.
107      ReferenceType operator[](const KeyType &i) { return tmp; }
108      ///Returns a const reference to the value associated to a key.
109      ConstReferenceType operator[](const KeyType &i) const
110      { return tmp; }
111      /// Sets the value associated with a key.
112      void set(const KeyType &k,const ValueType &t) { operator[](k)=t; }
113
114      ///Default constructor
115      ReferenceMap() {}
116    };
117
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
242    // @}
243
244  } //namespace skeleton
245} //namespace lemon
246#endif // LEMON_MAPSKELETON_H
Note: See TracBrowser for help on using the repository browser.