EIC code displayed by LXR master/​include/​boost/​yap/​user_macros.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:53:56

 // Copyright (C) 2016-2018 T. Zachary Laine
 //
 // 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_YAP_USER_MACROS_HPP_INCLUDED
 #define BOOST_YAP_USER_MACROS_HPP_INCLUDED
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 
 
 #ifndef BOOST_YAP_DOXYGEN
 
 // unary
 #define BOOST_YAP_OPERATOR_unary_plus(...) +(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_negate(...) -(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_dereference(...) *(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_complement(...) ~(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_address_of(...) &(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_logical_not(...) !(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_pre_inc(...) ++(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_pre_dec(...) --(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_post_inc(...) ++(__VA_ARGS__, int)
 #define BOOST_YAP_OPERATOR_post_dec(...) --(__VA_ARGS__, int)
 
 // binary
 #define BOOST_YAP_OPERATOR_shift_left(...) <<(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_shift_right(...) >>(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_multiplies(...) *(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_divides(...) /(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_modulus(...) %(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_plus(...) +(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_minus(...) -(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_less(...) <(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_greater(...) >(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_less_equal(...) <=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_greater_equal(...) >=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_equal_to(...) ==(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_not_equal_to(...) !=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_logical_or(...) ||(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_logical_and(...) &&(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_and(...) &(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_or(...) |(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_xor(...) ^(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_comma(...) ,(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_mem_ptr(...) ->*(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_assign(...) =(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_shift_left_assign(...) <<=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_shift_right_assign(...) >>=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_multiplies_assign(...) *=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_divides_assign(...) /=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_modulus_assign(...) %=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_plus_assign(...) +=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_minus_assign(...) -=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_and_assign(...) &=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_or_assign(...) |=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_bitwise_xor_assign(...) ^=(__VA_ARGS__)
 #define BOOST_YAP_OPERATOR_subscript(...) [](__VA_ARGS__)
 
 #define BOOST_YAP_INDIRECT_CALL(macro) BOOST_PP_CAT(BOOST_YAP_OPERATOR_, macro)
 
 #endif // BOOST_YAP_DOXYGEN
 
 
 /** Defines operator overloads for unary operator \a op_name that each take an
     expression instantiated from \a expr_template and return an expression
     instantiated from the \a result_expr_template expression template.  One
     overload is defined for each of the qualifiers <code>const &</code>,
     <code>&</code>, and <code>&&</code>.  For the lvalue reference overloads,
     the argument is captured by reference into the resulting expression.  For
     the rvalue reference overload, the argument is moved into the resulting
     expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_UNARY_OPERATOR
 
     \param op_name The operator to be overloaded; this must be one of the \b
     unary enumerators in <code>expr_kind</code>, without the
     <code>expr_kind::</code> qualification.
 
     \param expr_template The expression template to which the overloads apply.
     \a expr_template must be an \ref ExpressionTemplate.
 
     \param result_expr_template The expression template to use to instantiate
     the result expression.  \a result_expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_UNARY_OPERATOR(                                         \
     op_name, expr_template, result_expr_template)                              \
     template<::boost::yap::expr_kind Kind, typename Tuple>                     \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> const & x)                                  \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::operand_type_t<                 \
             result_expr_template,                                              \
             expr_template<Kind, Tuple> const &>;                               \
         using tuple_type = ::boost::hana::tuple<lhs_type>;                     \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{                                                       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(x)}};    \
     }                                                                          \
     template<::boost::yap::expr_kind Kind, typename Tuple>                     \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> & x)                                        \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::operand_type_t<                 \
             result_expr_template,                                              \
             expr_template<Kind, Tuple> &>;                                     \
         using tuple_type = ::boost::hana::tuple<lhs_type>;                     \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{                                                       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(x)}};    \
     }                                                                          \
     template<::boost::yap::expr_kind Kind, typename Tuple>                     \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> && x)                                       \
     {                                                                          \
         using tuple_type = ::boost::hana::tuple<expr_template<Kind, Tuple>>;   \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{tuple_type{std::move(x)}};                             \
     }
 
 
 /** Defines operator overloads for binary operator \a op_name that each
     produce an expression instantiated from the \a expr_template expression
     template.  One overload is defined for each of the qualifiers <code>const
     &</code>, <code>&</code>, and <code>&&</code>.  For the lvalue reference
     overloads, <code>*this</code> is captured by reference into the resulting
     expression.  For the rvalue reference overload, <code>*this</code> is
     moved into the resulting expression.
 
     Note that this does not work for yap::expr_kinds assign, subscript, or
     call.  Use BOOST_YAP_USER_ASSIGN_OPERATOR,
     BOOST_YAP_USER_SUBSCRIPT_OPERATOR, or BOOST_YAP_USER_CALL_OPERATOR for
     those, respectively.
 
     Example:
     \snippet user_macros_snippets.cpp USER_BINARY_OPERATOR
 
     \param op_name The operator to be overloaded; this must be one of the \b
     binary enumerators in <code>expr_kind</code>, except assign, subscript, or
     call, without the <code>expr_kind::</code> qualification.
 
     \param expr_template The expression template to which the overloads apply.
     \a expr_template must be an \ref ExpressionTemplate.
 
     \param result_expr_template The expression template to use to instantiate
     the result expression.  \a result_expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_BINARY_OPERATOR(                                        \
     op_name, expr_template, result_expr_template)                              \
     template<::boost::yap::expr_kind Kind, typename Tuple, typename Expr>      \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> const & lhs, Expr && rhs)                   \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::operand_type_t<                 \
             result_expr_template,                                              \
             expr_template<Kind, Tuple> const &>;                               \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<result_expr_template, Expr>;  \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{                                                       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(lhs),    \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<::boost::yap::expr_kind Kind, typename Tuple, typename Expr>      \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> & lhs, Expr && rhs)                         \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::operand_type_t<                 \
             result_expr_template,                                              \
             expr_template<Kind, Tuple> &>;                                     \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<result_expr_template, Expr>;  \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{                                                       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(lhs),    \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<::boost::yap::expr_kind Kind, typename Tuple, typename Expr>      \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         expr_template<Kind, Tuple> && lhs, Expr && rhs)                        \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::remove_cv_ref_t<                \
             expr_template<Kind, Tuple> &&>;                                    \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<result_expr_template, Expr>;  \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return result_expr_template<                                           \
             ::boost::yap::expr_kind::op_name,                                  \
             tuple_type>{                                                       \
             tuple_type{std::move(lhs),                                         \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<typename T, ::boost::yap::expr_kind Kind, typename Tuple>         \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         T && lhs, expr_template<Kind, Tuple> && rhs)                           \
         ->::boost::yap::detail::free_binary_op_result_t<                       \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> &&>                                     \
     {                                                                          \
         using result_types = ::boost::yap::detail::free_binary_op_result<      \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> &&>;                                    \
         using lhs_type = typename result_types::lhs_type;                      \
         using rhs_type = typename result_types::rhs_type;                      \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return {tuple_type{lhs_type{static_cast<T &&>(lhs)}, std::move(rhs)}}; \
     }                                                                          \
     template<typename T, ::boost::yap::expr_kind Kind, typename Tuple>         \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         T && lhs, expr_template<Kind, Tuple> const & rhs)                      \
         ->::boost::yap::detail::free_binary_op_result_t<                       \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> const &>                                \
     {                                                                          \
         using result_types = ::boost::yap::detail::free_binary_op_result<      \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> const &>;                               \
         using lhs_type = typename result_types::lhs_type;                      \
         using rhs_type = typename result_types::rhs_type;                      \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         using rhs_tuple_type = typename result_types::rhs_tuple_type;          \
         return {tuple_type{lhs_type{static_cast<T &&>(lhs)},                   \
                            rhs_type{rhs_tuple_type{std::addressof(rhs)}}}};    \
     }                                                                          \
     template<typename T, ::boost::yap::expr_kind Kind, typename Tuple>         \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(                  \
         T && lhs, expr_template<Kind, Tuple> & rhs)                            \
         ->::boost::yap::detail::free_binary_op_result_t<                       \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> &>                                      \
     {                                                                          \
         using result_types = ::boost::yap::detail::free_binary_op_result<      \
             result_expr_template,                                              \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             expr_template<Kind, Tuple> &>;                                     \
         using lhs_type = typename result_types::lhs_type;                      \
         using rhs_type = typename result_types::rhs_type;                      \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         using rhs_tuple_type = typename result_types::rhs_tuple_type;          \
         return {tuple_type{lhs_type{static_cast<T &&>(lhs)},                   \
                            rhs_type{rhs_tuple_type{std::addressof(rhs)}}}};    \
     }
 
 
 /** Defines operator overloads for \a operator=() that each produce an
     expression instantiated from the \a expr_template expression template.
     One overload is defined for each of the qualifiers <code>const &</code>,
     <code>&</code>, and <code>&&</code>.  For the lvalue reference overloads,
     <code>*this</code> is captured by reference into the resulting expression.
     For the rvalue reference overload, <code>*this</code> is moved into the
     resulting expression.
 
     The \a rhs parameter to each of the defined overloads may be any type,
     including an expression, except that the overloads are constrained by
     std::enable_if<> not to conflict with the assignment and move assignement
     operators.  If \a rhs is a non-expression, it is wrapped in a terminal
     expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_ASSIGN_OPERATOR
 
     \param this_type The type of the class the operator is a member of; this
     is required to avoid clashing with the assignment and move assignement
     operators.
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_ASSIGN_OPERATOR(this_type, expr_template)               \
     template<                                                                  \
         typename Expr,                                                         \
         typename = std::enable_if_t<                                           \
             !::boost::yap::detail::copy_or_move<this_type, Expr &&>::value>>   \
     constexpr auto operator=(Expr && rhs) const &                              \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, this_type const &>;                  \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return expr_template<::boost::yap::expr_kind::assign, tuple_type>{     \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<                                                                  \
         typename Expr,                                                         \
         typename = std::enable_if_t<                                           \
             !::boost::yap::detail::copy_or_move<this_type, Expr &&>::value>>   \
     constexpr auto operator=(Expr && rhs) &                                    \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return expr_template<::boost::yap::expr_kind::assign, tuple_type>{     \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<                                                                  \
         typename Expr,                                                         \
         typename = std::enable_if_t<                                           \
             !::boost::yap::detail::copy_or_move<this_type, Expr &&>::value>>   \
     constexpr auto operator=(Expr && rhs) &&                                   \
     {                                                                          \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<this_type, rhs_type>;          \
         return expr_template<::boost::yap::expr_kind::assign, tuple_type>{     \
             tuple_type{std::move(*this),                                       \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }
 
 
 /** Defines operator overloads for \a operator[]() that each produce an
     expression instantiated from the \a expr_template expression template.
     One overload is defined for each of the qualifiers <code>const &</code>,
     <code>&</code>, and <code>&&</code>.  For the lvalue reference overloads,
     <code>*this</code> is captured by reference into the resulting expression.
     For the rvalue reference overload, <code>*this</code> is moved into the
     resulting expression.
 
     The \a rhs parameter to each of the defined overloads may be any type,
     including an expression, except that the overloads are constrained by
     std::enable_if<> not to conflict with the assignment and move assignement
     operators.  If \a rhs is a non-expression, it is wrapped in a terminal
     expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_SUBSCRIPT_OPERATOR
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_SUBSCRIPT_OPERATOR(expr_template)                       \
     template<typename Expr>                                                    \
     constexpr auto operator[](Expr && rhs) const &                             \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return expr_template<::boost::yap::expr_kind::subscript, tuple_type>{  \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<typename Expr>                                                    \
     constexpr auto operator[](Expr && rhs) &                                   \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return expr_template<::boost::yap::expr_kind::subscript, tuple_type>{  \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }                                                                          \
     template<typename Expr>                                                    \
     constexpr auto operator[](Expr && rhs) &&                                  \
     {                                                                          \
         using lhs_type =                                                       \
             ::boost::yap::detail::remove_cv_ref_t<decltype(*this)>;            \
         using rhs_type =                                                       \
             ::boost::yap::detail::operand_type_t<expr_template, Expr>;         \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return expr_template<::boost::yap::expr_kind::subscript, tuple_type>{  \
             tuple_type{std::move(*this),                                       \
                        ::boost::yap::detail::make_operand<rhs_type>{}(         \
                            static_cast<Expr &&>(rhs))}};                       \
     }
 
 
 /** Defines operator overloads for the call operator taking any number of
     parameters ("operator()") that each produce an expression instantiated
     from the \a expr_template expression template.  One overload is defined
     for each of the qualifiers <code>const &</code>, <code>&</code>, and
     <code>&&</code>.  For the lvalue reference overloads, <code>*this</code>
     is captured by reference into the resulting expression.  For the rvalue
     reference overload, <code>*this</code> is moved into the resulting
     expression.
 
     The \a u parameters to each of the defined overloads may be any type,
     including an expression.  Each non-expression is wrapped in a terminal
     expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_CALL_OPERATOR
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_CALL_OPERATOR(expr_template)                            \
     template<typename... U>                                                    \
     constexpr auto operator()(U &&... u) const &                               \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using tuple_type = ::boost::hana::tuple<                               \
             lhs_type,                                                          \
             ::boost::yap::detail::operand_type_t<expr_template, U>...>;        \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{                                                        \
                 ::boost::yap::detail::make_operand<lhs_type>{}(*this),         \
                 ::boost::yap::detail::make_operand<                            \
                     ::boost::yap::detail::operand_type_t<expr_template, U>>{}( \
                     static_cast<U &&>(u))...}};                                \
     }                                                                          \
     template<typename... U>                                                    \
     constexpr auto operator()(U &&... u) &                                     \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using tuple_type = ::boost::hana::tuple<                               \
             lhs_type,                                                          \
             ::boost::yap::detail::operand_type_t<expr_template, U>...>;        \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{                                                        \
                 ::boost::yap::detail::make_operand<lhs_type>{}(*this),         \
                 ::boost::yap::detail::make_operand<                            \
                     ::boost::yap::detail::operand_type_t<expr_template, U>>{}( \
                     static_cast<U &&>(u))...}};                                \
     }                                                                          \
     template<typename... U>                                                    \
     constexpr auto operator()(U &&... u) &&                                    \
     {                                                                          \
         using this_type =                                                      \
             ::boost::yap::detail::remove_cv_ref_t<decltype(*this)>;            \
         using tuple_type = ::boost::hana::tuple<                               \
             this_type,                                                         \
             ::boost::yap::detail::operand_type_t<expr_template, U>...>;        \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{                                                        \
                 std::move(*this),                                              \
                 ::boost::yap::detail::make_operand<                            \
                     ::boost::yap::detail::operand_type_t<expr_template, U>>{}( \
                     static_cast<U &&>(u))...}};                                \
     }
 
 
 #ifndef BOOST_YAP_DOXYGEN
 
 #define BOOST_YAP_USER_CALL_OPERATOR_OPERAND_T(z, n, expr_template)            \
     ::boost::yap::detail::operand_type_t<expr_template, BOOST_PP_CAT(U, n)>
 #define BOOST_YAP_USER_CALL_OPERATOR_MAKE_OPERAND(z, n, expr_template)         \
     ::boost::yap::detail::make_operand<::boost::yap::detail::operand_type_t<   \
         expr_template,                                                         \
         BOOST_PP_CAT(U, n)>>{}(                                                \
         static_cast<BOOST_PP_CAT(U, n) &&>(BOOST_PP_CAT(u, n)))
 
 #endif
 
 /** Defines operator overloads for the call operator taking N parameters
     ("operator()(t0, t1, ... tn-1)") that each produce an expression
     instantiated from the \a expr_template expression template.  One overload
     is defined for each of the qualifiers <code>const &</code>,
     <code>&</code>, and <code>&&</code>.  For the lvalue reference overloads,
     <code>*this</code> is captured by reference into the resulting expression.
     For the rvalue reference overload, <code>*this</code> is moved into the
     resulting expression.
 
     The \a u parameters to each of the defined overloads may be any type,
     including an expression.  Each non-expression is wrapped in a terminal
     expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_CALL_OPERATOR
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 
     \param n The number of parameters accepted by the operator() overloads.  n
     must be <= BOOST_PP_LIMIT_REPEAT.
 */
 #define BOOST_YAP_USER_CALL_OPERATOR_N(expr_template, n)                       \
     template<BOOST_PP_ENUM_PARAMS(n, typename U)>                              \
     constexpr auto operator()(BOOST_PP_ENUM_BINARY_PARAMS(n, U, &&u)) const &  \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using tuple_type = ::boost::hana::tuple<                               \
             lhs_type,                                                          \
             BOOST_PP_ENUM(                                                     \
                 n, BOOST_YAP_USER_CALL_OPERATOR_OPERAND_T, expr_template)>;    \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        BOOST_PP_ENUM(                                          \
                            n,                                                  \
                            BOOST_YAP_USER_CALL_OPERATOR_MAKE_OPERAND,          \
                            expr_template)}};                                   \
     }                                                                          \
     template<BOOST_PP_ENUM_PARAMS(n, typename U)>                              \
     constexpr auto operator()(BOOST_PP_ENUM_BINARY_PARAMS(n, U, &&u)) &        \
     {                                                                          \
         using lhs_type = ::boost::yap::detail::                                \
             operand_type_t<expr_template, decltype(*this)>;                    \
         using tuple_type = ::boost::hana::tuple<                               \
             lhs_type,                                                          \
             BOOST_PP_ENUM(                                                     \
                 n, BOOST_YAP_USER_CALL_OPERATOR_OPERAND_T, expr_template)>;    \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{::boost::yap::detail::make_operand<lhs_type>{}(*this),  \
                        BOOST_PP_ENUM(                                          \
                            n,                                                  \
                            BOOST_YAP_USER_CALL_OPERATOR_MAKE_OPERAND,          \
                            expr_template)}};                                   \
     }                                                                          \
     template<BOOST_PP_ENUM_PARAMS(n, typename U)>                              \
     constexpr auto operator()(BOOST_PP_ENUM_BINARY_PARAMS(n, U, &&u)) &&       \
     {                                                                          \
         using this_type =                                                      \
             ::boost::yap::detail::remove_cv_ref_t<decltype(*this)>;            \
         using tuple_type = ::boost::hana::tuple<                               \
             this_type,                                                         \
             BOOST_PP_ENUM(                                                     \
                 n, BOOST_YAP_USER_CALL_OPERATOR_OPERAND_T, expr_template)>;    \
         return expr_template<::boost::yap::expr_kind::call, tuple_type>{       \
             tuple_type{std::move(*this),                                       \
                        BOOST_PP_ENUM(                                          \
                            n,                                                  \
                            BOOST_YAP_USER_CALL_OPERATOR_MAKE_OPERAND,          \
                            expr_template)}};                                   \
     }
 
 
 /** Defines a 3-parameter function <code>if_else()</code> that acts as an
     analogue to the ternary operator (<code>?:</code>), since the ternary
     operator is not user-overloadable.  The return type of
     <code>if_else()</code> is an expression instantiated from the \a
     expr_template expression template.
 
     At least one parameter to <code>if_else()</code> must be an expression.
 
     For each parameter E passed to <code>if_else()</code>, if E is an rvalue,
     E is moved into the result, and otherwise E is captured by reference into
     the result.
 
     Example:
     \snippet user_macros_snippets.cpp USER_EXPR_IF_ELSE
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_EXPR_IF_ELSE(expr_template)                             \
     template<typename Expr1, typename Expr2, typename Expr3>                   \
     constexpr auto if_else(Expr1 && expr1, Expr2 && expr2, Expr3 && expr3)     \
         ->::boost::yap::detail::                                               \
             ternary_op_result_t<expr_template, Expr1, Expr2, Expr3>            \
     {                                                                          \
         using result_types = ::boost::yap::detail::                            \
             ternary_op_result<expr_template, Expr1, Expr2, Expr3>;             \
         using cond_type = typename result_types::cond_type;                    \
         using then_type = typename result_types::then_type;                    \
         using else_type = typename result_types::else_type;                    \
         using tuple_type =                                                     \
             ::boost::hana::tuple<cond_type, then_type, else_type>;             \
         return {tuple_type{::boost::yap::detail::make_operand<cond_type>{}(    \
                                static_cast<Expr1 &&>(expr1)),                  \
                            ::boost::yap::detail::make_operand<then_type>{}(    \
                                static_cast<Expr2 &&>(expr2)),                  \
                            ::boost::yap::detail::make_operand<else_type>{}(    \
                                static_cast<Expr3 &&>(expr3))}};                \
     }
 
 
 /** Defines a function <code>if_else()</code> that acts as an analogue to the
     ternary operator (<code>?:</code>), since the ternary operator is not
     user-overloadable.  The return type of <code>if_else()</code> is an
     expression instantiated from the \a expr_template expression template.
 
     Each parameter to <code>if_else()</code> may be any type that is \b not an
     expression.  At least on parameter must be a type <code>T</code> for which
     \code udt_trait<std::remove_cv_t<std::remove_reference_t<T>>>::value
     \endcode is true.  Each parameter is wrapped in a terminal expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_UDT_ANY_IF_ELSE
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 
     \param udt_trait A trait template to use to constrain which types are
     accepted as template parameters to <code>if_else()</code>.
 */
 #define BOOST_YAP_USER_UDT_ANY_IF_ELSE(expr_template, udt_trait)               \
     template<typename Expr1, typename Expr2, typename Expr3>                   \
     constexpr auto if_else(Expr1 && expr1, Expr2 && expr2, Expr3 && expr3)     \
         ->::boost::yap::detail::udt_any_ternary_op_result_t<                   \
             expr_template,                                                     \
             Expr1,                                                             \
             Expr2,                                                             \
             Expr3,                                                             \
             udt_trait>                                                         \
     {                                                                          \
         using result_types = ::boost::yap::detail::udt_any_ternary_op_result<  \
             expr_template,                                                     \
             Expr1,                                                             \
             Expr2,                                                             \
             Expr3,                                                             \
             udt_trait>;                                                        \
         using cond_type = typename result_types::cond_type;                    \
         using then_type = typename result_types::then_type;                    \
         using else_type = typename result_types::else_type;                    \
         using tuple_type =                                                     \
             ::boost::hana::tuple<cond_type, then_type, else_type>;             \
         return {tuple_type{::boost::yap::detail::make_operand<cond_type>{}(    \
                                static_cast<Expr1 &&>(expr1)),                  \
                            ::boost::yap::detail::make_operand<then_type>{}(    \
                                static_cast<Expr2 &&>(expr2)),                  \
                            ::boost::yap::detail::make_operand<else_type>{}(    \
                                static_cast<Expr3 &&>(expr3))}};                \
     }
 
 
 /** Defines a free/non-member operator overload for unary operator \a op_name
     that produces an expression instantiated from the \a expr_template
     expression template.
 
     The parameter to the defined operator overload may be any type that is \b
     not an expression and for which \code
     udt_trait<std::remove_cv_t<std::remove_reference_t<T>>>::value \endcode is
     true.  The parameter is wrapped in a terminal expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_UDT_UNARY_OPERATOR
 
     \param op_name The operator to be overloaded; this must be one of the \b
     unary enumerators in <code>expr_kind</code>, without the
     <code>expr_kind::</code> qualification.
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 
     \param udt_trait A trait template to use to constrain which types are
     accepted as template parameters to the defined operator overload.
 */
 #define BOOST_YAP_USER_UDT_UNARY_OPERATOR(op_name, expr_template, udt_trait)   \
     template<typename T>                                                       \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(T && x)           \
         ->::boost::yap::detail::udt_unary_op_result_t<                         \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             udt_trait>                                                         \
     {                                                                          \
         using result_types = ::boost::yap::detail::udt_unary_op_result<        \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             udt_trait>;                                                        \
         using x_type = typename result_types::x_type;                          \
         using tuple_type = ::boost::hana::tuple<x_type>;                       \
         return {tuple_type{x_type{static_cast<T &&>(x)}}};                     \
     }
 
 
 /** Defines a free/non-member operator overload for binary operator \a op_name
     that produces an expression instantiated from the \a expr_template
     expression template.
 
     The \a lhs parameter to the defined operator overload may be any type that
     is \b not an expression and for which \code
     t_udt_trait<std::remove_cv_t<std::remove_reference_t<T>>>::value \endcode is
     true.  The parameter is wrapped in a terminal expression.
 
     The \a rhs parameter to the defined operator overload may be any type that
     is \b not an expression and for which \code
     u_udt_trait<std::remove_cv_t<std::remove_reference_t<U>>>::value \endcode is
     true.  The parameter is wrapped in a terminal expression.
 
     Example:
     \snippet user_macros_snippets.cpp USER_UDT_UDT_BINARY_OPERATOR
 
     \param op_name The operator to be overloaded; this must be one of the \b
     binary enumerators in <code>expr_kind</code>, without the
     <code>expr_kind::</code> qualification.
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 
     \param t_udt_trait A trait template to use to constrain which types are
     accepted as \a T template parameters to the defined operator overload.
 
     \param u_udt_trait A trait template to use to constrain which types are
     accepted as \a U template parameters to the defined operator overload.
 */
 #define BOOST_YAP_USER_UDT_UDT_BINARY_OPERATOR(                                \
     op_name, expr_template, t_udt_trait, u_udt_trait)                          \
     template<typename T, typename U>                                           \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(T && lhs, U && rhs) \
         ->::boost::yap::detail::udt_udt_binary_op_result_t<                    \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             U,                                                                 \
             t_udt_trait,                                                       \
             u_udt_trait>                                                       \
     {                                                                          \
         using result_types = ::boost::yap::detail::udt_udt_binary_op_result<   \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             U,                                                                 \
             t_udt_trait,                                                       \
             u_udt_trait>;                                                      \
         using lhs_type = typename result_types::lhs_type;                      \
         using rhs_type = typename result_types::rhs_type;                      \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return {tuple_type{                                                    \
             lhs_type{static_cast<T &&>(lhs)},                                  \
             rhs_type{static_cast<U &&>(rhs)},                                  \
         }};                                                                    \
     }
 
 
 /** Defines a free/non-member operator overload for binary operator \a op_name
     that produces an expression instantiated from the \a expr_template
     expression template.
 
     The \a lhs and \a rhs parameters to the defined operator overload may be any
    types that are \b not expressions.  Each parameter is wrapped in a terminal
    expression.
 
     At least one of the parameters to the defined operator overload must be a
     type \c T for which \code
     udt_trait<std::remove_cv_t<std::remove_reference_t<T>>>::value \endcode is
     true.
 
     Example:
     \snippet user_macros_snippets.cpp USER_UDT_ANY_BINARY_OPERATOR
 
     \param op_name The operator to be overloaded; this must be one of the \b
     binary enumerators in <code>expr_kind</code>, without the
     <code>expr_kind::</code> qualification.
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 
     \param udt_trait A trait template to use to constrain which types are
     accepted as template parameters to the defined operator overload.
 */
 #define BOOST_YAP_USER_UDT_ANY_BINARY_OPERATOR(                                \
     op_name, expr_template, udt_trait)                                         \
     template<typename T, typename U>                                           \
     constexpr auto operator BOOST_YAP_INDIRECT_CALL(op_name)(T && lhs, U && rhs) \
         ->::boost::yap::detail::udt_any_binary_op_result_t<                    \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             U,                                                                 \
             udt_trait>                                                         \
     {                                                                          \
         using result_types = ::boost::yap::detail::udt_any_binary_op_result<   \
             expr_template,                                                     \
             ::boost::yap::expr_kind::op_name,                                  \
             T,                                                                 \
             U,                                                                 \
             udt_trait>;                                                        \
         using lhs_type = typename result_types::lhs_type;                      \
         using rhs_type = typename result_types::rhs_type;                      \
         using tuple_type = ::boost::hana::tuple<lhs_type, rhs_type>;           \
         return {tuple_type{lhs_type{static_cast<T &&>(lhs)},                   \
                            rhs_type{static_cast<U &&>(rhs)}}};                 \
     }
 
 
 /** Defines user defined literal template that creates literal placeholders
     instantiated from the \a expr_template expression template.  It is
     recommended that you put this in its own namespace.
 
     \param expr_template The expression template to use to instantiate the
     result expression.  \a expr_template must be an \ref
     ExpressionTemplate.
 */
 #define BOOST_YAP_USER_LITERAL_PLACEHOLDER_OPERATOR(expr_template)             \
     template<char... c>                                                        \
     constexpr auto operator"" _p()                                             \
     {                                                                          \
         using i = ::boost::hana::llong<                                        \
             ::boost::hana::ic_detail::parse<sizeof...(c)>({c...})>;            \
         static_assert(1 <= i::value, "Placeholders must be >= 1.");            \
         return expr_template<                                                  \
             ::boost::yap::expr_kind::terminal,                                 \
             ::boost::hana::tuple<::boost::yap::placeholder<i::value>>>{};      \
     }
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team