Mercuriallemon-1.2 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
lemon/bits/traits.h
changeset 209 765619b7cbb2
parent 184 716b220697a0
child 220 a5d8c039f218
equal deleted inserted replaced
3:4a232d98f8b2 4:2bd1c8a3158a 
     1 
     1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
 
     2 /* -*- C++ -*-
 
     2  *
 
     3  *
 
     3  * This file is a part of LEMON, a generic C++ optimization library.
 
     4  * This file is a part of LEMON, a generic C++ optimization library
 
       
     5  *
 
     4  *
 
     6  * Copyright (C) 2003-2008
 
     5  * Copyright (C) 2003-2008
 
     7  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 
     8  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 
     9  *
 
     8  *
 
    27 ///
 
    26 ///
 
    28 
    27 
    29 namespace lemon {
 
    28 namespace lemon {
 
    30   template <typename _Graph, typename _Item>
 
    29   template <typename _Graph, typename _Item>
 
    31   class ItemSetTraits {};
 
    30   class ItemSetTraits {};
 
    32   
    31 
    33 
    32 
    34   template <typename Graph, typename Enable = void>
 
    33   template <typename Graph, typename Enable = void>
 
    35   struct NodeNotifierIndicator {
 
    34   struct NodeNotifierIndicator {
 
    36     typedef InvalidType Type;
 
    35     typedef InvalidType Type;
 
    37   };
 
    36   };
 
    38   template <typename Graph>
 
    37   template <typename Graph>
 
    39   struct NodeNotifierIndicator<
 
    38   struct NodeNotifierIndicator<
 
    40     Graph, 
    39     Graph,
 
    41     typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
 
    40     typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
 
    42   > { 
    41   > {
 
    43     typedef typename Graph::NodeNotifier Type;
 
    42     typedef typename Graph::NodeNotifier Type;
 
    44   };
 
    43   };
 
    45 
    44 
    46   template <typename _Graph>
 
    45   template <typename _Graph>
 
    47   class ItemSetTraits<_Graph, typename _Graph::Node> {
 
    46   class ItemSetTraits<_Graph, typename _Graph::Node> {
 
    48   public:
 
    47   public:
 
    49     
    48 
    50     typedef _Graph Graph;
 
    49     typedef _Graph Graph;
 
    51 
    50 
    52     typedef typename Graph::Node Item;
 
    51     typedef typename Graph::Node Item;
 
    53     typedef typename Graph::NodeIt ItemIt;
 
    52     typedef typename Graph::NodeIt ItemIt;
 
    54 
    53 
    55     typedef typename NodeNotifierIndicator<Graph>::Type ItemNotifier;
 
    54     typedef typename NodeNotifierIndicator<Graph>::Type ItemNotifier;
 
    56 
    55 
    57     template <typename _Value>
 
    56     template <typename _Value>
 
    58     class Map : public Graph::template NodeMap<_Value> {
 
    57     class Map : public Graph::template NodeMap<_Value> {
 
    59     public:
 
    58     public:
 
    60       typedef typename Graph::template NodeMap<_Value> Parent; 
    59       typedef typename Graph::template NodeMap<_Value> Parent;
 
    61       typedef typename Graph::template NodeMap<_Value> Type; 
    60       typedef typename Graph::template NodeMap<_Value> Type;
 
    62       typedef typename Parent::Value Value;
 
    61       typedef typename Parent::Value Value;
 
    63 
    62 
    64       Map(const Graph& _digraph) : Parent(_digraph) {}
 
    63       Map(const Graph& _digraph) : Parent(_digraph) {}
 
    65       Map(const Graph& _digraph, const Value& _value) 
    64       Map(const Graph& _digraph, const Value& _value)
 
    66 	: Parent(_digraph, _value) {}
 
    65         : Parent(_digraph, _value) {}
 
    67 
    66 
    68      };
 
    67      };
 
    69 
    68 
    70   };
 
    69   };
 
    71 
    70 
    73   struct ArcNotifierIndicator {
 
    72   struct ArcNotifierIndicator {
 
    74     typedef InvalidType Type;
 
    73     typedef InvalidType Type;
 
    75   };
 
    74   };
 
    76   template <typename Graph>
 
    75   template <typename Graph>
 
    77   struct ArcNotifierIndicator<
 
    76   struct ArcNotifierIndicator<
 
    78     Graph, 
    77     Graph,
 
    79     typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
 
    78     typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
 
    80   > { 
    79   > {
 
    81     typedef typename Graph::ArcNotifier Type;
 
    80     typedef typename Graph::ArcNotifier Type;
 
    82   };
 
    81   };
 
    83 
    82 
    84   template <typename _Graph>
 
    83   template <typename _Graph>
 
    85   class ItemSetTraits<_Graph, typename _Graph::Arc> {
 
    84   class ItemSetTraits<_Graph, typename _Graph::Arc> {
 
    86   public:
 
    85   public:
 
    87     
    86 
    88     typedef _Graph Graph;
 
    87     typedef _Graph Graph;
 
    89 
    88 
    90     typedef typename Graph::Arc Item;
 
    89     typedef typename Graph::Arc Item;
 
    91     typedef typename Graph::ArcIt ItemIt;
 
    90     typedef typename Graph::ArcIt ItemIt;
 
    92 
    91 
    93     typedef typename ArcNotifierIndicator<Graph>::Type ItemNotifier;
 
    92     typedef typename ArcNotifierIndicator<Graph>::Type ItemNotifier;
 
    94 
    93 
    95     template <typename _Value>
 
    94     template <typename _Value>
 
    96     class Map : public Graph::template ArcMap<_Value> {
 
    95     class Map : public Graph::template ArcMap<_Value> {
 
    97     public:
 
    96     public:
 
    98       typedef typename Graph::template ArcMap<_Value> Parent; 
    97       typedef typename Graph::template ArcMap<_Value> Parent;
 
    99       typedef typename Graph::template ArcMap<_Value> Type; 
    98       typedef typename Graph::template ArcMap<_Value> Type;
 
   100       typedef typename Parent::Value Value;
 
    99       typedef typename Parent::Value Value;
 
   101 
   100 
   102       Map(const Graph& _digraph) : Parent(_digraph) {}
 
   101       Map(const Graph& _digraph) : Parent(_digraph) {}
 
   103       Map(const Graph& _digraph, const Value& _value) 
   102       Map(const Graph& _digraph, const Value& _value)
 
   104 	: Parent(_digraph, _value) {}
 
   103         : Parent(_digraph, _value) {}
 
   105     };
 
   104     };
 
   106 
   105 
   107   };
 
   106   };
 
   108 
   107 
   109   template <typename Graph, typename Enable = void>
 
   108   template <typename Graph, typename Enable = void>
 
   110   struct EdgeNotifierIndicator {
 
   109   struct EdgeNotifierIndicator {
 
   111     typedef InvalidType Type;
 
   110     typedef InvalidType Type;
 
   112   };
 
   111   };
 
   113   template <typename Graph>
 
   112   template <typename Graph>
 
   114   struct EdgeNotifierIndicator<
 
   113   struct EdgeNotifierIndicator<
 
   115     Graph, 
   114     Graph,
 
   116     typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
 
   115     typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
 
   117   > { 
   116   > {
 
   118     typedef typename Graph::EdgeNotifier Type;
 
   117     typedef typename Graph::EdgeNotifier Type;
 
   119   };
 
   118   };
 
   120 
   119 
   121   template <typename _Graph>
 
   120   template <typename _Graph>
 
   122   class ItemSetTraits<_Graph, typename _Graph::Edge> {
 
   121   class ItemSetTraits<_Graph, typename _Graph::Edge> {
 
   123   public:
 
   122   public:
 
   124     
   123 
   125     typedef _Graph Graph;
 
   124     typedef _Graph Graph;
 
   126 
   125 
   127     typedef typename Graph::Edge Item;
 
   126     typedef typename Graph::Edge Item;
 
   128     typedef typename Graph::EdgeIt ItemIt;
 
   127     typedef typename Graph::EdgeIt ItemIt;
 
   129 
   128 
   130     typedef typename EdgeNotifierIndicator<Graph>::Type ItemNotifier;
 
   129     typedef typename EdgeNotifierIndicator<Graph>::Type ItemNotifier;
 
   131 
   130 
   132     template <typename _Value>
 
   131     template <typename _Value>
 
   133     class Map : public Graph::template EdgeMap<_Value> {
 
   132     class Map : public Graph::template EdgeMap<_Value> {
 
   134     public:
 
   133     public:
 
   135       typedef typename Graph::template EdgeMap<_Value> Parent; 
   134       typedef typename Graph::template EdgeMap<_Value> Parent;
 
   136       typedef typename Graph::template EdgeMap<_Value> Type; 
   135       typedef typename Graph::template EdgeMap<_Value> Type;
 
   137       typedef typename Parent::Value Value;
 
   136       typedef typename Parent::Value Value;
 
   138 
   137 
   139       Map(const Graph& _digraph) : Parent(_digraph) {}
 
   138       Map(const Graph& _digraph) : Parent(_digraph) {}
 
   140       Map(const Graph& _digraph, const Value& _value) 
   139       Map(const Graph& _digraph, const Value& _value)
 
   141 	: Parent(_digraph, _value) {}
 
   140         : Parent(_digraph, _value) {}
 
   142     };
 
   141     };
 
   143 
   142 
   144   };
 
   143   };
 
   145 
   144 
   146   template <typename Map, typename Enable = void>
 
   145   template <typename Map, typename Enable = void>
 
   154     typedef Value ReturnValue;
 
   153     typedef Value ReturnValue;
 
   155   };
 
   154   };
 
   156 
   155 
   157   template <typename Map>
 
   156   template <typename Map>
 
   158   struct MapTraits<
 
   157   struct MapTraits<
 
   159     Map, typename enable_if<typename Map::ReferenceMapTag, void>::type > 
   158     Map, typename enable_if<typename Map::ReferenceMapTag, void>::type >
 
   160   {
 
   159   {
 
   161     typedef True ReferenceMapTag;
 
   160     typedef True ReferenceMapTag;
 
   162     
   161 
   163     typedef typename Map::Key Key;
 
   162     typedef typename Map::Key Key;
 
   164     typedef typename Map::Value Value;
 
   163     typedef typename Map::Value Value;
 
   165 
   164 
   166     typedef typename Map::ConstReference ConstReturnValue;
 
   165     typedef typename Map::ConstReference ConstReturnValue;
 
   167     typedef typename Map::Reference ReturnValue;
 
   166     typedef typename Map::Reference ReturnValue;
 
   168 
   167 
   169     typedef typename Map::ConstReference ConstReference; 
   168     typedef typename Map::ConstReference ConstReference;
 
   170     typedef typename Map::Reference Reference;
 
   169     typedef typename Map::Reference Reference;
 
   171  };
 
   170  };
 
   172 
   171 
   173   template <typename MatrixMap, typename Enable = void>
 
   172   template <typename MatrixMap, typename Enable = void>
 
   174   struct MatrixMapTraits {
 
   173   struct MatrixMapTraits {
 
   182     typedef Value ReturnValue;
 
   181     typedef Value ReturnValue;
 
   183   };
 
   182   };
 
   184 
   183 
   185   template <typename MatrixMap>
 
   184   template <typename MatrixMap>
 
   186   struct MatrixMapTraits<
 
   185   struct MatrixMapTraits<
 
   187     MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag, 
   186     MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,
 
   188                                   void>::type > 
   187                                   void>::type >
 
   189   {
 
   188   {
 
   190     typedef True ReferenceMapTag;
 
   189     typedef True ReferenceMapTag;
 
   191     
   190 
   192     typedef typename MatrixMap::FirstKey FirstKey;
 
   191     typedef typename MatrixMap::FirstKey FirstKey;
 
   193     typedef typename MatrixMap::SecondKey SecondKey;
 
   192     typedef typename MatrixMap::SecondKey SecondKey;
 
   194     typedef typename MatrixMap::Value Value;
 
   193     typedef typename MatrixMap::Value Value;
 
   195 
   194 
   196     typedef typename MatrixMap::ConstReference ConstReturnValue;
 
   195     typedef typename MatrixMap::ConstReference ConstReturnValue;
 
   197     typedef typename MatrixMap::Reference ReturnValue;
 
   196     typedef typename MatrixMap::Reference ReturnValue;
 
   198 
   197 
   199     typedef typename MatrixMap::ConstReference ConstReference; 
   198     typedef typename MatrixMap::ConstReference ConstReference;
 
   200     typedef typename MatrixMap::Reference Reference;
 
   199     typedef typename MatrixMap::Reference Reference;
 
   201  };
 
   200  };
 
   202 
   201 
   203   // Indicators for the tags
 
   202   // Indicators for the tags
 
   204 
   203 
   207     static const bool value = false;
 
   206     static const bool value = false;
 
   208   };
 
   207   };
 
   209 
   208 
   210   template <typename Graph>
 
   209   template <typename Graph>
 
   211   struct NodeNumTagIndicator<
 
   210   struct NodeNumTagIndicator<
 
   212     Graph, 
   211     Graph,
 
   213     typename enable_if<typename Graph::NodeNumTag, void>::type
 
   212     typename enable_if<typename Graph::NodeNumTag, void>::type
 
   214   > {
 
   213   > {
 
   215     static const bool value = true;
 
   214     static const bool value = true;
 
   216   };
 
   215   };
 
   217 
   216 
   220     static const bool value = false;
 
   219     static const bool value = false;
 
   221   };
 
   220   };
 
   222 
   221 
   223   template <typename Graph>
 
   222   template <typename Graph>
 
   224   struct EdgeNumTagIndicator<
 
   223   struct EdgeNumTagIndicator<
 
   225     Graph, 
   224     Graph,
 
   226     typename enable_if<typename Graph::EdgeNumTag, void>::type
 
   225     typename enable_if<typename Graph::EdgeNumTag, void>::type
 
   227   > {
 
   226   > {
 
   228     static const bool value = true;
 
   227     static const bool value = true;
 
   229   };
 
   228   };
 
   230 
   229 
   233     static const bool value = false;
 
   232     static const bool value = false;
 
   234   };
 
   233   };
 
   235 
   234 
   236   template <typename Graph>
 
   235   template <typename Graph>
 
   237   struct FindEdgeTagIndicator<
 
   236   struct FindEdgeTagIndicator<
 
   238     Graph, 
   237     Graph,
 
   239     typename enable_if<typename Graph::FindEdgeTag, void>::type
 
   238     typename enable_if<typename Graph::FindEdgeTag, void>::type
 
   240   > {
 
   239   > {
 
   241     static const bool value = true;
 
   240     static const bool value = true;
 
   242   };
 
   241   };
 
   243 
   242 
   246     static const bool value = false;
 
   245     static const bool value = false;
 
   247   };
 
   246   };
 
   248 
   247 
   249   template <typename Graph>
 
   248   template <typename Graph>
 
   250   struct UndirectedTagIndicator<
 
   249   struct UndirectedTagIndicator<
 
   251     Graph, 
   250     Graph,
 
   252     typename enable_if<typename Graph::UndirectedTag, void>::type
 
   251     typename enable_if<typename Graph::UndirectedTag, void>::type
 
   253   > {
 
   252   > {
 
   254     static const bool value = true;
 
   253     static const bool value = true;
 
   255   };
 
   254   };
 
   256 
   255 
   259     static const bool value = false;
 
   258     static const bool value = false;
 
   260   };
 
   259   };
 
   261 
   260 
   262   template <typename Graph>
 
   261   template <typename Graph>
 
   263   struct BuildTagIndicator<
 
   262   struct BuildTagIndicator<
 
   264     Graph, 
   263     Graph,
 
   265     typename enable_if<typename Graph::BuildTag, void>::type
 
   264     typename enable_if<typename Graph::BuildTag, void>::type
 
   266   > {
 
   265   > {
 
   267     static const bool value = true;
 
   266     static const bool value = true;
 
   268   };
 
   267   };
 
   269 
   268
lemon-1.2