1#ifndef _RHEOLEF_FIELD_EXPR_UTILITIES_H
2#define _RHEOLEF_FIELD_EXPR_UTILITIES_H
30#include "rheolef/promote.h"
31#include "rheolef/point.h"
35namespace rheolef {
namespace details {
40template <
typename T1,
typename T2>
43 typename std::decay<T1>::type,
44 typename std::decay<T2>::type
58 :
public std::false_type
66template<
typename B1,
typename B2>
68 :
public std::conditional<B1::value, B1, B2>::type
71template<
typename B1,
typename B2,
typename B3,
typename... Bn>
73 :
public std::conditional<B1::value, B1, or_type<B2, B3, Bn...>>::type
81 :
public std::true_type
89template<
typename B1,
typename B2>
91 :
public std::conditional<B1::value, B2, B1>::type
94template<
typename B1,
typename B2,
typename B3,
typename... Bn>
96 :
public std::conditional<B1::value, and_type<B2, B3, Bn...>, B1>::type
101 :
public std::integral_constant<bool, !P::value>
110template <
size_t... Is>
115 template <
size_t MIN,
size_t N,
size_t... Is>
119 template <
size_t MIN,
size_t... Is>
126 template <
size_t MIN,
size_t N,
size_t... Is>
132template<
size_t MIN,
size_t MAX>
144template <
typename C,
typename R,
typename... Args>
147 static const std::size_t arity =
sizeof...(Args);
148 template <std::
size_t I>
150 static_assert(I < arity,
"error: invalid parameter index.");
151 using type =
typename std::tuple_element<I, std::tuple<Args...> >::type;
164template<
class R,
class... Args>
167template<
class R,
class... Args>
170 static constexpr std::size_t arity =
sizeof...(Args);
171 template <std::
size_t I>
173 static_assert(I < arity,
"error: invalid parameter index.");
174 using type =
typename std::tuple_element<I,std::tuple<Args...> >::type;
191template <
typename T,
typename M>
class field_basic;
201template <
typename,
typename>
204template <
typename F,
typename R,
typename ... Args>
206{
using type = R (*)(Args...); };
212template <
typename,
typename>
215template <
typename C,
typename R,
typename ... Args>
217{
using type = R (C::*)(Args...); };
219template <
typename C,
typename R,
typename ... Args>
221{
using type = R (C::*)(Args...)
const; };
223template <
typename C,
typename R,
typename ... Args>
225{
using type = R (C::*)(Args...)
volatile; };
228template <
typename C,
typename S>
231 typedef char (&
no)[2];
236 template <
typename T, T>
struct check;
244 static bool constexpr value =
sizeof(deduce<C>(0)) ==
sizeof(
yes);
248template <
typename F,
typename S>
252 static bool constexpr value = std::is_same<
258template <
typename C,
typename S,
bool>
260 : std::integral_constant<
261 bool, is_functor_with_signature<C, S>::value
266template <
typename F,
typename S>
268 : std::integral_constant<
269 bool, is_function_with_signature<F, S>::value
276template <
typename Callable,
typename Signature>
280 std::is_class<Callable>::value
284template <
typename Signature>
296 int c(
int &,
void **);
298#define _RHEOLEF_IS_CALLABLE_POSITIVE "should be recognized as callable"
299#define _RHEOLEF_IS_CALLABLE_NEGATIVE "should not be recognized as callable"
307#undef _RHEOLEF_IS_CALLABLE_POSITIVE
308#undef _RHEOLEF_IS_CALLABLE_NEGATIVE
316template <
typename C,
typename R,
typename ... Args>
320template <
typename C,
typename R,
typename ... Args>
324template <
typename C,
typename R,
typename ... Args>
332 typename
std::enable_if<
333 std::is_member_function_pointer<decltype(&F::operator())>::value
340template <
typename F,
typename Sfinae =
void>
struct is_functor : std::false_type {};
342 typename
std::enable_if<
343 get_functor_result<F>::value
345> : std::true_type {};
356template<
class R,
class T>
struct is_field_true_function <R(const
point_basic<
T>&)> :
std::true_type {};
357template<
class R,
class T>
struct is_field_true_function <R(*)(
const point_basic<T>&)> : std::true_type {};
360template<
class F,
class Sfinae =
void>
struct is_field_functor : std::false_type {};
361template<
class F>
struct is_field_functor<F,typename
std::enable_if<
362 std::is_class<F>::value
363 && is_functor<F>::value
367 is_callable<F,typename get_functor_result<F>::type (const point&) const>::value
368 , std::true_type, std::false_type>::type {};
371template<
class F,
class Sfinae =
void>
struct is_field_function : std::false_type {};
372template<
class F>
struct is_field_function<F,
373 typename
std::enable_if<
374 is_field_true_function<F>::value
375 || is_field_functor<F>::value
377> : std::true_type {};
379template<
class F,
class Sfinae =
void>
struct field_function_traits {};
380template<
class F>
struct field_function_traits<F,
381 typename
std::enable_if<
382 is_field_true_function<F>::value
385 typedef typename function_traits<F>::result_type result_type;
387template<
class F>
struct field_function_traits<F,
388 typename
std::enable_if<
389 is_field_functor<F>::value
392 typedef typename functor_traits<F>::result_type result_type;
#define _RHEOLEF_IS_CALLABLE_NEGATIVE
#define _RHEOLEF_IS_CALLABLE_POSITIVE
typename range_builder< MIN, MAX >::type index_range
This file is part of Rheolef.
t operator()(const t &a, const t &b)
R(C::*)(Args...) const type
R(C::*)(Args...) volatile type
typename std::decay< type >::type decay_type
typename std::tuple_element< I, std::tuple< Args... > >::type type
std::tuple< Args... > args_tuple_type
R(*)(Args...) function_pointer_type
typename get_functor_result_impl< F, decltype(&F::operator())>::type type
static bool constexpr value
static bool constexpr value
static yes deduce(check< typename build_class_function< C, S >::type, &T::operator()> *)
typename std::tuple_element< I, std::tuple< Args... > >::type type
std::tuple< Args... > args_tuple_type
R(*)(Args...) function_pointer_type
function_pointer_type copiable_type
std::function< R(Args...)> functor_type