204 lines
5.1 KiB
C++
204 lines
5.1 KiB
C++
//-----------------------------------------------------------------------------
|
|
// 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/throw_exception.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 BOOST_NOEXCEPT_OR_NOTHROW
|
|
{
|
|
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)
|
|
boost::throw_exception(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)
|
|
boost::throw_exception(bad_get());
|
|
return *result;
|
|
}
|
|
|
|
} // namespace boost
|
|
|
|
#endif // BOOST_VARIANT_GET_HPP
|