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

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