RhodeCode

/// \file

/// \brief Variant types

  /// \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 The \c First type.

    /// \brief The \c Second type.

    /// \brief Constructor

    ///

    /// This constructor initalizes to the default value of the \c First

    /// type.

    /// \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

    /// Second type.

    /// \brief Copy constructor

    ///

    /// Copy constructor

    /// \brief Destrcutor

    ///

    /// Destructor

    /// \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 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 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 given value of the \c Second type.

    ///

    /// This function sets the variant to the given value of the \c

    /// Second type.

    /// \brief Operator form of the \c setFirst()

    /// \brief Operator form of the \c setSecond()

    /// \brief Assign operator

    /// \brief Reference to the value

    ///

    /// Reference to the value of the \c First type.

    /// \pre The BiVariant should store value of \c First type.

      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 { 

      return *reinterpret_cast<const First*>(data); 

    /// \brief Operator form of the \c first()

    /// \brief Operator form of the const \c 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() { 

      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 { 

      return *reinterpret_cast<const Second*>(data); 

    /// \brief Operator form of the \c second()

    /// \brief Operator form of the const \c 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 second state

    ///

    /// %True when the variant stores value of the \c Second type.

  /// \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

  /// typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant;

  /// MyVariant var;

  /// var.set<0>(12);

  /// std::cout << var.get<0>() << std::endl;

  /// var.set<1>("alpha");

  /// std::cout << var.get<1>() << std::endl;

  /// var.set<2>(0.75);

  /// std::cout << var.get<2>() << std::endl;

  ///\endcode

  ///

  /// The result of course:

  ///\code

  /// 12

  /// alpha

  /// 0.75

  ///\endcode

    /// \brief Constructor

    ///

    /// This constructor initalizes to the default value of the \c type

    /// with 0 index.

    /// \brief Copy constructor

    ///

    /// Copy constructor

    /// \brief Assign operator

    ///

    /// Assign operator

    /// \brief Destrcutor

    ///

    /// Destructor

    /// \brief Set to the default value of the type with \c _idx index.

    ///

    /// This function sets the variant to the default value of the

    /// type with \c _idx index.

    /// \brief Set to the given value of the type with \c _idx index.

    ///

    /// This function sets the variant to the given value of the type

    /// with \c _idx index.

    /// \brief Gets the current value of the type with \c _idx index.

    ///

    /// Gets the current value of the type with \c _idx index.

    /// \brief Gets the current value of the type with \c _idx index.

    ///

    /// Gets the current value of the type with \c _idx index.

    /// \brief Returns the current state of the variant.

    ///

    /// Returns the current state of the variant.

              typename _T3, typename _T5, typename _T4, typename _T6,

  /// \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

    typename _T5 = void, typename _T4 = void, typename _T6 = void,