ceph/src/boost/libs/proto/include/boost/proto/detail/traits.hpp

   1 #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
   2
   3     #include <boost/proto/detail/preprocessed/traits.hpp>
   4
   5 #elif !defined(BOOST_PP_IS_ITERATING)
   6
   7     #define BOOST_PROTO_CHILD(Z, N, DATA)                                                           \
   8         /** INTERNAL ONLY */                                                                        \
   9         typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N);                                 \
  10         /**/
  11
  12     #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
  13         #pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp")
  14     #endif
  15
  16     ///////////////////////////////////////////////////////////////////////////////
  17     /// \file traits.hpp
  18     /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c
  19     //
  20     //  Copyright 2008 Eric Niebler. Distributed under the Boost
  21     //  Software License, Version 1.0. (See accompanying file
  22     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  23
  24     #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
  25         #pragma wave option(preserve: 1)
  26     #endif
  27
  28     #define BOOST_PP_ITERATION_PARAMS_1                                                             \
  29         (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/traits.hpp>))
  30     #include BOOST_PP_ITERATE()
  31
  32     #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
  33         #pragma wave option(output: null)
  34     #endif
  35
  36     #undef BOOST_PROTO_CHILD
  37
  38 #else // BOOST_PP_IS_ITERATING
  39
  40     #define N BOOST_PP_ITERATION()
  41
  42     #if N > 0
  43         /// \brief A metafunction for generating function-call expression types,
  44         /// a grammar element for matching function-call expressions, and a
  45         /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
  46         /// transform.
  47         template<BOOST_PP_ENUM_PARAMS(N, typename A)>
  48         struct function
  49         #if N != BOOST_PROTO_MAX_ARITY
  50         <
  51             BOOST_PP_ENUM_PARAMS(N, A)
  52             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
  53         >
  54         #endif
  55           : proto::transform<
  56                 function<
  57                     BOOST_PP_ENUM_PARAMS(N, A)
  58                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
  59                 >
  60               , int
  61             >
  62         {
  63             typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
  64             typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
  65
  66             template<typename Expr, typename State, typename Data>
  67             struct impl
  68               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
  69             {};
  70
  71             /// INTERNAL ONLY
  72             typedef proto::tag::function proto_tag;
  73             BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
  74             BOOST_PP_REPEAT_FROM_TO(
  75                 N
  76               , BOOST_PROTO_MAX_ARITY
  77               , BOOST_PROTO_CHILD
  78               , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
  79             )
  80         };
  81
  82         /// \brief A metafunction for generating n-ary expression types with a
  83         /// specified tag type,
  84         /// a grammar element for matching n-ary expressions, and a
  85         /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
  86         /// transform.
  87         ///
  88         /// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any
  89         /// n-ary expression; that is, any non-terminal.
  90         template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
  91         struct nary_expr
  92         #if N != BOOST_PROTO_MAX_ARITY
  93         <
  94             Tag
  95             BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
  96             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
  97         >
  98         #endif
  99           : proto::transform<
 100                 nary_expr<
 101                     Tag
 102                     BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
 103                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
 104                 >
 105               , int
 106             >
 107         {
 108             typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
 109             typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
 110
 111             template<typename Expr, typename State, typename Data>
 112             struct impl
 113               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
 114             {};
 115
 116             /// INTERNAL ONLY
 117             typedef Tag proto_tag;
 118             BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
 119             BOOST_PP_REPEAT_FROM_TO(
 120                 N
 121               , BOOST_PROTO_MAX_ARITY
 122               , BOOST_PROTO_CHILD
 123               , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
 124             )
 125         };
 126
 127         namespace detail
 128         {
 129             template<
 130                 template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T
 131               , BOOST_PP_ENUM_PARAMS(N, typename A)
 132             >
 133             struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)>
 134               : is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable>
 135             {};
 136         }
 137
 138     #endif
 139
 140         namespace result_of
 141         {
 142             /// \brief A metafunction that returns the type of the Nth child
 143             /// of a Proto expression.
 144             ///
 145             /// A metafunction that returns the type of the Nth child
 146             /// of a Proto expression. \c N must be less than
 147             /// \c Expr::proto_arity::value.
 148             template<typename Expr>
 149             struct child_c<Expr, N>
 150             {
 151                 /// Verify that we are not operating on a terminal
 152                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
 153
 154                 /// The raw type of the Nth child as it is stored within
 155                 /// \c Expr. This may be a value or a reference
 156                 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
 157
 158                 /// The "value" type of the child, suitable for return by value,
 159                 /// computed as follows:
 160                 /// \li <tt>T const &</tt> becomes <tt>T</tt>
 161                 /// \li <tt>T &</tt> becomes <tt>T</tt>
 162                 /// \li <tt>T</tt> becomes <tt>T</tt>
 163                 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type;
 164             };
 165
 166             template<typename Expr>
 167             struct child_c<Expr &, N>
 168             {
 169                 /// Verify that we are not operating on a terminal
 170                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
 171
 172                 /// The raw type of the Nth child as it is stored within
 173                 /// \c Expr. This may be a value or a reference
 174                 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
 175
 176                 /// The "reference" type of the child, suitable for return by
 177                 /// reference, computed as follows:
 178                 /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
 179                 /// \li <tt>T &</tt> becomes <tt>T &</tt>
 180                 /// \li <tt>T</tt> becomes <tt>T &</tt>
 181                 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type;
 182
 183                 /// INTERNAL ONLY
 184                 ///
 185                 BOOST_FORCEINLINE
 186                 static type call(Expr &e)
 187                 {
 188                     return e.proto_base().BOOST_PP_CAT(child, N);
 189                 }
 190             };
 191
 192             template<typename Expr>
 193             struct child_c<Expr const &, N>
 194             {
 195                 /// Verify that we are not operating on a terminal
 196                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
 197
 198                 /// The raw type of the Nth child as it is stored within
 199                 /// \c Expr. This may be a value or a reference
 200                 typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
 201
 202                 /// The "const reference" type of the child, suitable for return by
 203                 /// const reference, computed as follows:
 204                 /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
 205                 /// \li <tt>T &</tt> becomes <tt>T &</tt>
 206                 /// \li <tt>T</tt> becomes <tt>T const &</tt>
 207                 typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type;
 208
 209                 /// INTERNAL ONLY
 210                 ///
 211                 BOOST_FORCEINLINE
 212                 static type call(Expr const &e)
 213                 {
 214                     return e.proto_base().BOOST_PP_CAT(child, N);
 215                 }
 216             };
 217         }
 218
 219     #undef N
 220
 221 #endif