lemon-1.1: comparison lemon/bits/variant.h

equal deleted inserted replaced

-:c6e5f383942b
+:637d492e6e65
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 /// \brief Variant types
 namespace lemon {
 namespace _variant_bits {
 template <int left, int right>
 struct CTMax {
 static const int value = left < right ? right : left;
 };
 ///
 /// Copy constructor
 BiVariant(const BiVariant& bivariant) {
 flag = bivariant.flag;
 if (flag) {
 new(reinterpret_cast<First*>(data)) First(bivariant.first());
 } else {
 new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
 }
 }
 /// \brief Destrcutor
 ///
 /// This function sets the variant to the default value of the \c
 /// First type.
 BiVariant& setFirst() {
 destroy();
 flag = true;
 new(reinterpret_cast<First*>(data)) First();
 return *this;
 }
 /// \brief Set to the given value of the \c First type.
 ///
 /// This function sets the variant to the given value of the \c
 /// First type.
 BiVariant& setFirst(const First& f) {
 destroy();
 flag = true;
 new(reinterpret_cast<First*>(data)) First(f);
 return *this;
 }
 /// \brief Set to the default value of the \c Second type.
 ///
 /// This function sets the variant to the default value of the \c
 /// Second type.
 BiVariant& setSecond() {
 destroy();
 flag = false;
 new(reinterpret_cast<Second*>(data)) Second();
 return *this;
 }
 /// \brief Set to the given value of the \c Second type.
 ///
 /// This function sets the variant to the given value of the \c
 /// Second type.
 BiVariant& setSecond(const Second& s) {
 destroy();
 flag = false;
 new(reinterpret_cast<Second*>(data)) Second(s);
 return *this;
 }
 /// \brief Operator form of the \c setFirst()
 BiVariant& operator=(const First& f) {
 BiVariant& operator=(const BiVariant& bivariant) {
 if (this == &bivariant) return *this;
 destroy();
 flag = bivariant.flag;
 if (flag) {
 new(reinterpret_cast<First*>(data)) First(bivariant.first());
 } else {
 new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
 }
 return *this;
 }
 /// \brief Reference to the value
 reinterpret_cast<First*>(data)->~First();
 } else {
 reinterpret_cast<Second*>(data)->~Second();
 }
 }
 char data[_variant_bits::CTMax<sizeof(First), sizeof(Second)>::value];
 bool flag;
 };
 namespace _variant_bits {
 template <int _idx, typename _TypeMap>
 struct Memory {
 typedef typename _TypeMap::template Map<_idx>::Type Current;
 }
 };
 template <int _idx, typename _TypeMap>
 struct Size {
 static const int value =
 CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type),
 Size<_idx - 1, _TypeMap>::value>::value;
 };
 template <typename _TypeMap>
 struct Size<0, _TypeMap> {
 static const int value =
 sizeof(typename _TypeMap::template Map<0>::Type);
 };
 }
 /// destruction.
 ///
 /// \param _num The number of the types which can be stored in the
 /// variant type.
 /// \param _TypeMap This class describes the types of the Variant. The
 /// _TypeMap::Map<index>::Type should be a valid type for each index
 /// in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper
 /// class to define such type mappings up to 10 types.
 ///
 /// And the usage of the class:
 ///\code
 ///
 /// This constructor initalizes to the default value of the \c type
 /// with 0 index.
 Variant() {
 flag = 0;
 new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data))
 typename TypeMap::template Map<0>::Type();
 }
 /// \brief Copy constructor
 /// type with \c _idx index.
 template <int _idx>
 Variant& set() {
 _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
 flag = _idx;
 new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
 typename TypeMap::template Map<_idx>::Type();
 return *this;
 }
 /// \brief Set to the given value of the type with \c _idx index.
 /// with \c _idx index.
 template <int _idx>
 Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) {
 _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
 flag = _idx;
 new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
 typename TypeMap::template Map<_idx>::Type(init);
 return *this;
 }
 /// \brief Gets the current value of the type with \c _idx index.
 /// Gets the current value of the type with \c _idx index.
 template <int _idx>
 const typename TypeMap::template Map<_idx>::Type& get() const {
 LEMON_DEBUG(_idx == flag, "Variant wrong index");
 return *reinterpret_cast<const typename TypeMap::
 template Map<_idx>::Type*>(data);
 }
 /// \brief Gets the current value of the type with \c _idx index.
 ///
 /// Gets the current value of the type with \c _idx index.
 template <int _idx>
 typename _TypeMap::template Map<_idx>::Type& get() {
 LEMON_DEBUG(_idx == flag, "Variant wrong index");
 return *reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>
 (data);
 }
 /// \brief Returns the current state of the variant.
 ///
 /// Returns the current state of the variant.
 int state() const {
 return flag;
 }
 private:
 char data[_variant_bits::Size<num - 1, TypeMap>::value];
 int flag;
 };
 namespace _variant_bits {
 struct Get<0, _List> {
 typedef typename _List::Type Type;
 };
 struct List {};
 template <typename _Type, typename _List>
 struct Insert {
 typedef _List Next;
 typedef _Type Type;
 };
 template <int _idx, typename _T0, typename _T1, typename _T2,
 typename _T3, typename _T5, typename _T4, typename _T6,
 typename _T7, typename _T8, typename _T9>
 struct Mapper {
 typedef List L10;
 typedef Insert<_T9, L10> L9;
 typedef Insert<_T2, L3> L2;
 typedef Insert<_T1, L2> L1;
 typedef Insert<_T0, L1> L0;
 typedef typename Get<_idx, L0>::Type Type;
 };
 }
 /// \brief Helper class for Variant
 ///
 /// Helper class to define type mappings for Variant. This class
 /// converts the template parameters to be mappable by integer.
 /// \see Variant
 template <
 typename _T0,
 typename _T1 = void, typename _T2 = void, typename _T3 = void,
 typename _T5 = void, typename _T4 = void, typename _T6 = void,
 typename _T7 = void, typename _T8 = void, typename _T9 = void>
 struct VariantTypeMap {
 template <int _idx>
 typedef typename _variant_bits::
 Mapper<_idx, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>::Type
 Type;
 };
 };
 }
 #endif

changeset 418	ad483acf1654
parent 414	05357da973ce
child 430	09e416d35896