//----------------------------------------------------------------------------- // boost variant/recursive_wrapper_fwd.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2002 // Eric Friedman, Itay Maman // // Portions Copyright (C) 2002 David Abrahams // // 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_RECURSIVE_WRAPPER_FWD_HPP #define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP #include "boost/mpl/aux_/config/ctps.hpp" #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include "boost/mpl/eval_if.hpp" # include "boost/mpl/bool.hpp" # include "boost/mpl/identity.hpp" # include "boost/type.hpp" #endif #include "boost/mpl/aux_/lambda_support.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { ////////////////////////////////////////////////////////////////////////// // class template recursive_wrapper // // Enables recursive types in templates by breaking cyclic dependencies. // // For example: // // class my; // // typedef variant< int, recursive_wrapper<my> > var; // // class my { // var var_; // ... // }; // template <typename T> class recursive_wrapper; /////////////////////////////////////////////////////////////////////////////// // metafunction is_recursive_wrapper (modeled on code by David Abrahams) // // True iff specified type matches recursive_wrapper<T>. // namespace detail { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct is_recursive_wrapper_impl : mpl::false_ { }; template <typename T> struct is_recursive_wrapper_impl< recursive_wrapper<T> > : mpl::true_ { }; #else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) typedef char (&yes_recursive_wrapper_t)[1]; typedef char (&no_recursive_wrapper_t)[2]; no_recursive_wrapper_t is_recursive_wrapper_test(...); template<typename T> yes_recursive_wrapper_t is_recursive_wrapper_test( type< ::boost::recursive_wrapper<T> > ); template<typename T> struct is_recursive_wrapper_impl { BOOST_STATIC_CONSTANT(bool, value = ( sizeof(is_recursive_wrapper_test(type<T>())) == sizeof(yes_recursive_wrapper_t) )); }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_recursive_wrapper , T , (::boost::detail::is_recursive_wrapper_impl<T>::value) ) /////////////////////////////////////////////////////////////////////////////// // metafunction unwrap_recursive // // If specified type T matches recursive_wrapper<U>, then U; else T. // #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct unwrap_recursive { typedef T type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T)) }; template <typename T> struct unwrap_recursive< recursive_wrapper<T> > { typedef T type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,unwrap_recursive,(T)) }; #else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template <typename T> struct unwrap_recursive : mpl::eval_if< is_recursive_wrapper<T> , T , mpl::identity< T > > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T)) }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP