//-----------------------------------------------------------------------------

 // boost variant/get.hpp header file

 // See http://www.boost.org for updates, documentation, and revision history.

 //-----------------------------------------------------------------------------

 //

 // Copyright (c) 2003

 // Eric Friedman, Itay Maman

 //

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 #ifndef BOOST_VARIANT_GET_HPP

 #define BOOST_VARIANT_GET_HPP

 #include <exception>

 #include "boost/config.hpp"

 #include "boost/detail/workaround.hpp"

 #include "boost/utility/addressof.hpp"

 #include "boost/variant/variant_fwd.hpp"

 #include "boost/type_traits/add_reference.hpp"

 #include "boost/type_traits/add_pointer.hpp"

 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

 #   include "boost/mpl/bool.hpp"

 #   include "boost/mpl/or.hpp"

 #   include "boost/type_traits/is_same.hpp"

 #endif

 namespace boost {

 //////////////////////////////////////////////////////////////////////////

 // class bad_get

 //

 // The exception thrown in the event of a failed get of a value.

 //

 class bad_get

     : public std::exception

 {

 public: // std::exception implementation

     virtual const char * what() const throw()

     {

         return "boost::bad_get: "

                "failed value get using boost::get";

     }

 };

 //////////////////////////////////////////////////////////////////////////

 // function template get<T>

 //

 // Retrieves content of given variant object if content is of type T.

 // Otherwise: pointer ver. returns 0; reference ver. throws bad_get.

 //

 namespace detail { namespace variant {

 // (detail) class template get_visitor

 //

 // Generic static visitor that: if the value is of the specified type,

 // returns a pointer to the value it visits; else a null pointer.

 //

 template <typename T>

 struct get_visitor

 {

 private: // private typedefs

     typedef typename add_pointer<T>::type pointer;

     typedef typename add_reference<T>::type reference;

 public: // visitor typedefs

     typedef pointer result_type;

 public: // visitor interfaces

 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

     pointer operator()(reference operand) const

     {

         return boost::addressof(operand);

     }

     template <typename U>

     pointer operator()(const U&) const

     {

         return static_cast<pointer>(0);

     }

 #else // MSVC6

 private: // helpers, for visitor interfaces (below)

     pointer execute_impl(reference operand, mpl::true_) const

     {

         return boost::addressof(operand);

     }

     template <typename U>

     pointer execute_impl(const U& operand, mpl::false_) const

     {

         return static_cast<pointer>(0);

     }

 public: // visitor interfaces

     template <typename U>

     pointer operator()(U& operand) const

     {

         // MSVC6 finds normal implementation (above) ambiguous,

         // so we must explicitly disambiguate

         typedef typename mpl::or_<

               is_same<U, T>

             , is_same<const U, T>

             >::type U_is_T;

         return execute_impl(operand, U_is_T());

     }

 #endif // MSVC6 workaround

 };

 }} // namespace detail::variant

 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))

 #   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \

     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)

 #else

 #   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \

     , t* = 0

 #endif

 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >

 inline

     typename add_pointer<U>::type

 get(

       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand

       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)

     )

 {

     typedef typename add_pointer<U>::type U_ptr;

     if (!operand) return static_cast<U_ptr>(0);

     detail::variant::get_visitor<U> v;

     return operand->apply_visitor(v);

 }

 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >

 inline

     typename add_pointer<const U>::type

 get(

       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand

       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)

     )

 {

     typedef typename add_pointer<const U>::type U_ptr;

     if (!operand) return static_cast<U_ptr>(0);

     detail::variant::get_visitor<const U> v;

     return operand->apply_visitor(v);

 }

 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >

 inline

     typename add_reference<U>::type

 get(

       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand

       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)

     )

 {

     typedef typename add_pointer<U>::type U_ptr;

     U_ptr result = get<U>(&operand);

     if (!result)

         throw bad_get();

     return *result;

 }

 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >

 inline

     typename add_reference<const U>::type

 get(

       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand

       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)

     )

 {

     typedef typename add_pointer<const U>::type U_ptr;

     U_ptr result = get<const U>(&operand);

     if (!result)

         throw bad_get();

     return *result;

 }

 } // namespace boost

 #endif // BOOST_VARIANT_GET_HPP