CODEWITHSUNDEEP
c++templatesvariadic-templates
CODIJY
CODIJY

Reputation: 93

Compile time configurable callback

I'm trying to implement compile-time configurable callback for sync/async call behaviour.

Here is the first approach to do that: 

//emit type's
enum EEmitType
{
   SYNC,
   ASYNC,
};

//general 
template<EEmitType et, typename... Args>
class callback_impl;

//implementation
template<EEmitType et, typename R, typename... Args>
class callback_impl<et, R(Args...)>
{ /*todo*/ };

//................................................................

//convert enum value to type or SFINAE
template <EEmitType et>
using callback_emit_type = std::integral_constant<EEmitType, et>;

//(for default SYNC)
template <typename T>
struct is_emit_type : std::false_type {};

//(for any other implementation)
template <EEmitType et>
struct is_emit_type<callback_emit_type<et>> : std::true_type {};

//................................................................

//metafunction
template <typename T>
using is_emit_type_t = typename is_emit_type<T>::type;

//................................................................

//for decl. like: callback<void()>
template <typename _unused, typename... Args>
struct construct_callback_impl
{
    //alias on implementation
    using type = callback_impl<SYNC, Args...>;
};

//for decl. like: callback<callback_emit_type<ASYNC>, void()>
template <typename EEmitType, typename... Args>
struct construct_callback_impl<typename 
std::enable_if<is_emit_type_t<EEmitType>::value>::type, EEmitType, Args...>
{
    //alias on implementation
    using type = callback_impl<EEmitType::value, Args...>;
};

//................................................................

//user alias
template <typename... Args>
using callback = typename construct_callback_impl<Args...>::type;

Now USING:

callback<int(int)> ff_s; //<--  uses undefined class 'callback_impl<SYNC>'
callback<callback_emit_type<ASYNC>, int(int)> ff_a; //<--OK

Of course because first args is eating, and for success compilation it should be write down like: 

 callback<int(int), int(int)> ff_s

But of course it's not unacceptable. OK, then I try extract EEmitType from Args...

//for decl. like: callback<void()>
template <typename... Args>
struct construct_callback_impl
{
   //alias on implementation
   using type = int; //temporary stub
};

//for decl. like: callback<callback_emit_type<ASYNC>, void()>
template <typename... Args>
struct construct_callback_impl<typename std::enable_if<is_emit_type_t< typename std::tuple_element_t<0, std::tuple<Args...> >::type >::value>::type, Args...>
{
    //alias on implementation
    using type = int; //temporary stub
};

BUT now I get the:

error C2338: tuple index out of bounds
note: see reference to class template instantiation 'std::tuple_element<0,std::tuple<>>' being compiled

Upvotes: 0

Views: 120

Answers (1)

n. m. could be an AI
n. m. could be an AI

Reputation: 119877

Something like this should work

template <typename>
struct emit_type_value : std::integral_constant<EEmitType, SYNC> {};

template <EEmitType x>
struct emit_type_value<callback_emit_type<x>> : std::integral_constant<EEmitType, x> {};

//for decl. like: callback<void()>
template <typename Arg0, typename ... Args>
struct construct_callback_impl
{
    //alias on implementation
    using type = std::conditional_t<is_emit_type<Arg0>::value,
          callback_impl<emit_type_value<Arg0>::value, Args...>,
          callback_impl<SYNC, Arg0, Args...>>;

};

It would be somewhat terser if you just used false and true instead of SYNC and ASYNC.

Upvotes: 2

Related Questions