mirror of
https://github.com/vdemydiuk/mtapi.git
synced 2026-08-15 03:38:09 +00:00
Added thirdparty: boost library
This commit is contained in:
Viacheslav Demydiuk
+591
@@ -0,0 +1,591 @@
|
||||
// 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_DETAIL_TRANSFORM_HPP_INCLUDED
|
||||
#define BOOST_YAP_DETAIL_TRANSFORM_HPP_INCLUDED
|
||||
|
||||
#include <boost/yap/algorithm_fwd.hpp>
|
||||
|
||||
#include <boost/hana/transform.hpp>
|
||||
|
||||
#include <cassert>
|
||||
|
||||
|
||||
namespace boost { namespace yap { namespace detail {
|
||||
|
||||
template<int I, typename T, typename... Ts>
|
||||
struct nth_element_impl
|
||||
{
|
||||
using type = typename nth_element_impl<I - 1, Ts...>::type;
|
||||
};
|
||||
|
||||
template<typename T, typename... Ts>
|
||||
struct nth_element_impl<0, T, Ts...>
|
||||
{
|
||||
using type = T;
|
||||
};
|
||||
|
||||
template<int I, typename... Ts>
|
||||
using nth_element = typename nth_element_impl<I, Ts...>::type;
|
||||
|
||||
template<typename T, bool RemoveRefs = std::is_rvalue_reference<T>::value>
|
||||
struct rvalue_ref_to_value;
|
||||
|
||||
template<typename T>
|
||||
struct rvalue_ref_to_value<T, true>
|
||||
{
|
||||
using type = typename std::remove_reference<T>::type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct rvalue_ref_to_value<T, false>
|
||||
{
|
||||
using type = T;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
using rvalue_ref_to_value_t = typename rvalue_ref_to_value<T>::type;
|
||||
|
||||
template<bool IsRvalueRef>
|
||||
struct rvalue_mover
|
||||
{
|
||||
template<typename T>
|
||||
constexpr decltype(auto) operator()(T && t) const
|
||||
{
|
||||
return static_cast<T &&>(t);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct rvalue_mover<true>
|
||||
{
|
||||
template<typename T>
|
||||
constexpr std::remove_reference_t<T> operator()(T && t) const
|
||||
{
|
||||
return std::move(t);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename... PlaceholderArgs>
|
||||
struct placeholder_transform_t
|
||||
{
|
||||
using tuple_t = hana::tuple<rvalue_ref_to_value_t<PlaceholderArgs>...>;
|
||||
|
||||
constexpr placeholder_transform_t(PlaceholderArgs &&... args) :
|
||||
placeholder_args_(static_cast<PlaceholderArgs &&>(args)...)
|
||||
{}
|
||||
|
||||
template<long long I>
|
||||
constexpr decltype(auto)
|
||||
operator()(expr_tag<expr_kind::terminal>, boost::yap::placeholder<I>) const
|
||||
{
|
||||
static_assert(
|
||||
I <= decltype(hana::size(std::declval<tuple_t>()))::value,
|
||||
"Out of range placeholder index,");
|
||||
using nth_type = nth_element<I - 1, PlaceholderArgs...>;
|
||||
return as_expr<minimal_expr>(
|
||||
rvalue_mover<!std::is_lvalue_reference<nth_type>::value>{}(
|
||||
placeholder_args_[hana::llong<I - 1>{}]));
|
||||
}
|
||||
|
||||
tuple_t placeholder_args_;
|
||||
};
|
||||
|
||||
template<typename... PlaceholderArgs>
|
||||
struct evaluation_transform_t
|
||||
{
|
||||
using tuple_t = hana::tuple<rvalue_ref_to_value_t<PlaceholderArgs>...>;
|
||||
|
||||
constexpr evaluation_transform_t(PlaceholderArgs &&... args) :
|
||||
placeholder_args_(static_cast<PlaceholderArgs &&>(args)...)
|
||||
{}
|
||||
|
||||
template<long long I>
|
||||
constexpr decltype(auto)
|
||||
operator()(expr_tag<expr_kind::terminal>, boost::yap::placeholder<I>) const
|
||||
{
|
||||
static_assert(
|
||||
I <= decltype(hana::size(std::declval<tuple_t>()))::value,
|
||||
"Out of range placeholder index,");
|
||||
using nth_type = nth_element<I - 1, PlaceholderArgs...>;
|
||||
return rvalue_mover<!std::is_lvalue_reference<nth_type>::value>{}(
|
||||
placeholder_args_[hana::llong<I - 1>{}]);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::terminal>, T && t) const
|
||||
{
|
||||
return static_cast<T &&>(t);
|
||||
}
|
||||
|
||||
#define BOOST_YAP_UNARY_OPERATOR_CASE(op, op_name) \
|
||||
template<typename T> \
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::op_name>, T && t) const \
|
||||
{ \
|
||||
return op transform( \
|
||||
as_expr<minimal_expr>(static_cast<T &&>(t)), *this); \
|
||||
}
|
||||
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(+, unary_plus)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(-, negate)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(*, dereference)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(~, complement)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(&, address_of)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(!, logical_not)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(++, pre_inc)
|
||||
BOOST_YAP_UNARY_OPERATOR_CASE(--, pre_dec)
|
||||
|
||||
template<typename T>
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::post_inc>, T && t) const
|
||||
{
|
||||
return transform(
|
||||
as_expr<minimal_expr>(static_cast<T &&>(t)), *this)++;
|
||||
}
|
||||
template<typename T>
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::post_dec>, T && t) const
|
||||
{
|
||||
return transform(
|
||||
as_expr<minimal_expr>(static_cast<T &&>(t)), *this)--;
|
||||
}
|
||||
|
||||
#undef BOOST_YAP_UNARY_OPERATOR_CASE
|
||||
|
||||
#define BOOST_YAP_BINARY_OPERATOR_CASE(op, op_name) \
|
||||
template<typename T, typename U> \
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::op_name>, T && t, U && u) const \
|
||||
{ \
|
||||
return transform(as_expr<minimal_expr>(static_cast<T &&>(t)), *this) \
|
||||
op transform(as_expr<minimal_expr>(static_cast<U &&>(u)), *this); \
|
||||
}
|
||||
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(<<, shift_left)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(>>, shift_right)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(*, multiplies)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(/, divides)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(%, modulus)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(+, plus)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(-, minus)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(<, less)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(>, greater)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(<=, less_equal)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(>=, greater_equal)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(==, equal_to)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(!=, not_equal_to)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(||, logical_or)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(&&, logical_and)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(&, bitwise_and)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(|, bitwise_or)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE (^, bitwise_xor)
|
||||
|
||||
// clang-format off
|
||||
//[ evaluation_transform_comma
|
||||
template<typename T, typename U>
|
||||
constexpr decltype(auto) operator()(expr_tag<expr_kind::comma>, T && t, U && u) const
|
||||
{
|
||||
return transform(
|
||||
as_expr<minimal_expr>(static_cast<T &&>(t)), *this),
|
||||
transform(
|
||||
as_expr<minimal_expr>(static_cast<U &&>(u)), *this);
|
||||
}
|
||||
//]
|
||||
// clang-format on
|
||||
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(->*, mem_ptr)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(=, assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(<<=, shift_left_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(>>=, shift_right_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(*=, multiplies_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(/=, divides_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(%=, modulus_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(+=, plus_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(-=, minus_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(&=, bitwise_and_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(|=, bitwise_or_assign)
|
||||
BOOST_YAP_BINARY_OPERATOR_CASE(^=, bitwise_xor_assign)
|
||||
|
||||
template<typename T, typename U>
|
||||
constexpr decltype(auto)
|
||||
operator()(expr_tag<expr_kind::subscript>, T && t, U && u) const
|
||||
{
|
||||
return transform(
|
||||
as_expr<minimal_expr>(static_cast<T &&>(t)), *this)[transform(
|
||||
as_expr<minimal_expr>(static_cast<U &&>(u)), *this)];
|
||||
}
|
||||
|
||||
#undef BOOST_YAP_BINARY_OPERATOR_CASE
|
||||
|
||||
template<typename T, typename U, typename V>
|
||||
constexpr decltype(auto)
|
||||
operator()(expr_tag<expr_kind::if_else>, T && t, U && u, V && v) const
|
||||
{
|
||||
return transform(as_expr<minimal_expr>(static_cast<T &&>(t)), *this)
|
||||
? transform(
|
||||
as_expr<minimal_expr>(static_cast<U &&>(u)), *this)
|
||||
: transform(
|
||||
as_expr<minimal_expr>(static_cast<V &&>(v)),
|
||||
*this);
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
//[ evaluation_transform_call
|
||||
template<typename Callable, typename... Args>
|
||||
constexpr decltype(auto) operator()(
|
||||
expr_tag<expr_kind::call>, Callable && callable, Args &&... args) const
|
||||
{
|
||||
return transform(as_expr<minimal_expr>(static_cast<Callable &&>(callable)), *this)(
|
||||
transform(as_expr<minimal_expr>(static_cast<Args &&>(args)), *this)...
|
||||
);
|
||||
}
|
||||
//]
|
||||
// clang-format on
|
||||
|
||||
tuple_t placeholder_args_;
|
||||
};
|
||||
|
||||
|
||||
template<bool Strict, int I, bool IsExprRef>
|
||||
struct transform_impl;
|
||||
|
||||
template<
|
||||
bool Strict,
|
||||
typename Expr,
|
||||
typename TransformTuple,
|
||||
int I,
|
||||
expr_arity Arity,
|
||||
typename = void_t<>>
|
||||
struct transform_expression_tag;
|
||||
|
||||
|
||||
// Forward terminals/recurively transform noterminasl; attempted last.
|
||||
|
||||
template<bool IsLvalueRef, bool IsTerminal, bool Strict>
|
||||
struct default_transform
|
||||
{
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return static_cast<Expr &&>(expr);
|
||||
}
|
||||
};
|
||||
|
||||
template<bool IsLvalueRef, bool IsTerminal>
|
||||
struct default_transform<IsLvalueRef, IsTerminal, true>
|
||||
{
|
||||
struct incomplete;
|
||||
|
||||
// If you're getting an error because this function is uncallable,
|
||||
// that's by design. You called yap::transform_strict(expr, xfrom)
|
||||
// and one or more subexpression of 'expr' are not callable with any
|
||||
// overload in 'xform'.
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr incomplete operator()(Expr && expr, TransformTuple transforms) const;
|
||||
};
|
||||
|
||||
template<
|
||||
expr_kind Kind,
|
||||
template<expr_kind, class> class ExprTemplate,
|
||||
typename OldTuple,
|
||||
typename NewTuple>
|
||||
constexpr auto make_expr_from_tuple(
|
||||
ExprTemplate<Kind, OldTuple> const & expr, NewTuple && tuple)
|
||||
{
|
||||
return ExprTemplate<Kind, NewTuple>{std::move(tuple)};
|
||||
}
|
||||
|
||||
template<expr_kind Kind, typename Expr, typename NewTuple>
|
||||
constexpr auto make_expr_from_tuple(Expr const & expr, NewTuple && tuple)
|
||||
{
|
||||
return minimal_expr<Kind, NewTuple>{std::move(tuple)};
|
||||
}
|
||||
|
||||
template<typename Expr, typename Tuple, typename TransformTuple>
|
||||
constexpr decltype(auto) transform_nonterminal(
|
||||
Expr const & expr, Tuple && tuple, TransformTuple transforms)
|
||||
{
|
||||
auto transformed_tuple =
|
||||
hana::transform(static_cast<Tuple &&>(tuple), [&](auto && element) {
|
||||
using element_t = decltype(element);
|
||||
auto const kind = remove_cv_ref_t<element_t>::kind;
|
||||
::boost::yap::detail::
|
||||
transform_impl<false, 0, kind == expr_kind::expr_ref>
|
||||
xform;
|
||||
return xform(static_cast<element_t &&>(element), transforms);
|
||||
});
|
||||
auto const kind = remove_cv_ref_t<Expr>::kind;
|
||||
return make_expr_from_tuple<kind>(expr, std::move(transformed_tuple));
|
||||
}
|
||||
|
||||
template<>
|
||||
struct default_transform<true, false, false>
|
||||
{
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return transform_nonterminal(expr, expr.elements, transforms);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct default_transform<false, false, false>
|
||||
{
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr decltype(auto)
|
||||
operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return transform_nonterminal(
|
||||
expr, std::move(expr.elements), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
// Dispatch to the next transform, or to the default transform if there is
|
||||
// no next transform.
|
||||
|
||||
template<
|
||||
bool Strict,
|
||||
typename Expr,
|
||||
typename TransformTuple,
|
||||
int I,
|
||||
bool NextTransformExists>
|
||||
struct next_or_default_transform
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
// Use the next transform.
|
||||
constexpr expr_kind kind = remove_cv_ref_t<Expr>::kind;
|
||||
return detail::
|
||||
transform_impl<Strict, I + 1, kind == expr_kind::expr_ref>{}(
|
||||
static_cast<Expr &&>(expr), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct next_or_default_transform<Strict, Expr, TransformTuple, I, false>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
// No next transform exists; use the default transform.
|
||||
constexpr expr_kind kind = remove_cv_ref_t<Expr>::kind;
|
||||
return default_transform<
|
||||
std::is_lvalue_reference<Expr>::value,
|
||||
kind == expr_kind::terminal,
|
||||
Strict>{}(static_cast<Expr &&>(expr), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
// Expression-matching; attempted second.
|
||||
|
||||
template<
|
||||
bool Strict,
|
||||
typename Expr,
|
||||
typename TransformTuple,
|
||||
int I,
|
||||
typename = detail::void_t<>>
|
||||
struct transform_expression_expr
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
// No expr-matching succeeded; use the next or default transform.
|
||||
return next_or_default_transform<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
I + 1 < decltype(hana::size(
|
||||
std::declval<TransformTuple>()))::value>{}(
|
||||
static_cast<Expr &&>(expr), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct transform_expression_expr<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
void_t<decltype((*std::declval<TransformTuple>()[hana::llong<I>{}])(
|
||||
std::declval<Expr>()))>>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return (*transforms[hana::llong<I>{}])(static_cast<Expr &&>(expr));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Tag-matching; attempted first.
|
||||
|
||||
template<
|
||||
bool Strict,
|
||||
typename Expr,
|
||||
typename TransformTuple,
|
||||
int I,
|
||||
expr_arity Arity,
|
||||
typename>
|
||||
struct transform_expression_tag
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
// No tag-matching succeeded; try expr-matching.
|
||||
return transform_expression_expr<Strict, Expr, TransformTuple, I>{}(
|
||||
static_cast<Expr &&>(expr), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
constexpr decltype(auto) terminal_value(T && x)
|
||||
{
|
||||
return value_impl<true>(static_cast<T &&>(x));
|
||||
}
|
||||
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct transform_expression_tag<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
expr_arity::one,
|
||||
void_t<decltype((*std::declval<TransformTuple>()[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(::boost::yap::value(std::declval<Expr>()))))>>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return (*transforms[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(
|
||||
::boost::yap::value(static_cast<Expr &&>(expr))));
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct transform_expression_tag<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
expr_arity::two,
|
||||
void_t<decltype((*std::declval<TransformTuple>()[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(::boost::yap::left(std::declval<Expr>())),
|
||||
terminal_value(::boost::yap::right(std::declval<Expr>()))))>>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return (*transforms[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(::boost::yap::left(static_cast<Expr &&>(expr))),
|
||||
terminal_value(
|
||||
::boost::yap::right(static_cast<Expr &&>(expr))));
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct transform_expression_tag<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
expr_arity::three,
|
||||
void_t<decltype((*std::declval<TransformTuple>()[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(::boost::yap::cond(std::declval<Expr>())),
|
||||
terminal_value(::boost::yap::then(std::declval<Expr>())),
|
||||
terminal_value(::boost::yap::else_(std::declval<Expr>()))))>>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return (*transforms[hana::llong<I>{}])(
|
||||
expr_tag<remove_cv_ref_t<Expr>::kind>{},
|
||||
terminal_value(::boost::yap::cond(static_cast<Expr &&>(expr))),
|
||||
terminal_value(::boost::yap::then(static_cast<Expr &&>(expr))),
|
||||
terminal_value(
|
||||
::boost::yap::else_(static_cast<Expr &&>(expr))));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Expr, typename Transform>
|
||||
struct transform_call_unpacker
|
||||
{
|
||||
template<long long... I>
|
||||
constexpr auto operator()(
|
||||
Expr && expr,
|
||||
Transform & transform,
|
||||
std::integer_sequence<long long, I...>) const
|
||||
-> decltype(transform(
|
||||
expr_tag<expr_kind::call>{},
|
||||
terminal_value(::boost::yap::get(
|
||||
static_cast<Expr &&>(expr), hana::llong_c<I>))...))
|
||||
{
|
||||
return transform(
|
||||
expr_tag<expr_kind::call>{},
|
||||
terminal_value(::boost::yap::get(
|
||||
static_cast<Expr &&>(expr), hana::llong_c<I>))...);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
constexpr auto indices_for(Expr const & expr)
|
||||
{
|
||||
constexpr long long size = decltype(hana::size(expr.elements))::value;
|
||||
return std::make_integer_sequence<long long, size>();
|
||||
}
|
||||
|
||||
template<bool Strict, typename Expr, typename TransformTuple, int I>
|
||||
struct transform_expression_tag<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
expr_arity::n,
|
||||
void_t<decltype(
|
||||
transform_call_unpacker<
|
||||
Expr,
|
||||
decltype(*std::declval<TransformTuple>()[hana::llong<I>{}])>{}(
|
||||
std::declval<Expr>(),
|
||||
*std::declval<TransformTuple>()[hana::llong<I>{}],
|
||||
indices_for(std::declval<Expr>())))>>
|
||||
{
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
using transform_t = decltype(*transforms[hana::llong<I>{}]);
|
||||
return transform_call_unpacker<Expr, transform_t>{}(
|
||||
static_cast<Expr &&>(expr),
|
||||
*transforms[hana::llong<I>{}],
|
||||
indices_for(expr));
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, int I, bool IsExprRef>
|
||||
struct transform_impl
|
||||
{
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
|
||||
return detail::transform_expression_tag<
|
||||
Strict,
|
||||
Expr,
|
||||
TransformTuple,
|
||||
I,
|
||||
detail::arity_of<kind>()>{}(
|
||||
static_cast<Expr &&>(expr), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
template<bool Strict, int I>
|
||||
struct transform_impl<Strict, I, true>
|
||||
{
|
||||
template<typename Expr, typename TransformTuple>
|
||||
constexpr decltype(auto) operator()(Expr && expr, TransformTuple transforms) const
|
||||
{
|
||||
return detail::transform_impl<Strict, I, false>{}(
|
||||
::boost::yap::deref(static_cast<Expr &&>(expr)), transforms);
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user