boost/variant/get.hpp

   1 //-----------------------------------------------------------------------------
   2 // boost variant/get.hpp header file
   3 // See http://www.boost.org for updates, documentation, and revision history.
   4 //-----------------------------------------------------------------------------
   5 //
   6 // Copyright (c) 2003
   7 // Eric Friedman, Itay Maman
   8 //
   9 // Distributed under the Boost Software License, Version 1.0. (See
  10 // accompanying file LICENSE_1_0.txt or copy at
  11 // http://www.boost.org/LICENSE_1_0.txt)
  12
  13 #ifndef BOOST_VARIANT_GET_HPP
  14 #define BOOST_VARIANT_GET_HPP
  15
  16 #include <exception>
  17
  18 #include "boost/config.hpp"
  19 #include "boost/detail/workaround.hpp"
  20 #include "boost/utility/addressof.hpp"
  21 #include "boost/variant/variant_fwd.hpp"
  22
  23 #include "boost/type_traits/add_reference.hpp"
  24 #include "boost/type_traits/add_pointer.hpp"
  25
  26 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
  27 #   include "boost/mpl/bool.hpp"
  28 #   include "boost/mpl/or.hpp"
  29 #   include "boost/type_traits/is_same.hpp"
  30 #endif
  31
  32 namespace boost {
  33
  34 //////////////////////////////////////////////////////////////////////////
  35 // class bad_get
  36 //
  37 // The exception thrown in the event of a failed get of a value.
  38 //
  39 class bad_get
  40     : public std::exception
  41 {
  42 public: // std::exception implementation
  43
  44     virtual const char * what() const throw()
  45     {
  46         return "boost::bad_get: "
  47                "failed value get using boost::get";
  48     }
  49
  50 };
  51
  52 //////////////////////////////////////////////////////////////////////////
  53 // function template get<T>
  54 //
  55 // Retrieves content of given variant object if content is of type T.
  56 // Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
  57 //
  58
  59 namespace detail { namespace variant {
  60
  61 // (detail) class template get_visitor
  62 //
  63 // Generic static visitor that: if the value is of the specified type,
  64 // returns a pointer to the value it visits; else a null pointer.
  65 //
  66 template <typename T>
  67 struct get_visitor
  68 {
  69 private: // private typedefs
  70
  71     typedef typename add_pointer<T>::type pointer;
  72     typedef typename add_reference<T>::type reference;
  73
  74 public: // visitor typedefs
  75
  76     typedef pointer result_type;
  77
  78 public: // visitor interfaces
  79
  80 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
  81
  82     pointer operator()(reference operand) const
  83     {
  84         return boost::addressof(operand);
  85     }
  86
  87     template <typename U>
  88     pointer operator()(const U&) const
  89     {
  90         return static_cast<pointer>(0);
  91     }
  92
  93 #else // MSVC6
  94
  95 private: // helpers, for visitor interfaces (below)
  96
  97     pointer execute_impl(reference operand, mpl::true_) const
  98     {
  99         return boost::addressof(operand);
 100     }
 101
 102     template <typename U>
 103     pointer execute_impl(const U& operand, mpl::false_) const
 104     {
 105         return static_cast<pointer>(0);
 106     }
 107
 108 public: // visitor interfaces
 109
 110     template <typename U>
 111     pointer operator()(U& operand) const
 112     {
 113         // MSVC6 finds normal implementation (above) ambiguous,
 114         // so we must explicitly disambiguate
 115
 116         typedef typename mpl::or_<
 117               is_same<U, T>
 118             , is_same<const U, T>
 119             >::type U_is_T;
 120
 121         return execute_impl(operand, U_is_T());
 122     }
 123
 124 #endif // MSVC6 workaround
 125
 126 };
 127
 128 }} // namespace detail::variant
 129
 130 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
 131 #   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
 132     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
 133 #else
 134 #   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
 135     , t* = 0
 136 #endif
 137
 138 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 139 inline
 140     typename add_pointer<U>::type
 141 get(
 142       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
 143       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
 144     )
 145 {
 146     typedef typename add_pointer<U>::type U_ptr;
 147     if (!operand) return static_cast<U_ptr>(0);
 148
 149     detail::variant::get_visitor<U> v;
 150     return operand->apply_visitor(v);
 151 }
 152
 153 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 154 inline
 155     typename add_pointer<const U>::type
 156 get(
 157       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
 158       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
 159     )
 160 {
 161     typedef typename add_pointer<const U>::type U_ptr;
 162     if (!operand) return static_cast<U_ptr>(0);
 163
 164     detail::variant::get_visitor<const U> v;
 165     return operand->apply_visitor(v);
 166 }
 167
 168 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 169 inline
 170     typename add_reference<U>::type
 171 get(
 172       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
 173       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
 174     )
 175 {
 176     typedef typename add_pointer<U>::type U_ptr;
 177     U_ptr result = get<U>(&operand);
 178
 179     if (!result)
 180         throw bad_get();
 181     return *result;
 182 }
 183
 184 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 185 inline
 186     typename add_reference<const U>::type
 187 get(
 188       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
 189       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
 190     )
 191 {
 192     typedef typename add_pointer<const U>::type U_ptr;
 193     U_ptr result = get<const U>(&operand);
 194
 195     if (!result)
 196         throw bad_get();
 197     return *result;
 198 }
 199
 200 } // namespace boost
 201
 202 #endif // BOOST_VARIANT_GET_HPP