1acad98f7d
Invoking a method that takes a reference argument with
Object::invokeMethod() results in a compilation error:
../test/object-invoke.cpp:131:11: error: no matching member function for call to 'invokeMethod'
object_.invokeMethod(&InvokedObject::methodWithReference,
~~~~~~~~^~~~~~~~~~~~
../include/libcamera/object.h:33:7: note: candidate template ignored: deduced conflicting types for parameter 'Args' (<const int &> vs. <int>)
void invokeMethod(void (T::*func)(Args...), ConnectionType type, Args... args)
This is due to the fact that implicit type conversions (from value to
reference in this case) takes place after template argument type
deduction, during overload resolution. A similar issue would occur if
T::func took a long argument and invokeMethod() was called with an in
argument.
Fix this by specifying to sets of argument types in the invokeMethod()
template, one for the arguments to the invoked method, and one for the
arguments to invokeMethod() itself. The compiler can then first perform
type deduction separately, and implicit conversion in a second step.
Reported-by: Paul Elder <paul.elder@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
75 lines
1.6 KiB
C++
75 lines
1.6 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2019, Google Inc.
|
|
*
|
|
* object.h - Base object
|
|
*/
|
|
#ifndef __LIBCAMERA_OBJECT_H__
|
|
#define __LIBCAMERA_OBJECT_H__
|
|
|
|
#include <list>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include <libcamera/bound_method.h>
|
|
|
|
namespace libcamera {
|
|
|
|
class Message;
|
|
template<typename... Args>
|
|
class Signal;
|
|
class SignalBase;
|
|
class Thread;
|
|
|
|
class Object
|
|
{
|
|
public:
|
|
Object(Object *parent = nullptr);
|
|
virtual ~Object();
|
|
|
|
void postMessage(std::unique_ptr<Message> msg);
|
|
|
|
template<typename T, typename... FuncArgs, typename... Args,
|
|
typename std::enable_if<std::is_base_of<Object, T>::value>::type * = nullptr>
|
|
void invokeMethod(void (T::*func)(FuncArgs...), ConnectionType type,
|
|
Args... args)
|
|
{
|
|
T *obj = static_cast<T *>(this);
|
|
BoundMethodBase *method =
|
|
new BoundMemberMethod<T, FuncArgs...>(obj, this, func, type);
|
|
void *pack = new typename BoundMemberMethod<T, FuncArgs...>::PackType{ args... };
|
|
|
|
method->activatePack(pack, true);
|
|
}
|
|
|
|
Thread *thread() const { return thread_; }
|
|
void moveToThread(Thread *thread);
|
|
|
|
Object *parent() const { return parent_; }
|
|
|
|
protected:
|
|
virtual void message(Message *msg);
|
|
|
|
private:
|
|
template<typename... Args>
|
|
friend class Signal;
|
|
friend class BoundMethodBase;
|
|
friend class Thread;
|
|
|
|
void notifyThreadMove();
|
|
|
|
void connect(SignalBase *signal);
|
|
void disconnect(SignalBase *signal);
|
|
|
|
Object *parent_;
|
|
std::vector<Object *> children_;
|
|
|
|
Thread *thread_;
|
|
std::list<SignalBase *> signals_;
|
|
unsigned int pendingMessages_;
|
|
};
|
|
|
|
} /* namespace libcamera */
|
|
|
|
#endif /* __LIBCAMERA_OBJECT_H__ */
|