libcamera v0.7.2 Supporting cameras in Linux since 2019

Loading...
Searching...
No Matches
bound_method.h
Go to the documentation of this file.
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2/*
3 * Copyright (C) 2019, Google Inc.
4 *
5 * Method bind and invocation
6 */
7
8#pragma once
9
10#include <memory>
11#include <tuple>
12#include <type_traits>
13#include <utility>
14
15 namespace libcamera {
16
17 class Object;
18
19 enum ConnectionType {
20 ConnectionTypeAuto,
21 ConnectionTypeDirect,
22 ConnectionTypeQueued,
23 ConnectionTypeBlocking,
24};
25
26 class BoundMethodPackBase
27{
28 public:
29 virtual ~BoundMethodPackBase() = default;
30};
31
32 template<typename R, typename... Args>
33 class BoundMethodPack : public BoundMethodPackBase
34{
35 public:
36 template<typename... Ts>
37 BoundMethodPack(Ts &&...args)
38 : args_(std::forward<Ts>(args)...)
39 {
40 }
41
42 std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> args_;
43 R ret_;
44};
45
46 template<typename... Args>
47 class BoundMethodPack<void, Args...> : public BoundMethodPackBase
48{
49 public:
50 template<typename... Ts>
51 BoundMethodPack(Ts &&...args)
52 : args_(std::forward<Ts>(args)...)
53 {
54 }
55
56 std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> args_;
57};
58
59 class BoundMethodBase
60{
61 public:
62 BoundMethodBase(void *obj, Object *object, ConnectionType type)
63 : obj_(obj), object_(object), connectionType_(type)
64 {
65 }
66 virtual ~BoundMethodBase() = default;
67
68 template<typename T, std::enable_if_t<!std::is_same<Object, T>::value> * = nullptr>
69 bool match(T *obj) { return obj == obj_; }
70 bool match(Object *object) { return object == object_; }
71
72 Object *object() const { return object_; }
73
74 virtual void invokePack(BoundMethodPackBase *pack) = 0;
75
76 protected:
77 bool activatePack(std::shared_ptr<BoundMethodPackBase> pack,
78 bool deleteMethod);
79
80 void *obj_;
81 Object *object_;
82
83 private:
84 ConnectionType connectionType_;
85};
86
87 template<typename R, typename... Args>
88 class BoundMethodArgs : public BoundMethodBase
89{
90 public:
91 using PackType = BoundMethodPack<R, Args...>;
92
93 BoundMethodArgs(void *obj, Object *object, ConnectionType type)
94 : BoundMethodBase(obj, object, type) {}
95
96 void invokePack(BoundMethodPackBase *pack) override
97 {
98 auto *argsPack = static_cast<PackType *>(pack);
99
100 std::apply([&](Args &&...args) {
101 if constexpr (!std::is_void_v<R>)
102 argsPack->ret_ = invoke(std::forward<decltype(args)>(args)...);
103 else
104 invoke(std::forward<decltype(args)>(args)...);
105 }, std::move(argsPack->args_));
106 }
107
108 virtual R activate(Args... args, bool deleteMethod = false) = 0;
109 virtual R invoke(Args... args) = 0;
110};
111
112 template<typename T, typename R, typename Func, typename... Args>
113 class BoundMethodFunctor : public BoundMethodArgs<R, Args...>
114{
115 public:
116 using PackType = typename BoundMethodArgs<R, Args...>::PackType;
117
118 BoundMethodFunctor(T *obj, Object *object, Func func,
119 ConnectionType type = ConnectionTypeAuto)
120 : BoundMethodArgs<R, Args...>(obj, object, type), func_(std::move(func))
121 {
122 }
123
124 R activate(Args... args, bool deleteMethod = false) override
125 {
126 if (!this->object_)
127 return func_(std::forward<Args>(args)...);
128
129 auto pack = std::make_shared<PackType>(std::forward<Args>(args)...);
130 [[maybe_unused]] bool sync = BoundMethodBase::activatePack(pack, deleteMethod);
131
132 if constexpr (!std::is_void_v<R>)
133 return sync ? std::move(pack->ret_) : R();
134 }
135
136 R invoke(Args... args) override
137 {
138 return func_(std::forward<Args>(args)...);
139 }
140
141 private:
142 Func func_;
143};
144
145 template<typename T, typename R, typename... Args>
146 class BoundMethodMember : public BoundMethodArgs<R, Args...>
147{
148 public:
149 using PackType = typename BoundMethodArgs<R, Args...>::PackType;
150
151 BoundMethodMember(T *obj, Object *object, R (T::*func)(Args...),
152 ConnectionType type = ConnectionTypeAuto)
153 : BoundMethodArgs<R, Args...>(obj, object, type), func_(func)
154 {
155 }
156
157 bool match(R (T::*func)(Args...)) const { return func == func_; }
158
159 R activate(Args... args, bool deleteMethod = false) override
160 {
161 if (!this->object_) {
162 T *obj = static_cast<T *>(this->obj_);
163 return (obj->*func_)(std::forward<Args>(args)...);
164 }
165
166 auto pack = std::make_shared<PackType>(std::forward<Args>(args)...);
167 [[maybe_unused]] bool sync = BoundMethodBase::activatePack(pack, deleteMethod);
168
169 if constexpr (!std::is_void_v<R>)
170 return sync ? std::move(pack->ret_) : R();
171 }
172
173 R invoke(Args... args) override
174 {
175 T *obj = static_cast<T *>(this->obj_);
176 return (obj->*func_)(std::forward<Args>(args)...);
177 }
178
179 private:
180 R (T::*func_)(Args...);
181};
182
183 template<typename R, typename... Args>
184 class BoundMethodStatic : public BoundMethodArgs<R, Args...>
185{
186 public:
187 BoundMethodStatic(R (*func)(Args...))
188 : BoundMethodArgs<R, Args...>(nullptr, nullptr, ConnectionTypeAuto),
189 func_(func)
190 {
191 }
192
193 bool match(R (*func)(Args...)) const { return func == func_; }
194
195 R activate(Args... args, [[maybe_unused]] bool deleteMethod = false) override
196 {
197 return (*func_)(std::forward<Args>(args)...);
198 }
199
200 R invoke(Args...) override
201 {
202 return R();
203 }
204
205 private:
206 R (*func_)(Args...);
207};
208
209} /* namespace libcamera */
libcamera::Object
Base object to support automatic signal disconnection.
Definition object.h:27
libcamera
Top-level libcamera namespace.
Definition backtrace.h:17
libcamera::ConnectionType
ConnectionType
Connection type for asynchronous communication.
Definition bound_method.h:19
libcamera::ConnectionTypeDirect
@ ConnectionTypeDirect
The receiver is invoked immediately and synchronously in the sender's thread.
Definition bound_method.h:21
libcamera::ConnectionTypeBlocking
@ ConnectionTypeBlocking
The receiver is invoked synchronously.
Definition bound_method.h:23
libcamera::ConnectionTypeQueued
@ ConnectionTypeQueued
The receiver is invoked asynchronously.
Definition bound_method.h:22
libcamera::ConnectionTypeAuto
@ ConnectionTypeAuto
If the sender and the receiver live in the same thread, ConnectionTypeDirect is used....
Definition bound_method.h:20