[416] | 1 | /* -*- mode: C++; indent-tabs-mode: nil; -*- |
---|
[414] | 2 | * |
---|
[416] | 3 | * This file is a part of LEMON, a generic C++ optimization library. |
---|
[414] | 4 | * |
---|
[440] | 5 | * Copyright (C) 2003-2009 |
---|
[414] | 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_VARIANT_H |
---|
| 20 | #define LEMON_BITS_VARIANT_H |
---|
| 21 | |
---|
| 22 | #include <lemon/assert.h> |
---|
| 23 | |
---|
[431] | 24 | // \file |
---|
| 25 | // \brief Variant types |
---|
[414] | 26 | |
---|
| 27 | namespace lemon { |
---|
| 28 | |
---|
| 29 | namespace _variant_bits { |
---|
[416] | 30 | |
---|
[414] | 31 | template <int left, int right> |
---|
| 32 | struct CTMax { |
---|
| 33 | static const int value = left < right ? right : left; |
---|
| 34 | }; |
---|
| 35 | |
---|
| 36 | } |
---|
| 37 | |
---|
| 38 | |
---|
[431] | 39 | // \brief Simple Variant type for two types |
---|
| 40 | // |
---|
| 41 | // Simple Variant type for two types. The Variant type is a type-safe |
---|
| 42 | // union. C++ has strong limitations for using unions, for |
---|
| 43 | // example you cannot store a type with non-default constructor or |
---|
| 44 | // destructor in a union. This class always knowns the current |
---|
| 45 | // state of the variant and it cares for the proper construction |
---|
| 46 | // and destruction. |
---|
[414] | 47 | template <typename _First, typename _Second> |
---|
| 48 | class BiVariant { |
---|
| 49 | public: |
---|
| 50 | |
---|
[431] | 51 | // \brief The \c First type. |
---|
[414] | 52 | typedef _First First; |
---|
[431] | 53 | // \brief The \c Second type. |
---|
[414] | 54 | typedef _Second Second; |
---|
| 55 | |
---|
[431] | 56 | // \brief Constructor |
---|
| 57 | // |
---|
| 58 | // This constructor initalizes to the default value of the \c First |
---|
| 59 | // type. |
---|
[414] | 60 | BiVariant() { |
---|
| 61 | flag = true; |
---|
| 62 | new(reinterpret_cast<First*>(data)) First(); |
---|
| 63 | } |
---|
| 64 | |
---|
[431] | 65 | // \brief Constructor |
---|
| 66 | // |
---|
| 67 | // This constructor initalizes to the given value of the \c First |
---|
| 68 | // type. |
---|
[414] | 69 | BiVariant(const First& f) { |
---|
| 70 | flag = true; |
---|
| 71 | new(reinterpret_cast<First*>(data)) First(f); |
---|
| 72 | } |
---|
| 73 | |
---|
[431] | 74 | // \brief Constructor |
---|
| 75 | // |
---|
| 76 | // This constructor initalizes to the given value of the \c |
---|
| 77 | // Second type. |
---|
[414] | 78 | BiVariant(const Second& s) { |
---|
| 79 | flag = false; |
---|
| 80 | new(reinterpret_cast<Second*>(data)) Second(s); |
---|
| 81 | } |
---|
| 82 | |
---|
[431] | 83 | // \brief Copy constructor |
---|
| 84 | // |
---|
| 85 | // Copy constructor |
---|
[414] | 86 | BiVariant(const BiVariant& bivariant) { |
---|
| 87 | flag = bivariant.flag; |
---|
| 88 | if (flag) { |
---|
[416] | 89 | new(reinterpret_cast<First*>(data)) First(bivariant.first()); |
---|
[414] | 90 | } else { |
---|
[416] | 91 | new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); |
---|
[414] | 92 | } |
---|
| 93 | } |
---|
| 94 | |
---|
[431] | 95 | // \brief Destrcutor |
---|
| 96 | // |
---|
| 97 | // Destructor |
---|
[414] | 98 | ~BiVariant() { |
---|
| 99 | destroy(); |
---|
| 100 | } |
---|
| 101 | |
---|
[431] | 102 | // \brief Set to the default value of the \c First type. |
---|
| 103 | // |
---|
| 104 | // This function sets the variant to the default value of the \c |
---|
| 105 | // First type. |
---|
[414] | 106 | BiVariant& setFirst() { |
---|
| 107 | destroy(); |
---|
| 108 | flag = true; |
---|
[416] | 109 | new(reinterpret_cast<First*>(data)) First(); |
---|
[414] | 110 | return *this; |
---|
| 111 | } |
---|
| 112 | |
---|
[431] | 113 | // \brief Set to the given value of the \c First type. |
---|
| 114 | // |
---|
| 115 | // This function sets the variant to the given value of the \c |
---|
| 116 | // First type. |
---|
[414] | 117 | BiVariant& setFirst(const First& f) { |
---|
| 118 | destroy(); |
---|
| 119 | flag = true; |
---|
[416] | 120 | new(reinterpret_cast<First*>(data)) First(f); |
---|
[414] | 121 | return *this; |
---|
| 122 | } |
---|
| 123 | |
---|
[431] | 124 | // \brief Set to the default value of the \c Second type. |
---|
| 125 | // |
---|
| 126 | // This function sets the variant to the default value of the \c |
---|
| 127 | // Second type. |
---|
[414] | 128 | BiVariant& setSecond() { |
---|
| 129 | destroy(); |
---|
| 130 | flag = false; |
---|
[416] | 131 | new(reinterpret_cast<Second*>(data)) Second(); |
---|
[414] | 132 | return *this; |
---|
| 133 | } |
---|
| 134 | |
---|
[431] | 135 | // \brief Set to the given value of the \c Second type. |
---|
| 136 | // |
---|
| 137 | // This function sets the variant to the given value of the \c |
---|
| 138 | // Second type. |
---|
[414] | 139 | BiVariant& setSecond(const Second& s) { |
---|
| 140 | destroy(); |
---|
| 141 | flag = false; |
---|
[416] | 142 | new(reinterpret_cast<Second*>(data)) Second(s); |
---|
[414] | 143 | return *this; |
---|
| 144 | } |
---|
| 145 | |
---|
[431] | 146 | // \brief Operator form of the \c setFirst() |
---|
[414] | 147 | BiVariant& operator=(const First& f) { |
---|
| 148 | return setFirst(f); |
---|
| 149 | } |
---|
| 150 | |
---|
[431] | 151 | // \brief Operator form of the \c setSecond() |
---|
[414] | 152 | BiVariant& operator=(const Second& s) { |
---|
| 153 | return setSecond(s); |
---|
| 154 | } |
---|
| 155 | |
---|
[431] | 156 | // \brief Assign operator |
---|
[414] | 157 | BiVariant& operator=(const BiVariant& bivariant) { |
---|
| 158 | if (this == &bivariant) return *this; |
---|
| 159 | destroy(); |
---|
| 160 | flag = bivariant.flag; |
---|
| 161 | if (flag) { |
---|
[416] | 162 | new(reinterpret_cast<First*>(data)) First(bivariant.first()); |
---|
[414] | 163 | } else { |
---|
[416] | 164 | new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); |
---|
[414] | 165 | } |
---|
| 166 | return *this; |
---|
| 167 | } |
---|
| 168 | |
---|
[431] | 169 | // \brief Reference to the value |
---|
| 170 | // |
---|
| 171 | // Reference to the value of the \c First type. |
---|
| 172 | // \pre The BiVariant should store value of \c First type. |
---|
[414] | 173 | First& first() { |
---|
| 174 | LEMON_DEBUG(flag, "Variant wrong state"); |
---|
[431] | 175 | return *reinterpret_cast<First*>(data); |
---|
[414] | 176 | } |
---|
| 177 | |
---|
[431] | 178 | // \brief Const reference to the value |
---|
| 179 | // |
---|
| 180 | // Const reference to the value of the \c First type. |
---|
| 181 | // \pre The BiVariant should store value of \c First type. |
---|
| 182 | const First& first() const { |
---|
[414] | 183 | LEMON_DEBUG(flag, "Variant wrong state"); |
---|
[431] | 184 | return *reinterpret_cast<const First*>(data); |
---|
[414] | 185 | } |
---|
| 186 | |
---|
[431] | 187 | // \brief Operator form of the \c first() |
---|
[414] | 188 | operator First&() { return first(); } |
---|
[431] | 189 | // \brief Operator form of the const \c first() |
---|
[414] | 190 | operator const First&() const { return first(); } |
---|
| 191 | |
---|
[431] | 192 | // \brief Reference to the value |
---|
| 193 | // |
---|
| 194 | // Reference to the value of the \c Second type. |
---|
| 195 | // \pre The BiVariant should store value of \c Second type. |
---|
| 196 | Second& second() { |
---|
[414] | 197 | LEMON_DEBUG(!flag, "Variant wrong state"); |
---|
[431] | 198 | return *reinterpret_cast<Second*>(data); |
---|
[414] | 199 | } |
---|
| 200 | |
---|
[431] | 201 | // \brief Const reference to the value |
---|
| 202 | // |
---|
| 203 | // Const reference to the value of the \c Second type. |
---|
| 204 | // \pre The BiVariant should store value of \c Second type. |
---|
| 205 | const Second& second() const { |
---|
[414] | 206 | LEMON_DEBUG(!flag, "Variant wrong state"); |
---|
[431] | 207 | return *reinterpret_cast<const Second*>(data); |
---|
[414] | 208 | } |
---|
| 209 | |
---|
[431] | 210 | // \brief Operator form of the \c second() |
---|
[414] | 211 | operator Second&() { return second(); } |
---|
[431] | 212 | // \brief Operator form of the const \c second() |
---|
[414] | 213 | operator const Second&() const { return second(); } |
---|
| 214 | |
---|
[431] | 215 | // \brief %True when the variant is in the first state |
---|
| 216 | // |
---|
| 217 | // %True when the variant stores value of the \c First type. |
---|
[414] | 218 | bool firstState() const { return flag; } |
---|
| 219 | |
---|
[431] | 220 | // \brief %True when the variant is in the second state |
---|
| 221 | // |
---|
| 222 | // %True when the variant stores value of the \c Second type. |
---|
[414] | 223 | bool secondState() const { return !flag; } |
---|
| 224 | |
---|
| 225 | private: |
---|
| 226 | |
---|
| 227 | void destroy() { |
---|
| 228 | if (flag) { |
---|
| 229 | reinterpret_cast<First*>(data)->~First(); |
---|
| 230 | } else { |
---|
| 231 | reinterpret_cast<Second*>(data)->~Second(); |
---|
| 232 | } |
---|
| 233 | } |
---|
[416] | 234 | |
---|
[414] | 235 | char data[_variant_bits::CTMax<sizeof(First), sizeof(Second)>::value]; |
---|
| 236 | bool flag; |
---|
| 237 | }; |
---|
| 238 | |
---|
| 239 | namespace _variant_bits { |
---|
[416] | 240 | |
---|
[414] | 241 | template <int _idx, typename _TypeMap> |
---|
| 242 | struct Memory { |
---|
| 243 | |
---|
| 244 | typedef typename _TypeMap::template Map<_idx>::Type Current; |
---|
| 245 | |
---|
| 246 | static void destroy(int index, char* place) { |
---|
| 247 | if (index == _idx) { |
---|
| 248 | reinterpret_cast<Current*>(place)->~Current(); |
---|
| 249 | } else { |
---|
| 250 | Memory<_idx - 1, _TypeMap>::destroy(index, place); |
---|
| 251 | } |
---|
| 252 | } |
---|
| 253 | |
---|
| 254 | static void copy(int index, char* to, const char* from) { |
---|
| 255 | if (index == _idx) { |
---|
| 256 | new (reinterpret_cast<Current*>(to)) |
---|
| 257 | Current(reinterpret_cast<const Current*>(from)); |
---|
| 258 | } else { |
---|
| 259 | Memory<_idx - 1, _TypeMap>::copy(index, to, from); |
---|
| 260 | } |
---|
| 261 | } |
---|
| 262 | |
---|
| 263 | }; |
---|
| 264 | |
---|
| 265 | template <typename _TypeMap> |
---|
| 266 | struct Memory<-1, _TypeMap> { |
---|
| 267 | |
---|
| 268 | static void destroy(int, char*) { |
---|
| 269 | LEMON_DEBUG(false, "Variant wrong index."); |
---|
| 270 | } |
---|
| 271 | |
---|
| 272 | static void copy(int, char*, const char*) { |
---|
| 273 | LEMON_DEBUG(false, "Variant wrong index."); |
---|
| 274 | } |
---|
| 275 | }; |
---|
| 276 | |
---|
| 277 | template <int _idx, typename _TypeMap> |
---|
| 278 | struct Size { |
---|
[416] | 279 | static const int value = |
---|
| 280 | CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type), |
---|
[414] | 281 | Size<_idx - 1, _TypeMap>::value>::value; |
---|
| 282 | }; |
---|
| 283 | |
---|
| 284 | template <typename _TypeMap> |
---|
| 285 | struct Size<0, _TypeMap> { |
---|
[416] | 286 | static const int value = |
---|
[414] | 287 | sizeof(typename _TypeMap::template Map<0>::Type); |
---|
| 288 | }; |
---|
| 289 | |
---|
| 290 | } |
---|
| 291 | |
---|
[431] | 292 | // \brief Variant type |
---|
| 293 | // |
---|
| 294 | // Simple Variant type. The Variant type is a type-safe union. |
---|
| 295 | // C++ has strong limitations for using unions, for example you |
---|
| 296 | // cannot store type with non-default constructor or destructor in |
---|
| 297 | // a union. This class always knowns the current state of the |
---|
| 298 | // variant and it cares for the proper construction and |
---|
| 299 | // destruction. |
---|
| 300 | // |
---|
| 301 | // \param _num The number of the types which can be stored in the |
---|
| 302 | // variant type. |
---|
| 303 | // \param _TypeMap This class describes the types of the Variant. The |
---|
| 304 | // _TypeMap::Map<index>::Type should be a valid type for each index |
---|
| 305 | // in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper |
---|
| 306 | // class to define such type mappings up to 10 types. |
---|
| 307 | // |
---|
| 308 | // And the usage of the class: |
---|
| 309 | //\code |
---|
| 310 | // typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant; |
---|
| 311 | // MyVariant var; |
---|
| 312 | // var.set<0>(12); |
---|
| 313 | // std::cout << var.get<0>() << std::endl; |
---|
| 314 | // var.set<1>("alpha"); |
---|
| 315 | // std::cout << var.get<1>() << std::endl; |
---|
| 316 | // var.set<2>(0.75); |
---|
| 317 | // std::cout << var.get<2>() << std::endl; |
---|
| 318 | //\endcode |
---|
| 319 | // |
---|
| 320 | // The result of course: |
---|
| 321 | //\code |
---|
| 322 | // 12 |
---|
| 323 | // alpha |
---|
| 324 | // 0.75 |
---|
| 325 | //\endcode |
---|
[414] | 326 | template <int _num, typename _TypeMap> |
---|
| 327 | class Variant { |
---|
| 328 | public: |
---|
| 329 | |
---|
| 330 | static const int num = _num; |
---|
| 331 | |
---|
| 332 | typedef _TypeMap TypeMap; |
---|
| 333 | |
---|
[431] | 334 | // \brief Constructor |
---|
| 335 | // |
---|
| 336 | // This constructor initalizes to the default value of the \c type |
---|
| 337 | // with 0 index. |
---|
[414] | 338 | Variant() { |
---|
| 339 | flag = 0; |
---|
[416] | 340 | new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data)) |
---|
[414] | 341 | typename TypeMap::template Map<0>::Type(); |
---|
| 342 | } |
---|
| 343 | |
---|
| 344 | |
---|
[431] | 345 | // \brief Copy constructor |
---|
| 346 | // |
---|
| 347 | // Copy constructor |
---|
[414] | 348 | Variant(const Variant& variant) { |
---|
| 349 | flag = variant.flag; |
---|
| 350 | _variant_bits::Memory<num - 1, TypeMap>::copy(flag, data, variant.data); |
---|
| 351 | } |
---|
| 352 | |
---|
[431] | 353 | // \brief Assign operator |
---|
| 354 | // |
---|
| 355 | // Assign operator |
---|
[414] | 356 | Variant& operator=(const Variant& variant) { |
---|
| 357 | if (this == &variant) return *this; |
---|
| 358 | _variant_bits::Memory<num - 1, TypeMap>:: |
---|
| 359 | destroy(flag, data); |
---|
| 360 | flag = variant.flag; |
---|
| 361 | _variant_bits::Memory<num - 1, TypeMap>:: |
---|
| 362 | copy(flag, data, variant.data); |
---|
| 363 | return *this; |
---|
| 364 | } |
---|
| 365 | |
---|
[431] | 366 | // \brief Destrcutor |
---|
| 367 | // |
---|
| 368 | // Destructor |
---|
[414] | 369 | ~Variant() { |
---|
| 370 | _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data); |
---|
| 371 | } |
---|
| 372 | |
---|
[431] | 373 | // \brief Set to the default value of the type with \c _idx index. |
---|
| 374 | // |
---|
| 375 | // This function sets the variant to the default value of the |
---|
| 376 | // type with \c _idx index. |
---|
[414] | 377 | template <int _idx> |
---|
| 378 | Variant& set() { |
---|
| 379 | _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data); |
---|
| 380 | flag = _idx; |
---|
[416] | 381 | new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) |
---|
[414] | 382 | typename TypeMap::template Map<_idx>::Type(); |
---|
| 383 | return *this; |
---|
| 384 | } |
---|
| 385 | |
---|
[431] | 386 | // \brief Set to the given value of the type with \c _idx index. |
---|
| 387 | // |
---|
| 388 | // This function sets the variant to the given value of the type |
---|
| 389 | // with \c _idx index. |
---|
[414] | 390 | template <int _idx> |
---|
| 391 | Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) { |
---|
| 392 | _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data); |
---|
| 393 | flag = _idx; |
---|
[416] | 394 | new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) |
---|
[414] | 395 | typename TypeMap::template Map<_idx>::Type(init); |
---|
| 396 | return *this; |
---|
| 397 | } |
---|
| 398 | |
---|
[431] | 399 | // \brief Gets the current value of the type with \c _idx index. |
---|
| 400 | // |
---|
| 401 | // Gets the current value of the type with \c _idx index. |
---|
[414] | 402 | template <int _idx> |
---|
| 403 | const typename TypeMap::template Map<_idx>::Type& get() const { |
---|
| 404 | LEMON_DEBUG(_idx == flag, "Variant wrong index"); |
---|
| 405 | return *reinterpret_cast<const typename TypeMap:: |
---|
[416] | 406 | template Map<_idx>::Type*>(data); |
---|
[414] | 407 | } |
---|
| 408 | |
---|
[431] | 409 | // \brief Gets the current value of the type with \c _idx index. |
---|
| 410 | // |
---|
| 411 | // Gets the current value of the type with \c _idx index. |
---|
[414] | 412 | template <int _idx> |
---|
| 413 | typename _TypeMap::template Map<_idx>::Type& get() { |
---|
| 414 | LEMON_DEBUG(_idx == flag, "Variant wrong index"); |
---|
| 415 | return *reinterpret_cast<typename TypeMap::template Map<_idx>::Type*> |
---|
[416] | 416 | (data); |
---|
[414] | 417 | } |
---|
| 418 | |
---|
[431] | 419 | // \brief Returns the current state of the variant. |
---|
| 420 | // |
---|
| 421 | // Returns the current state of the variant. |
---|
[414] | 422 | int state() const { |
---|
| 423 | return flag; |
---|
| 424 | } |
---|
| 425 | |
---|
| 426 | private: |
---|
[416] | 427 | |
---|
[414] | 428 | char data[_variant_bits::Size<num - 1, TypeMap>::value]; |
---|
| 429 | int flag; |
---|
| 430 | }; |
---|
| 431 | |
---|
| 432 | namespace _variant_bits { |
---|
| 433 | |
---|
| 434 | template <int _index, typename _List> |
---|
| 435 | struct Get { |
---|
| 436 | typedef typename Get<_index - 1, typename _List::Next>::Type Type; |
---|
| 437 | }; |
---|
| 438 | |
---|
| 439 | template <typename _List> |
---|
| 440 | struct Get<0, _List> { |
---|
| 441 | typedef typename _List::Type Type; |
---|
| 442 | }; |
---|
| 443 | |
---|
| 444 | struct List {}; |
---|
[416] | 445 | |
---|
[414] | 446 | template <typename _Type, typename _List> |
---|
| 447 | struct Insert { |
---|
| 448 | typedef _List Next; |
---|
| 449 | typedef _Type Type; |
---|
| 450 | }; |
---|
| 451 | |
---|
[416] | 452 | template <int _idx, typename _T0, typename _T1, typename _T2, |
---|
[430] | 453 | typename _T3, typename _T4, typename _T5, typename _T6, |
---|
[414] | 454 | typename _T7, typename _T8, typename _T9> |
---|
| 455 | struct Mapper { |
---|
| 456 | typedef List L10; |
---|
| 457 | typedef Insert<_T9, L10> L9; |
---|
| 458 | typedef Insert<_T8, L9> L8; |
---|
| 459 | typedef Insert<_T7, L8> L7; |
---|
| 460 | typedef Insert<_T6, L7> L6; |
---|
| 461 | typedef Insert<_T5, L6> L5; |
---|
| 462 | typedef Insert<_T4, L5> L4; |
---|
| 463 | typedef Insert<_T3, L4> L3; |
---|
| 464 | typedef Insert<_T2, L3> L2; |
---|
| 465 | typedef Insert<_T1, L2> L1; |
---|
| 466 | typedef Insert<_T0, L1> L0; |
---|
| 467 | typedef typename Get<_idx, L0>::Type Type; |
---|
| 468 | }; |
---|
[416] | 469 | |
---|
[414] | 470 | } |
---|
| 471 | |
---|
[431] | 472 | // \brief Helper class for Variant |
---|
| 473 | // |
---|
| 474 | // Helper class to define type mappings for Variant. This class |
---|
| 475 | // converts the template parameters to be mappable by integer. |
---|
| 476 | // \see Variant |
---|
[414] | 477 | template < |
---|
[416] | 478 | typename _T0, |
---|
[414] | 479 | typename _T1 = void, typename _T2 = void, typename _T3 = void, |
---|
[430] | 480 | typename _T4 = void, typename _T5 = void, typename _T6 = void, |
---|
[414] | 481 | typename _T7 = void, typename _T8 = void, typename _T9 = void> |
---|
| 482 | struct VariantTypeMap { |
---|
| 483 | template <int _idx> |
---|
| 484 | struct Map { |
---|
| 485 | typedef typename _variant_bits:: |
---|
| 486 | Mapper<_idx, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>::Type |
---|
| 487 | Type; |
---|
| 488 | }; |
---|
| 489 | }; |
---|
[416] | 490 | |
---|
[414] | 491 | } |
---|
| 492 | |
---|
| 493 | |
---|
| 494 | #endif |
---|