NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions

libcamera: base: bound_method: Remove BoundMethodArgs specialization

Browse source 
The BoundMethodArgs specialization for the void return type is only
needed to avoid accessing the ret_ member variable that is lacking from
the corresponding BoundMethodPack specialization. As the member variable
is only accessed in the invokePack() function, instead of specializing
the whole class we can use SFINAE to select between two different
implementations of the function.

SFINAE can only depend on the function template parameters, not the
parameters of the class template in which the function is defined:

"Only the failures in the types and expressions in the immediate context
of the function type or its template parameter types are SFINAE errors."

We thus can't use the type R in an std::enable_if expression for the
invokePack() function. To work around this, we have to add a type T to
the function template definition, which defaults to R, and use T with
std::enable_if.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Umang Jain <umang.jain@ideasonboard.com>
This commit is contained in:
Laurent Pinchart 2021-08-27 02:50:29 +03:00
parent d1315600b8
commit c4e2b00d51
1 changed files with 8 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

34
include/libcamera/base/bound_method.h
View file

@ -98,35 +98,17 @@ public:
using PackType = BoundMethodPack<R, Args...>; using PackType = BoundMethodPack<R, Args...>;
private: private:
template<std::size_t... I> template<std::size_t... I, typename T = R>
void invokePack(BoundMethodPackBase *pack, std::index_sequence<I...>) std::enable_if_t<!std::is_void<T>::value, void>
invokePack(BoundMethodPackBase *pack, std::index_sequence<I...>)
{ {
PackType *args = static_cast<PackType *>(pack); PackType *args = static_cast<PackType *>(pack);
args->ret_ = invoke(std::get<I>(args->args_)...); args->ret_ = invoke(std::get<I>(args->args_)...);
} }
public: template<std::size_t... I, typename T = R>
BoundMethodArgs(void *obj, Object *object, ConnectionType type) std::enable_if_t<std::is_void<T>::value, void>
: BoundMethodBase(obj, object, type) {} invokePack(BoundMethodPackBase *pack, std::index_sequence<I...>)
void invokePack(BoundMethodPackBase *pack) override
{
invokePack(pack, std::make_index_sequence<sizeof...(Args)>{});
}
virtual R activate(Args... args, bool deleteMethod = false) = 0;
virtual R invoke(Args... args) = 0;
};
template<typename... Args>
class BoundMethodArgs<void, Args...> : public BoundMethodBase
{
public:
using PackType = BoundMethodPack<void, Args...>;
private:
template<std::size_t... I>
void invokePack(BoundMethodPackBase *pack, std::index_sequence<I...>)
{ {
/* args is effectively unused when the sequence I is empty. */ /* args is effectively unused when the sequence I is empty. */
PackType *args [[gnu::unused]] = static_cast<PackType *>(pack); PackType *args [[gnu::unused]] = static_cast<PackType *>(pack);
@ -142,8 +124,8 @@ public:
invokePack(pack, std::make_index_sequence<sizeof...(Args)>{}); invokePack(pack, std::make_index_sequence<sizeof...(Args)>{});
} }
virtual void activate(Args... args, bool deleteMethod = false) = 0; virtual R activate(Args... args, bool deleteMethod = false) = 0;
virtual void invoke(Args... args) = 0; virtual R invoke(Args... args) = 0;
}; };
template<typename T, typename R, typename... Args> template<typename T, typename R, typename... Args>