[Lemon-commits] Alpar Juttner: Merge
Lemon HG
hg at lemon.cs.elte.hu
Fri Dec 12 23:30:49 CET 2008
details: http://lemon.cs.elte.hu/hg/lemon/rev/e9a568cc86e3
changeset: 453:e9a568cc86e3
user: Alpar Juttner <alpar [at] cs.elte.hu>
date: Fri Dec 12 21:41:05 2008 +0000
description:
Merge
diffstat:
1 file changed, 153 insertions(+), 153 deletions(-)
lemon/bits/variant.h | 306 +++++++++++++++++++++++++-------------------------
diffs (truncated from 502 to 300 lines):
diff --git a/lemon/bits/variant.h b/lemon/bits/variant.h
--- a/lemon/bits/variant.h
+++ b/lemon/bits/variant.h
@@ -21,8 +21,8 @@
#include <lemon/assert.h>
-/// \file
-/// \brief Variant types
+// \file
+// \brief Variant types
namespace lemon {
@@ -36,53 +36,53 @@
}
- /// \brief Simple Variant type for two types
- ///
- /// Simple Variant type for two types. The Variant type is a type
- /// safe union. The C++ has strong limitations for using unions, by
- /// example we can not store type with non default constructor or
- /// destructor in an union. This class always knowns the current
- /// state of the variant and it cares for the proper construction
- /// and destruction.
+ // \brief Simple Variant type for two types
+ //
+ // Simple Variant type for two types. The Variant type is a type-safe
+ // union. C++ has strong limitations for using unions, for
+ // example you cannot store a type with non-default constructor or
+ // destructor in a union. This class always knowns the current
+ // state of the variant and it cares for the proper construction
+ // and destruction.
template <typename _First, typename _Second>
class BiVariant {
public:
- /// \brief The \c First type.
+ // \brief The \c First type.
typedef _First First;
- /// \brief The \c Second type.
+ // \brief The \c Second type.
typedef _Second Second;
- /// \brief Constructor
- ///
- /// This constructor initalizes to the default value of the \c First
- /// type.
+ // \brief Constructor
+ //
+ // This constructor initalizes to the default value of the \c First
+ // type.
BiVariant() {
flag = true;
new(reinterpret_cast<First*>(data)) First();
}
- /// \brief Constructor
- ///
- /// This constructor initalizes to the given value of the \c First
- /// type.
+ // \brief Constructor
+ //
+ // This constructor initalizes to the given value of the \c First
+ // type.
BiVariant(const First& f) {
flag = true;
new(reinterpret_cast<First*>(data)) First(f);
}
- /// \brief Constructor
- ///
- /// This constructor initalizes to the given value of the \c
- /// Second type.
+ // \brief Constructor
+ //
+ // This constructor initalizes to the given value of the \c
+ // Second type.
BiVariant(const Second& s) {
flag = false;
new(reinterpret_cast<Second*>(data)) Second(s);
}
- /// \brief Copy constructor
- ///
- /// Copy constructor
+ // \brief Copy constructor
+ //
+ // Copy constructor
BiVariant(const BiVariant& bivariant) {
flag = bivariant.flag;
if (flag) {
@@ -92,17 +92,17 @@
}
}
- /// \brief Destrcutor
- ///
- /// Destructor
+ // \brief Destrcutor
+ //
+ // Destructor
~BiVariant() {
destroy();
}
- /// \brief Set to the default value of the \c First type.
- ///
- /// This function sets the variant to the default value of the \c
- /// First type.
+ // \brief Set to the default value of the \c First type.
+ //
+ // This function sets the variant to the default value of the \c
+ // First type.
BiVariant& setFirst() {
destroy();
flag = true;
@@ -110,10 +110,10 @@
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.
+ // \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;
@@ -121,10 +121,10 @@
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.
+ // \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;
@@ -132,10 +132,10 @@
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.
+ // \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;
@@ -143,17 +143,17 @@
return *this;
}
- /// \brief Operator form of the \c setFirst()
+ // \brief Operator form of the \c setFirst()
BiVariant& operator=(const First& f) {
return setFirst(f);
}
- /// \brief Operator form of the \c setSecond()
+ // \brief Operator form of the \c setSecond()
BiVariant& operator=(const Second& s) {
return setSecond(s);
}
- /// \brief Assign operator
+ // \brief Assign operator
BiVariant& operator=(const BiVariant& bivariant) {
if (this == &bivariant) return *this;
destroy();
@@ -166,60 +166,60 @@
return *this;
}
- /// \brief Reference to the value
- ///
- /// Reference to the value of the \c First type.
- /// \pre The BiVariant should store value of \c First type.
+ // \brief Reference to the value
+ //
+ // Reference to the value of the \c First type.
+ // \pre The BiVariant should store value of \c First type.
First& first() {
LEMON_DEBUG(flag, "Variant wrong state");
- return *reinterpret_cast<First*>(data);
+ return *reinterpret_cast<First*>(data);
}
- /// \brief Const reference to the value
- ///
- /// Const reference to the value of the \c First type.
- /// \pre The BiVariant should store value of \c First type.
- const First& first() const {
+ // \brief Const reference to the value
+ //
+ // Const reference to the value of the \c First type.
+ // \pre The BiVariant should store value of \c First type.
+ const First& first() const {
LEMON_DEBUG(flag, "Variant wrong state");
- return *reinterpret_cast<const First*>(data);
+ return *reinterpret_cast<const First*>(data);
}
- /// \brief Operator form of the \c first()
+ // \brief Operator form of the \c first()
operator First&() { return first(); }
- /// \brief Operator form of the const \c first()
+ // \brief Operator form of the const \c first()
operator const First&() const { return first(); }
- /// \brief Reference to the value
- ///
- /// Reference to the value of the \c Second type.
- /// \pre The BiVariant should store value of \c Second type.
- Second& second() {
+ // \brief Reference to the value
+ //
+ // Reference to the value of the \c Second type.
+ // \pre The BiVariant should store value of \c Second type.
+ Second& second() {
LEMON_DEBUG(!flag, "Variant wrong state");
- return *reinterpret_cast<Second*>(data);
+ return *reinterpret_cast<Second*>(data);
}
- /// \brief Const reference to the value
- ///
- /// Const reference to the value of the \c Second type.
- /// \pre The BiVariant should store value of \c Second type.
- const Second& second() const {
+ // \brief Const reference to the value
+ //
+ // Const reference to the value of the \c Second type.
+ // \pre The BiVariant should store value of \c Second type.
+ const Second& second() const {
LEMON_DEBUG(!flag, "Variant wrong state");
- return *reinterpret_cast<const Second*>(data);
+ return *reinterpret_cast<const Second*>(data);
}
- /// \brief Operator form of the \c second()
+ // \brief Operator form of the \c second()
operator Second&() { return second(); }
- /// \brief Operator form of the const \c second()
+ // \brief Operator form of the const \c second()
operator const Second&() const { return second(); }
- /// \brief %True when the variant is in the first state
- ///
- /// %True when the variant stores value of the \c First type.
+ // \brief %True when the variant is in the first state
+ //
+ // %True when the variant stores value of the \c First type.
bool firstState() const { return flag; }
- /// \brief %True when the variant is in the second state
- ///
- /// %True when the variant stores value of the \c Second type.
+ // \brief %True when the variant is in the second state
+ //
+ // %True when the variant stores value of the \c Second type.
bool secondState() const { return !flag; }
private:
@@ -289,40 +289,40 @@
}
- /// \brief Variant type
- ///
- /// Simple Variant type. The Variant type is a type safe union. The
- /// C++ has strong limitations for using unions, for example we
- /// cannot store type with non default constructor or destructor in
- /// a union. This class always knowns the current state of the
- /// variant and it cares for the proper construction and
- /// 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
More information about the Lemon-commits
mailing list