Mercurialtest / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
epoc32/include/stdapis/boost/variant/detail/enable_recursive.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations 
     1 //-----------------------------------------------------------------------------

     2 // boost variant/detail/enable_recursive.hpp header file

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

     4 //-----------------------------------------------------------------------------

     5 //

     6 // Copyright (c) 2003

     7 // Eric Friedman

     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_DETAIL_ENABLE_RECURSIVE_HPP

    14 #define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP

    15 

    16 #include "boost/variant/detail/enable_recursive_fwd.hpp"

    17 #include "boost/variant/variant_fwd.hpp"

    18 

    19 #if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)

    20 #   include "boost/mpl/apply.hpp"

    21 #   include "boost/mpl/eval_if.hpp"

    22 #   include "boost/mpl/lambda.hpp"

    23 #endif

    24 

    25 #include "boost/variant/detail/substitute.hpp"

    26 #include "boost/mpl/aux_/config/ctps.hpp"

    27 #include "boost/mpl/bool_fwd.hpp"

    28 #include "boost/mpl/if.hpp"

    29 #include "boost/mpl/or.hpp"

    30 #include "boost/type_traits/is_pointer.hpp"

    31 #include "boost/type_traits/is_reference.hpp"

    32 #include "boost/type_traits/is_same.hpp"

    33 

    34 #include "boost/variant/recursive_wrapper.hpp"

    35 

    36 namespace boost {

    37 namespace detail { namespace variant {

    38 

    39 #if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)

    40 

    41 #   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \

    42     substitute< T , Dest , Source > \

    43     /**/

    44 

    45 #else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)

    46 

    47 ///////////////////////////////////////////////////////////////////////////////

    48 // (detail) class template rebind1

    49 //

    50 // Limited workaround in case 'substitute' metafunction unavailable.

    51 //

    52 

    53 template <typename T, typename U1>

    54 struct rebind1

    55 {

    56 private:

    57     typedef typename mpl::lambda<

    58           mpl::identity<T>

    59         >::type le_;

    60 

    61 public:

    62     typedef typename mpl::eval_if<

    63           is_same< le_, mpl::identity<T> >

    64         , le_ // identity<T>

    65         , mpl::apply1<le_, U1>

    66         >::type type;

    67 };

    68 

    69 #   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \

    70     rebind1< T , Dest > \

    71     /**/

    72 

    73 #endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)

    74 

    75 ///////////////////////////////////////////////////////////////////////////////

    76 // (detail) metafunction enable_recursive

    77 //

    78 // See boost/variant/detail/enable_recursive_fwd.hpp for more information.

    79 //

    80 

    81 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

    82 

    83 template <typename T, typename RecursiveVariant, typename NoWrapper>

    84 struct enable_recursive

    85     : BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(

    86           T, RecursiveVariant, ::boost::recursive_variant_

    87         )

    88 {

    89 };

    90 

    91 template <typename T, typename RecursiveVariant>

    92 struct enable_recursive< T,RecursiveVariant,mpl::false_ >

    93 {

    94 private: // helpers, for metafunction result (below)

    95 

    96     typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(

    97           T, RecursiveVariant, ::boost::recursive_variant_

    98         )::type t_;

    99 

   100 public: // metafunction result

   101 

   102     // [Wrap with recursive_wrapper only if rebind really changed something:]

   103     typedef typename mpl::if_<

   104           mpl::or_<

   105               is_same< t_,T >

   106             , is_reference<t_>

   107             , is_pointer<t_>

   108             >

   109         , t_

   110         , boost::recursive_wrapper<t_>

   111         >::type type;

   112 

   113 };

   114 

   115 #else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   116 

   117 template <typename T, typename RecursiveVariant, typename NoWrapper>

   118 struct enable_recursive

   119 {

   120 private: // helpers, for metafunction result (below)

   121 

   122     typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(

   123           T, RecursiveVariant, ::boost::recursive_variant_

   124         )::type t_;

   125 

   126 public: // metafunction result

   127 

   128     // [Wrap with recursive_wrapper only if rebind really changed something:]

   129     typedef typename mpl::if_<

   130           mpl::or_<

   131               NoWrapper

   132             , is_same< t_,T >

   133             , is_reference<t_>

   134             , is_pointer<t_>

   135             >

   136         , t_

   137         , boost::recursive_wrapper<t_>

   138         >::type type;

   139 

   140 };

   141 

   142 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround

   143 

   144 ///////////////////////////////////////////////////////////////////////////////

   145 // (detail) metafunction class quoted_enable_recursive

   146 //

   147 // Same behavior as enable_recursive metafunction (see above).

   148 //

   149 template <typename RecursiveVariant, typename NoWrapper>

   150 struct quoted_enable_recursive

   151 {

   152     template <typename T>

   153     struct apply

   154         : enable_recursive<T, RecursiveVariant, NoWrapper>

   155     {

   156     };

   157 };

   158 

   159 }} // namespace detail::variant

   160 } // namespace boost

   161 

   162 #endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
test