Homec4science
Diffusion LibMultiScale (master) Browse

libmultiscale/src/common/automatic_cast.hh
908a9d244523master

Last Change
Raw File

automatic_cast.hh
View Options

#ifndef __LIBMULTISCALE_AUTOMATIC_CAST_HH__
#define __LIBMULTISCALE_AUTOMATIC_CAST_HH__
#include <any>
#include <iostream>
#include <stdexcept>
#include <tuple>
#include <utility>
//****************************************************************
// apply static functor on tuple
//****************************************************************
// namespace detail {
// template <class F, class Tuple, std::size_t... I>
// constexpr decltype(auto) apply_impl(F &&f, Tuple &&t,
// std::index_sequence<I...>) {
// return f(std::get<I>(std::forward<Tuple>(t))...);
// }
// } // namespace detail
// template <class F, class Tuple>
// constexpr decltype(auto) apply(F &&f, Tuple &&t) {
// return detail::apply_impl(
// std::forward<F>(f), std::forward<Tuple>(t),
// std::make_index_sequence<
// std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
// }
//****************************************************************
// casting of objects
//****************************************************************
template <typename possible_types, int n> struct _cpp_dynamic_cast {
template <typename CastFunctor, typename AfterCastFunctor, typename Arg>
static void cast(CastFunctor &cast_functor, AfterCastFunctor &call_after_cast,
Arg &arg) {
using _type = std::remove_pointer_t<
std::decay_t<std::tuple_element_t<n, possible_types>>>;
if (cast_functor.template cast<_type>(arg, call_after_cast)) {
return;
}
_cpp_dynamic_cast<possible_types, n - 1>::template cast(
cast_functor, call_after_cast, arg);
}
};
template <typename possible_types>
struct _cpp_dynamic_cast<possible_types, -1> {
template <typename CastFunctor, typename AfterCastFunctor, typename Arg>
static void cast(CastFunctor &cast_functor, AfterCastFunctor &call_after_cast,
Arg &arg) {
throw std::bad_cast();
}
};
template <typename possible_types, typename CastFunctor,
typename AfterCastFunctor, typename Arg>
void cpp_dynamic_cast(CastFunctor &cast_functor,
AfterCastFunctor &call_after_cast, Arg &arg) {
constexpr size_t N = std::tuple_size<possible_types>::value;
_cpp_dynamic_cast<possible_types, N - 1>::cast(cast_functor, call_after_cast,
arg);
}
/* --------------------------------------------------------------------- */
template <int argument_position, typename PossibleTypes,
typename ArgumentsTuple, typename ArgumentsCastedTuple>
struct CallCast {
template <typename Functor, typename CastFunctor>
static void call_compute(Functor &functor, CastFunctor &cast_functor,
ArgumentsTuple args,
ArgumentsCastedTuple args_casted) {
using possible_types =
std::tuple_element_t<argument_position, PossibleTypes>;
auto arg = std::get<argument_position>(args);
// functor that will be called after resolving
// the dynamic cast of the current argument
// => It will proceed to the next argument
auto &&call_after_cast = [&](auto &&casted_object) {
auto tup = std::forward_as_tuple(casted_object);
auto new_args_casted = std::tuple_cat(tup, args_casted);
CallCast<argument_position - 1, PossibleTypes, ArgumentsTuple,
decltype(new_args_casted)>::call_compute(functor, cast_functor,
args, new_args_casted);
};
cpp_dynamic_cast<possible_types>(cast_functor, call_after_cast, arg);
}
};
// specialization for the end of recursion: all args have been dynamic casted
// need to call the function
template <typename PossibleTypes, typename ArgumentsTuple,
typename ArgumentsCastedTuple>
struct CallCast<-1, PossibleTypes, ArgumentsTuple, ArgumentsCastedTuple> {
template <typename Functor, typename CastFunctor>
static void call_compute(Functor &functor, CastFunctor &cast_functor,
ArgumentsTuple args,
ArgumentsCastedTuple args_formatted) {
std::apply([&](auto &... args) { functor(args...); }, args_formatted);
}
};
template <typename PossibleTypes, typename CastFunctor, typename Functor,
typename... Args>
void call_compute(Functor func, Args &... args) {
auto arguments_tuple = std::make_tuple(&args...);
constexpr size_t N = std::tuple_size<decltype(arguments_tuple)>::value;
auto cast_functor = CastFunctor{};
CallCast<N - 1, PossibleTypes, decltype(arguments_tuple),
std::tuple<>>::call_compute(func, cast_functor, arguments_tuple,
std::tuple<>{});
}
/* --------------------------------------------------------------------- */
// DECORATION POSSIBILITY
/* --------------------------------------------------------------------- */
#define _Args(...) __VA_ARGS__
#define STRIP_PARENS(X) X
#define STATIC_DISPATCH_DECLARE(NAME) \
template <typename... Args> void dispatch_##NAME(Args &&... args);
#define STATIC_DISPATCH_DEFINE(NAME, POS_TYPES) \
template <typename... Args> void dispatch_##NAME(Args &&... args) { \
\
using possible_types = std::tuple<STRIP_PARENS(_Args POS_TYPES)>; \
\
call_compute<possible_types, simple_cast>( \
[&](auto &&... args) { NAME(std::forward<decltype(args)>(args)...); }, \
std::forward<Args>(args)...); \
}
struct simple_cast {
template <typename type, typename AfterCastFunctor, typename Arg>
bool cast(Arg &arg, AfterCastFunctor &call_after_cast) {
if (auto *ptr = dynamic_cast<type *>(arg)) {
call_after_cast(*ptr);
return true;
}
return false;
}
};
/* --------------------------------------------------------------------- */
#endif // __LIBMULTISCALE_AUTOMATIC_CAST_HH__
c4science · Help