Mercuriallemon-main / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
lemon/bits/traits.h
author Alpar Juttner <alpar@cs.elte.hu>
Mon, 05 Aug 2013 14:03:29 +0200
changeset 1074 97d978243703
parent 1019 4c89e925cfe2
child 1092 dceba191c00d
permissions -rw-r--r--
Fix unresolved doc references (#459) 
     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 

    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
lemon-main