1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
2  *
3  * This file is a part of LEMON, a generic C++ optimization library.
4  *
5  * Copyright (C) 2003-2013
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_BITS_TRAITS_H
20 #define LEMON_BITS_TRAITS_H
21 
22 //\file
23 //\brief Traits for graphs and maps
24 //
25 
26 #include <lemon/bits/enable_if.h>
27 
28 namespace lemon {
29 
30   struct InvalidType {};
31 
32   template <typename GR, typename _Item>
33   class ItemSetTraits {};
34 
35 
36   template <typename GR, typename Enable = void>
37   struct NodeNotifierIndicator {
38     typedef InvalidType Type;
39   };
40   template <typename GR>
41   struct NodeNotifierIndicator<
42     GR,
43     typename enable_if<typename GR::NodeNotifier::Notifier, void>::type
44   > {
45     typedef typename GR::NodeNotifier Type;
46   };
47 
48   template <typename GR>
49   class ItemSetTraits<GR, typename GR::Node> {
50   public:
51 
52     typedef GR Graph;
53     typedef GR Digraph;
54 
55     typedef typename GR::Node Item;
56     typedef typename GR::NodeIt ItemIt;
57 
58     typedef typename NodeNotifierIndicator<GR>::Type ItemNotifier;
59 
60     template <typename V>
61     class Map : public GR::template NodeMap<V> {
62       typedef typename GR::template NodeMap<V> Parent;
63 
64     public:
65       typedef typename GR::template NodeMap<V> Type;
66       typedef typename Parent::Value Value;
67 
68       Map(const GR& _digraph) : Parent(_digraph) {}
69       Map(const GR& _digraph, const Value& _value)
70         : Parent(_digraph, _value) {}
71 
72      };
73 
74   };
75 
76   template <typename GR, typename Enable = void>
77   struct ArcNotifierIndicator {
78     typedef InvalidType Type;
79   };
80   template <typename GR>
81   struct ArcNotifierIndicator<
82     GR,
83     typename enable_if<typename GR::ArcNotifier::Notifier, void>::type
84   > {
85     typedef typename GR::ArcNotifier Type;
86   };
87 
88   template <typename GR>
89   class ItemSetTraits<GR, typename GR::Arc> {
90   public:
91 
92     typedef GR Graph;
93     typedef GR Digraph;
94 
95     typedef typename GR::Arc Item;
96     typedef typename GR::ArcIt ItemIt;
97 
98     typedef typename ArcNotifierIndicator<GR>::Type ItemNotifier;
99 
100     template <typename V>
101     class Map : public GR::template ArcMap<V> {
102       typedef typename GR::template ArcMap<V> Parent;
103 
104     public:
105       typedef typename GR::template ArcMap<V> Type;
106       typedef typename Parent::Value Value;
107 
108       Map(const GR& _digraph) : Parent(_digraph) {}
109       Map(const GR& _digraph, const Value& _value)
110         : Parent(_digraph, _value) {}
111     };
112 
113   };
114 
115   template <typename GR, typename Enable = void>
116   struct EdgeNotifierIndicator {
117     typedef InvalidType Type;
118   };
119   template <typename GR>
120   struct EdgeNotifierIndicator<
121     GR,
122     typename enable_if<typename GR::EdgeNotifier::Notifier, void>::type
123   > {
124     typedef typename GR::EdgeNotifier Type;
125   };
126 
127   template <typename GR>
128   class ItemSetTraits<GR, typename GR::Edge> {
129   public:
130 
131     typedef GR Graph;
132     typedef GR Digraph;
133 
134     typedef typename GR::Edge Item;
135     typedef typename GR::EdgeIt ItemIt;
136 
137     typedef typename EdgeNotifierIndicator<GR>::Type ItemNotifier;
138 
139     template <typename V>
140     class Map : public GR::template EdgeMap<V> {
141       typedef typename GR::template EdgeMap<V> Parent;
142 
143     public:
144       typedef typename GR::template EdgeMap<V> Type;
145       typedef typename Parent::Value Value;
146 
147       Map(const GR& _digraph) : Parent(_digraph) {}
148       Map(const GR& _digraph, const Value& _value)
149         : Parent(_digraph, _value) {}
150     };
151 
152   };
153 
154   template <typename GR, typename Enable = void>
155   struct RedNodeNotifierIndicator {
156     typedef InvalidType Type;
157   };
158   template <typename GR>
159   struct RedNodeNotifierIndicator<
160     GR,
161     typename enable_if<typename GR::RedNodeNotifier::Notifier, void>::type
162   > {
163     typedef typename GR::RedNodeNotifier Type;
164   };
165 
166   template <typename GR>
167   class ItemSetTraits<GR, typename GR::RedNode> {
168   public:
169 
170     typedef GR BpGraph;
171     typedef GR Graph;
172     typedef GR Digraph;
173 
174     typedef typename GR::RedNode Item;
175     typedef typename GR::RedNodeIt ItemIt;
176 
177     typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
178 
179     template <typename V>
180     class Map : public GR::template RedNodeMap<V> {
181       typedef typename GR::template RedNodeMap<V> Parent;
182 
183     public:
184       typedef typename GR::template RedNodeMap<V> Type;
185       typedef typename Parent::Value Value;
186 
187       Map(const GR& _bpgraph) : Parent(_bpgraph) {}
188       Map(const GR& _bpgraph, const Value& _value)
189         : Parent(_bpgraph, _value) {}
190 
191      };
192 
193   };
194 
195   template <typename GR, typename Enable = void>
196   struct BlueNodeNotifierIndicator {
197     typedef InvalidType Type;
198   };
199   template <typename GR>
200   struct BlueNodeNotifierIndicator<
201     GR,
202     typename enable_if<typename GR::BlueNodeNotifier::Notifier, void>::type
203   > {
204     typedef typename GR::BlueNodeNotifier Type;
205   };
206 
207   template <typename GR>
208   class ItemSetTraits<GR, typename GR::BlueNode> {
209   public:
210 
211     typedef GR BpGraph;
212     typedef GR Graph;
213     typedef GR Digraph;
214 
215     typedef typename GR::BlueNode Item;
216     typedef typename GR::BlueNodeIt ItemIt;
217 
218     typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
219 
220     template <typename V>
221     class Map : public GR::template BlueNodeMap<V> {
222       typedef typename GR::template BlueNodeMap<V> Parent;
223 
224     public:
225       typedef typename GR::template BlueNodeMap<V> Type;
226       typedef typename Parent::Value Value;
227 
228       Map(const GR& _bpgraph) : Parent(_bpgraph) {}
229       Map(const GR& _bpgraph, const Value& _value)
230         : Parent(_bpgraph, _value) {}
231 
232      };
233 
234   };
235 
236   template <typename Map, typename Enable = void>
237   struct MapTraits {
238     typedef False ReferenceMapTag;
239 
240     typedef typename Map::Key Key;
241     typedef typename Map::Value Value;
242 
243     typedef Value ConstReturnValue;
244     typedef Value ReturnValue;
245   };
246 
247   template <typename Map>
248   struct MapTraits<
249     Map, typename enable_if<typename Map::ReferenceMapTag, void>::type >
250   {
251     typedef True ReferenceMapTag;
252 
253     typedef typename Map::Key Key;
254     typedef typename Map::Value Value;
255 
256     typedef typename Map::ConstReference ConstReturnValue;
257     typedef typename Map::Reference ReturnValue;
258 
259     typedef typename Map::ConstReference ConstReference;
260     typedef typename Map::Reference Reference;
261  };
262 
263   template <typename MatrixMap, typename Enable = void>
264   struct MatrixMapTraits {
265     typedef False ReferenceMapTag;
266 
267     typedef typename MatrixMap::FirstKey FirstKey;
268     typedef typename MatrixMap::SecondKey SecondKey;
269     typedef typename MatrixMap::Value Value;
270 
271     typedef Value ConstReturnValue;
272     typedef Value ReturnValue;
273   };
274 
275   template <typename MatrixMap>
276   struct MatrixMapTraits<
277     MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,
278                                   void>::type >
279   {
280     typedef True ReferenceMapTag;
281 
282     typedef typename MatrixMap::FirstKey FirstKey;
283     typedef typename MatrixMap::SecondKey SecondKey;
284     typedef typename MatrixMap::Value Value;
285 
286     typedef typename MatrixMap::ConstReference ConstReturnValue;
287     typedef typename MatrixMap::Reference ReturnValue;
288 
289     typedef typename MatrixMap::ConstReference ConstReference;
290     typedef typename MatrixMap::Reference Reference;
291  };
292 
293   // Indicators for the tags
294 
295   template <typename GR, typename Enable = void>
296   struct NodeNumTagIndicator {
297     static const bool value = false;
298   };
299 
300   template <typename GR>
301   struct NodeNumTagIndicator<
302     GR,
303     typename enable_if<typename GR::NodeNumTag, void>::type
304   > {
305     static const bool value = true;
306   };
307 
308   template <typename GR, typename Enable = void>
309   struct ArcNumTagIndicator {
310     static const bool value = false;
311   };
312 
313   template <typename GR>
314   struct ArcNumTagIndicator<
315     GR,
316     typename enable_if<typename GR::ArcNumTag, void>::type
317   > {
318     static const bool value = true;
319   };
320 
321   template <typename GR, typename Enable = void>
322   struct EdgeNumTagIndicator {
323     static const bool value = false;
324   };
325 
326   template <typename GR>
327   struct EdgeNumTagIndicator<
328     GR,
329     typename enable_if<typename GR::EdgeNumTag, void>::type
330   > {
331     static const bool value = true;
332   };
333 
334   template <typename GR, typename Enable = void>
335   struct FindArcTagIndicator {
336     static const bool value = false;
337   };
338 
339   template <typename GR>
340   struct FindArcTagIndicator<
341     GR,
342     typename enable_if<typename GR::FindArcTag, void>::type
343   > {
344     static const bool value = true;
345   };
346 
347   template <typename GR, typename Enable = void>
348   struct FindEdgeTagIndicator {
349     static const bool value = false;
350   };
351 
352   template <typename GR>
353   struct FindEdgeTagIndicator<
354     GR,
355     typename enable_if<typename GR::FindEdgeTag, void>::type
356   > {
357     static const bool value = true;
358   };
359 
360   template <typename GR, typename Enable = void>
361   struct UndirectedTagIndicator {
362     static const bool value = false;
363   };
364 
365   template <typename GR>
366   struct UndirectedTagIndicator<
367     GR,
368     typename enable_if<typename GR::UndirectedTag, void>::type
369   > {
370     static const bool value = true;
371   };
372 
373   template <typename GR, typename Enable = void>
374   struct BuildTagIndicator {
375     static const bool value = false;
376   };
377 
378   template <typename GR>
379   struct BuildTagIndicator<
380     GR,
381     typename enable_if<typename GR::BuildTag, void>::type
382   > {
383     static const bool value = true;
384   };
385 
386 }
387 
388 #endif
389