COIN-OR::LEMON - Graph Library

source: lemon/lemon/bits/traits.h @ 1194:699c7eac2c6d

Last change on this file since 1194:699c7eac2c6d was 1194:699c7eac2c6d, checked in by Balazs Dezso <deba@…>, 8 years ago

Renamings in BpGraphs? (#69)

File size: 9.4 KB
Line 
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-2009
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
28namespace 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
Note: See TracBrowser for help on using the repository browser.