fallback to alternate function when templated function instantiation fails - c++

Question

i need to store pointers to instanced template functions and when function cannot be instanced i would like to store pointer to empty function instead. I looked into SFINAE but i dont think it applies here.
struct StaticEntity {
double position;
};
struct DynamicEntity {
double position;
double speed;
};
class MoveSystem {
public:
template <typename T>
void update(T& entity, double dt) {
entity.position += entity.speed*dt;
}
};
typedef void (*updateEntitiesFunc)(void* system, void* entity, double dt);
template <typename S, typename E>
static void update(void* system, void* entity, double dt)
{
// here if inner function cannot be instanced i would like to skip it and do "nothing" instead
((S*)system)->update(*(E*)entity, dt);
}
int main() {
updateEntitiesFunc uf = update<MoveSystem, DynamicEntity>;
updateEntitiesFunc uf2 = update<MoveSystem, StaticEntity>;
//^ this does not compile
// gives error: 'struct StaticEntity' has no member named 'speed'
// i would like it to compile and contain pointer to empty function
return 0;
}
It probably is solvable with some template magic that i just cant figure out.
Ideally without adding complexity to both Entity and System classes.
Design motivation:
for all my entity and system types i want to create a static array of function pointers:
updateEntitiesFunc funcs[EntityTypes::getTypesCount()][SystemTypes::getTypesCount()];
And then at runtime call correct function with type-ids:
funcs[entity->getTypeId()][system->getTypeId()](&system, &entity, dt);
At runtime i will check if entity is compatible with system but it is runtime information. So all function pointers must be registered for all entity-system pairs at compile time, even though they are not compatible. This is where i wanted to create those no-op functions.

Answer 1

First, metaprogramming boilerplate:
namespace details {
template<class...>struct voider{using type=void;};
template<class...Ts>using void_t=typename voider<Ts...>::type;
template<template<class...>class Z, class, class...Ts>
struct can_apply:
std::false_type
{};
template<template<class...>class Z, class...Ts>
struct can_apply<Z, void_t<Z<Ts...>>, Ts...>:
std::true_type
{};
}
template<template<class...>class Z, class...Ts>
using can_apply=details::can_apply<Z,void,Ts...>;
Now, we can detect properties:
template<class T>
using speed_t = decltype(std::declval<T>().speed);
template<class T>
using position_t = decltype(std::declval<T>().position);
template<class T>
using has_speed = can_apply<speed_t, T>;
template<class T>
using has_position = can_apply<position_t, T>;
template<class S, class E>
using update_call_t = decltype( std::declval<S>().update( std::declval<E>(), 0.0 ) );
template<class S, class E>
using has_update = can_apply< update_call_t, S, E >;
and we have three traits, has_position, has_update and has_speed that are useful.
Now we fix MoveSystem:
struct MoveSystem {
template <class T>
std::enable_if_t< has_speed<T&>{} && has_position<T&>{} >
update(T& entity, double dt) {
entity.position += entity.speed*dt;
}
};
next, we modify update:
namespace updates {
template<class S, class E>
std::enable_if_t< has_update<S,E>{} >
update(S* system, E* entity, double dt ) {
system->update(*entity, dt);
}
void update(void*, void*, double) {}
}
template<class S, class E>
void update(void* system, void* entity, double dt) {
using updates::update;
update(static_cast<S*>(system), static_cast<E*>(entity), dt );
}
to check for the .update method working with those parameters.
I ADL-enabled the code such that if the class has a friend void update( S*, E*, double ) it will also work.
This is all SFINAE work. Note that adding more properties once we have can_apply is pretty easy. Make an alias that generates a type that only works if the property is satisfied, then write a can_apply alias that converts that application to a compile-time boolean test.
As an aside, MSVC2015 is not a C++11 compiler, in that it cannot compile the above code. In MSVC you have to track down some proprietary extensions to do the equivalent of the above code. This involves writing has_position and the other traits differently. They call the failure to obey the C++11 standard in this case an inability to do "expression SFINAE".
Note that the above uses a handful of C++14 features. Replace std::enable_if_t<??> with typename std::enable_if<??>::type, replace has_position<??>{} with has_position<??>::value and similar other changes if your compiler doesn't support it.