mirror of http://192.168.1.51:8099/lmh188/twain3.0
830 lines
51 KiB
C++
830 lines
51 KiB
C++
// 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
|