ceph/src/boost/boost/proto/make_expr.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 /// \file make_expr.hpp
   3 /// Definition of the \c make_expr() and \c unpack_expr() utilities for
   4 /// building Proto expression nodes from child nodes or from a Fusion
   5 /// sequence of child nodes, respectively.
   6 //
   7 //  Copyright 2008 Eric Niebler. Distributed under the Boost
   8 //  Software License, Version 1.0. (See accompanying file
   9 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  10
  11 #ifndef BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
  12 #define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
  13
  14 #include <boost/preprocessor/cat.hpp>
  15 #include <boost/preprocessor/arithmetic/inc.hpp>
  16 #include <boost/preprocessor/arithmetic/dec.hpp>
  17 #include <boost/preprocessor/arithmetic/sub.hpp>
  18 #include <boost/preprocessor/punctuation/comma_if.hpp>
  19 #include <boost/preprocessor/iteration/iterate.hpp>
  20 #include <boost/preprocessor/facilities/intercept.hpp>
  21 #include <boost/preprocessor/repetition/enum.hpp>
  22 #include <boost/preprocessor/repetition/enum_params.hpp>
  23 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  24 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
  25 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
  26 #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
  27 #include <boost/preprocessor/repetition/repeat.hpp>
  28 #include <boost/ref.hpp>
  29 #include <boost/mpl/if.hpp>
  30 #include <boost/mpl/assert.hpp>
  31 #include <boost/mpl/eval_if.hpp>
  32 #include <boost/utility/enable_if.hpp>
  33 #include <boost/type_traits/add_const.hpp>
  34 #include <boost/type_traits/add_reference.hpp>
  35 #include <boost/type_traits/remove_cv.hpp>
  36 #include <boost/proto/proto_fwd.hpp>
  37 #include <boost/proto/traits.hpp>
  38 #include <boost/proto/domain.hpp>
  39 #include <boost/proto/generate.hpp>
  40 #include <boost/fusion/include/at_c.hpp>
  41 #include <boost/fusion/include/begin.hpp>
  42 #include <boost/fusion/include/next.hpp>
  43 #include <boost/fusion/include/value_of.hpp>
  44 #include <boost/fusion/include/size.hpp>
  45 #include <boost/proto/detail/poly_function.hpp>
  46 #include <boost/proto/detail/deprecated.hpp>
  47
  48 #if defined(_MSC_VER)
  49 # pragma warning(push)
  50 # pragma warning(disable : 4180) // qualifier applied to function type has no meaning; ignored
  51 # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
  52 #endif
  53
  54 namespace boost { namespace proto
  55 {
  56 /// INTERNAL ONLY
  57 ///
  58 #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA)                                                   \
  59     typename boost::proto::detail::protoify<                                                    \
  60         BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N)                                        \
  61       , BOOST_PP_TUPLE_ELEM(3, 2, DATA)                                                         \
  62     >::result_type                                                                              \
  63     /**/
  64
  65 /// INTERNAL ONLY
  66 ///
  67 #define BOOST_PROTO_AS_CHILD(Z, N, DATA)                                                        \
  68     boost::proto::detail::protoify<                                                             \
  69         BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N)                                        \
  70       , BOOST_PP_TUPLE_ELEM(3, 2, DATA)                                                         \
  71     >()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N))                                       \
  72     /**/
  73
  74     namespace detail
  75     {
  76         template<typename T, typename Domain>
  77         struct protoify
  78           : Domain::template as_expr<T>
  79         {};
  80
  81         template<typename T, typename Domain>
  82         struct protoify<T &, Domain>
  83           : Domain::template as_child<T>
  84         {};
  85
  86         template<typename T, typename Domain>
  87         struct protoify<boost::reference_wrapper<T>, Domain>
  88           : Domain::template as_child<T>
  89         {};
  90
  91         template<typename T, typename Domain>
  92         struct protoify<boost::reference_wrapper<T> const, Domain>
  93           : Domain::template as_child<T>
  94         {};
  95
  96         // Definition of detail::unpack_expr_
  97         #include <boost/proto/detail/unpack_expr_.hpp>
  98
  99         // Definition of detail::make_expr_
 100         #include <boost/proto/detail/make_expr_.hpp>
 101     }
 102
 103     namespace result_of
 104     {
 105         /// \brief Metafunction that computes the return type of the
 106         /// \c make_expr() function, with a domain deduced from the
 107         /// domains of the children.
 108         ///
 109         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to
 110         /// compute the return type of the \c make_expr() function.
 111         ///
 112         /// In this specialization, the domain is deduced from the
 113         /// domains of the child types. (If
 114         /// <tt>is_domain\<A0\>::value</tt> is \c true, then another
 115         /// specialization is selected.)
 116         template<
 117             typename Tag
 118           , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
 119           , typename Void1  // = void
 120           , typename Void2  // = void
 121         >
 122         struct make_expr
 123         {
 124             /// Same as <tt>result_of::make_expr\<Tag, D, A0, ... AN\>::type</tt>
 125             /// where \c D is the deduced domain, which is calculated as follows:
 126             ///
 127             /// For each \c x in <tt>[0,N)</tt> (proceeding in order beginning with
 128             /// <tt>x=0</tt>), if <tt>domain_of\<Ax\>::type</tt> is not
 129             /// \c default_domain, then \c D is <tt>domain_of\<Ax\>::type</tt>.
 130             /// Otherwise, \c D is \c default_domain.
 131             typedef
 132                 typename detail::make_expr_<
 133                     Tag
 134                   , deduce_domain
 135                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
 136                 >::result_type
 137             type;
 138         };
 139
 140         /// \brief Metafunction that computes the return type of the
 141         /// \c make_expr() function, within the specified domain.
 142         ///
 143         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
 144         /// the return type of the \c make_expr() function.
 145         template<
 146             typename Tag
 147           , typename Domain
 148             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
 149         >
 150         struct make_expr<
 151             Tag
 152           , Domain
 153             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
 154           , typename Domain::proto_is_domain_
 155         >
 156         {
 157             /// If \c Tag is <tt>tag::terminal</tt>, then \c type is a
 158             /// typedef for <tt>boost::result_of\<Domain(expr\<tag::terminal,
 159             /// term\<A0\> \>)\>::type</tt>.
 160             ///
 161             /// Otherwise, \c type is a typedef for <tt>boost::result_of\<Domain(expr\<Tag,
 162             /// listN\< as_child\<A0\>::type, ... as_child\<AN\>::type\>)
 163             /// \>::type</tt>, where \c N is the number of non-void template
 164             /// arguments, and <tt>as_child\<A\>::type</tt> is evaluated as
 165             /// follows:
 166             ///
 167             /// \li If <tt>is_expr\<A\>::value</tt> is \c true, then the
 168             /// child type is \c A.
 169             /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
 170             /// and <tt>is_expr\<B\>::value</tt> is \c true, then the
 171             /// child type is <tt>B &</tt>.
 172             /// \li If <tt>is_expr\<A\>::value</tt> is \c false, then the
 173             /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<A\> \>
 174             /// )\>::type</tt>.
 175             /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
 176             /// and <tt>is_expr\<B\>::value</tt> is \c false, then the
 177             /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<B &\> \>
 178             /// )\>::type</tt>.
 179             typedef
 180                 typename detail::make_expr_<
 181                     Tag
 182                   , Domain
 183                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
 184                 >::result_type
 185             type;
 186         };
 187
 188         /// \brief Metafunction that computes the return type of the
 189         /// \c unpack_expr() function, with a domain deduced from the
 190         /// domains of the children.
 191         ///
 192         /// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to
 193         /// compute the return type of the \c unpack_expr() function.
 194         ///
 195         /// \c Sequence is a Fusion Forward Sequence.
 196         ///
 197         /// In this specialization, the domain is deduced from the
 198         /// domains of the child types. (If
 199         /// <tt>is_domain\<Sequence>::value</tt> is \c true, then another
 200         /// specialization is selected.)
 201         template<
 202             typename Tag
 203           , typename Sequence
 204           , typename Void1  // = void
 205           , typename Void2  // = void
 206         >
 207         struct unpack_expr
 208         {
 209             /// Let \c S be the type of a Fusion Random Access Sequence
 210             /// equivalent to \c Sequence. Then \c type is the
 211             /// same as <tt>result_of::make_expr\<Tag,
 212             /// fusion::result_of::value_at_c\<S, 0\>::type, ...
 213             /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
 214             /// where \c N is the size of \c S.
 215             typedef
 216                 typename detail::unpack_expr_<
 217                     Tag
 218                   , deduce_domain
 219                   , Sequence
 220                   , fusion::result_of::size<Sequence>::type::value
 221                 >::type
 222             type;
 223         };
 224
 225         /// \brief Metafunction that computes the return type of the
 226         /// \c unpack_expr() function, within the specified domain.
 227         ///
 228         /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
 229         /// the return type of the \c make_expr() function.
 230         template<typename Tag, typename Domain, typename Sequence>
 231         struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_>
 232         {
 233             /// Let \c S be the type of a Fusion Random Access Sequence
 234             /// equivalent to \c Sequence. Then \c type is the
 235             /// same as <tt>result_of::make_expr\<Tag, Domain,
 236             /// fusion::result_of::value_at_c\<S, 0\>::type, ...
 237             /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
 238             /// where \c N is the size of \c S.
 239             typedef
 240                 typename detail::unpack_expr_<
 241                     Tag
 242                   , Domain
 243                   , Sequence
 244                   , fusion::result_of::size<Sequence>::type::value
 245                 >::type
 246             type;
 247         };
 248     }
 249
 250     namespace functional
 251     {
 252         /// \brief A callable function object equivalent to the
 253         /// \c proto::make_expr() function.
 254         ///
 255         /// In all cases, <tt>functional::make_expr\<Tag, Domain\>()(a0, ... aN)</tt>
 256         /// is equivalent to <tt>proto::make_expr\<Tag, Domain\>(a0, ... aN)</tt>.
 257         ///
 258         /// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt>
 259         /// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>.
 260         template<typename Tag, typename Domain  /* = deduce_domain*/>
 261         struct make_expr
 262         {
 263             BOOST_PROTO_CALLABLE()
 264             BOOST_PROTO_POLY_FUNCTION()
 265
 266             template<typename Sig>
 267             struct result;
 268
 269             template<typename This, typename A0>
 270             struct result<This(A0)>
 271             {
 272                 typedef
 273                     typename result_of::make_expr<
 274                         Tag
 275                       , Domain
 276                       , A0
 277                     >::type
 278                 type;
 279             };
 280
 281             /// Construct an expression node with tag type \c Tag
 282             /// and in the domain \c Domain.
 283             ///
 284             /// \return <tt>proto::make_expr\<Tag, Domain\>(a0,...aN)</tt>
 285             template<typename A0>
 286             BOOST_FORCEINLINE
 287             typename result_of::make_expr<
 288                 Tag
 289               , Domain
 290               , A0 const
 291             >::type const
 292             operator ()(A0 const &a0) const
 293             {
 294                 return proto::detail::make_expr_<
 295                     Tag
 296                   , Domain
 297                   , A0 const
 298                 >()(a0);
 299             }
 300
 301             // Additional overloads generated by the preprocessor ...
 302             #include <boost/proto/detail/make_expr_funop.hpp>
 303
 304             /// INTERNAL ONLY
 305             ///
 306             template<
 307                 BOOST_PP_ENUM_BINARY_PARAMS(
 308                     BOOST_PROTO_MAX_ARITY
 309                   , typename A
 310                   , = void BOOST_PP_INTERCEPT
 311                 )
 312             >
 313             struct impl
 314               : detail::make_expr_<
 315                     Tag
 316                   , Domain
 317                     BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
 318                 >
 319             {};
 320         };
 321
 322         /// \brief A callable function object equivalent to the
 323         /// \c proto::unpack_expr() function.
 324         ///
 325         /// In all cases, <tt>functional::unpack_expr\<Tag, Domain\>()(seq)</tt>
 326         /// is equivalent to <tt>proto::unpack_expr\<Tag, Domain\>(seq)</tt>.
 327         ///
 328         /// <tt>functional::unpack_expr\<Tag\>()(seq)</tt>
 329         /// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>.
 330         template<typename Tag, typename Domain /* = deduce_domain*/>
 331         struct unpack_expr
 332         {
 333             BOOST_PROTO_CALLABLE()
 334
 335             template<typename Sig>
 336             struct result;
 337
 338             template<typename This, typename Sequence>
 339             struct result<This(Sequence)>
 340             {
 341                 typedef
 342                     typename result_of::unpack_expr<
 343                         Tag
 344                       , Domain
 345                       , typename remove_reference<Sequence>::type
 346                     >::type
 347                 type;
 348             };
 349
 350             /// Construct an expression node with tag type \c Tag
 351             /// and in the domain \c Domain.
 352             ///
 353             /// \param sequence A Fusion Forward Sequence
 354             /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt>
 355             template<typename Sequence>
 356             BOOST_FORCEINLINE
 357             typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const
 358             operator ()(Sequence const &sequence) const
 359             {
 360                 return proto::detail::unpack_expr_<
 361                     Tag
 362                   , Domain
 363                   , Sequence const
 364                   , fusion::result_of::size<Sequence>::type::value
 365                 >::call(sequence);
 366             }
 367         };
 368
 369     } // namespace functional
 370
 371     /// \brief Construct an expression of the requested tag type
 372     /// with a domain and with the specified arguments as children.
 373     ///
 374     /// This function template may be invoked either with or without
 375     /// specifying a \c Domain argument. If no domain is specified,
 376     /// the domain is deduced by examining in order the domains of
 377     /// the given arguments and taking the first that is not
 378     /// \c default_domain, if any such domain exists, or
 379     /// \c default_domain otherwise.
 380     ///
 381     /// Let \c wrap_(x) be defined such that:
 382     /// \li If \c x is a <tt>boost::reference_wrapper\<\></tt>,
 383     /// \c wrap_(x) is equivalent to <tt>as_child\<Domain\>(x.get())</tt>.
 384     /// \li Otherwise, \c wrap_(x) is equivalent to
 385     /// <tt>as_expr\<Domain\>(x)</tt>.
 386     ///
 387     /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
 388     /// <tt>expr\<Tag, listN\<C0,...CN\> \>::make(c0,...cN)</tt>
 389     /// where \c Bx is the type of \c bx.
 390     ///
 391     /// \return <tt>Domain()(make_\<Tag\>(wrap_(a0),...wrap_(aN)))</tt>.
 392     template<typename Tag, typename A0>
 393     BOOST_FORCEINLINE
 394     typename lazy_disable_if<
 395         is_domain<A0>
 396       , result_of::make_expr<
 397             Tag
 398           , A0 const
 399         >
 400     >::type const
 401     make_expr(A0 const &a0)
 402     {
 403         return proto::detail::make_expr_<
 404             Tag
 405           , deduce_domain
 406           , A0 const
 407         >()(a0);
 408     }
 409
 410     /// \overload
 411     ///
 412     template<typename Tag, typename Domain, typename C0>
 413     BOOST_FORCEINLINE
 414     typename result_of::make_expr<
 415         Tag
 416       , Domain
 417       , C0 const
 418     >::type const
 419     make_expr(C0 const &c0)
 420     {
 421         return proto::detail::make_expr_<
 422             Tag
 423           , Domain
 424           , C0 const
 425         >()(c0);
 426     }
 427
 428     // Additional overloads generated by the preprocessor...
 429     #include <boost/proto/detail/make_expr.hpp>
 430
 431     /// \brief Construct an expression of the requested tag type
 432     /// with a domain and with childres from the specified Fusion
 433     /// Forward Sequence.
 434     ///
 435     /// This function template may be invoked either with or without
 436     /// specifying a \c Domain argument. If no domain is specified,
 437     /// the domain is deduced by examining in order the domains of the
 438     /// elements of \c sequence and taking the first that is not
 439     /// \c default_domain, if any such domain exists, or
 440     /// \c default_domain otherwise.
 441     ///
 442     /// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence.
 443     /// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined
 444     /// such that:
 445     /// \li If <tt>fusion::result_of::value_at_c\<S,N\>::type</tt> is a reference,
 446     /// <tt>wrap_\<N\>(s)</tt> is equivalent to
 447     /// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>.
 448     /// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to
 449     /// <tt>as_expr\<Domain\>(fusion::at_c\<N\>(s))</tt>.
 450     ///
 451     /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
 452     /// <tt>expr\<Tag, listN\<B0,...BN\> \>::make(b0,...bN)</tt>
 453     /// where \c Bx is the type of \c bx.
 454     ///
 455     /// \param sequence a Fusion Forward Sequence.
 456     /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>,
 457     /// where N is the size of \c Sequence.
 458     template<typename Tag, typename Sequence>
 459     BOOST_FORCEINLINE
 460     typename lazy_disable_if<
 461         is_domain<Sequence>
 462       , result_of::unpack_expr<Tag, Sequence const>
 463     >::type const
 464     unpack_expr(Sequence const &sequence)
 465     {
 466         return proto::detail::unpack_expr_<
 467             Tag
 468           , deduce_domain
 469           , Sequence const
 470           , fusion::result_of::size<Sequence>::type::value
 471         >::call(sequence);
 472     }
 473
 474     /// \overload
 475     ///
 476     template<typename Tag, typename Domain, typename Sequence2>
 477     BOOST_FORCEINLINE
 478     typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const
 479     unpack_expr(Sequence2 const &sequence2)
 480     {
 481         return proto::detail::unpack_expr_<
 482             Tag
 483           , Domain
 484           , Sequence2 const
 485           , fusion::result_of::size<Sequence2>::type::value
 486         >::call(sequence2);
 487     }
 488
 489     /// INTERNAL ONLY
 490     ///
 491     template<typename Tag, typename Domain>
 492     struct is_callable<functional::make_expr<Tag, Domain> >
 493       : mpl::true_
 494     {};
 495
 496     /// INTERNAL ONLY
 497     ///
 498     template<typename Tag, typename Domain>
 499     struct is_callable<functional::unpack_expr<Tag, Domain> >
 500       : mpl::true_
 501     {};
 502
 503 }}
 504
 505 #if defined(_MSC_VER)
 506 # pragma warning(pop)
 507 #endif
 508
 509 #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005