2 * Copyright (c) 2023 Simon Marchi <simon.marchi@efficios.com>
3 * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
5 * SPDX-License-Identifier: MIT
8 #ifndef BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP
9 #define BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP
15 #include <babeltrace2/babeltrace.h>
17 #include "cpp-common/bt2c/c-string-view.hpp"
18 #include "cpp-common/bt2c/logging.hpp"
19 #include "cpp-common/vendor/fmt/core.h"
27 constexpr bt2c::CStringView unhandledExcLogStr() noexcept
29 return "Unhandled exception.";
32 constexpr bt2c::CStringView unhandledExcLogTag() noexcept
34 return "PLUGIN-DEV-HPP";
38 * Base class of any component class bridge.
40 * `UserCompClsT` is the actual C++ user component class and `LibTypesT`
41 * is a structure offering the following specific library types:
44 * Self component class.
50 * Self component configuration.
52 template <typename UserCompClsT, typename LibTypesT>
56 using _LibSelfCompPtr = typename LibTypesT::SelfComp *;
59 static UserCompClsT& userCompFromLibSelfCompPtr(const _LibSelfCompPtr libSelfCompPtr) noexcept
61 return wrap(libSelfCompPtr).template data<UserCompClsT>();
64 static bt_component_class_initialize_method_status init(const _LibSelfCompPtr libSelfCompPtr,
65 typename LibTypesT::SelfCompCfg *,
66 const bt_value * const libParamsPtr,
69 const auto selfComp = wrap(libSelfCompPtr);
72 const auto comp = new UserCompClsT {selfComp, wrap(libParamsPtr).asMap()};
75 } catch (const std::bad_alloc&) {
76 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
77 } catch (const Error&) {
78 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
80 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, static_cast<int>(selfComp.loggingLevel()),
81 unhandledExcLogTag(), unhandledExcLogStr());
82 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
85 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
88 static void finalize(const _LibSelfCompPtr libSelfCompPtr) noexcept
90 delete &userCompFromLibSelfCompPtr(libSelfCompPtr);
93 static bt_component_class_get_supported_mip_versions_method_status
94 getSupportedMipVersions(typename LibTypesT::SelfCompCls * const libSelfCompClsPtr,
95 const bt_value * const libParamsPtr, void *,
96 const bt_logging_level logLevel,
97 bt_integer_range_set_unsigned * const libSupportedVersionsPtr) noexcept
100 UserCompClsT::getSupportedMipVersions(wrap(libSelfCompClsPtr), wrap(libParamsPtr),
101 static_cast<LoggingLevel>(logLevel),
102 wrap(libSupportedVersionsPtr));
103 return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_OK;
104 } catch (const std::bad_alloc&) {
105 return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_MEMORY_ERROR;
106 } catch (const Error&) {
107 return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_ERROR;
109 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, static_cast<int>(logLevel), unhandledExcLogTag(),
110 unhandledExcLogStr());
111 return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_ERROR;
115 static bt_component_class_query_method_status
116 query(typename LibTypesT::SelfCompCls * const libSelfCompClsPtr,
117 bt_private_query_executor * const libPrivQueryExecPtr, const char * const object,
118 const bt_value * const libParamsPtr, void *,
119 const bt_value ** const libResultPtr) noexcept
121 const auto privQueryExec = wrap(libPrivQueryExecPtr);
124 auto result = UserCompClsT::query(wrap(libSelfCompClsPtr), privQueryExec, object,
127 *libResultPtr = result.release().libObjPtr();
128 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
129 } catch (const TryAgain&) {
130 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_AGAIN;
131 } catch (const UnknownObject&) {
132 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
133 } catch (const std::bad_alloc&) {
134 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
135 } catch (const Error&) {
136 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
138 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING, static_cast<int>(privQueryExec.loggingLevel()),
139 unhandledExcLogTag(), unhandledExcLogStr());
140 return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
145 template <typename SpecCompClsBridgeT, typename LibTypesT>
146 struct CompClsBridgeWithInputPorts
148 static bt_component_class_port_connected_method_status
149 inputPortConnected(typename LibTypesT::SelfComp * const libSelfCompPtr,
150 bt_self_component_port_input * const libSelfCompPortPtr,
151 const bt_port_output * const libOtherPortPtr) noexcept
154 SpecCompClsBridgeT::userCompFromLibSelfCompPtr(libSelfCompPtr)
155 .inputPortConnected(wrap(libSelfCompPortPtr), wrap(libOtherPortPtr));
156 } catch (const std::bad_alloc&) {
157 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_MEMORY_ERROR;
158 } catch (const Error&) {
159 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
161 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
162 static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
163 unhandledExcLogTag(), unhandledExcLogStr());
164 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
167 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
171 template <typename SpecCompClsBridgeT, typename LibTypesT>
172 struct CompClsBridgeWithOutputPorts
174 static bt_component_class_port_connected_method_status
175 outputPortConnected(typename LibTypesT::SelfComp * const libSelfCompPtr,
176 bt_self_component_port_output * const libSelfCompPortPtr,
177 const bt_port_input * const libOtherPortPtr) noexcept
180 SpecCompClsBridgeT::userCompFromLibSelfCompPtr(libSelfCompPtr)
181 .outputPortConnected(wrap(libSelfCompPortPtr), wrap(libOtherPortPtr));
182 } catch (const std::bad_alloc&) {
183 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_MEMORY_ERROR;
184 } catch (const Error&) {
185 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
187 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
188 static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
189 unhandledExcLogTag(), unhandledExcLogStr());
190 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
193 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
197 struct SrcCompClsLibTypes final
199 using SelfCompCls = bt_self_component_class_source;
200 using SelfComp = bt_self_component_source;
201 using SelfCompCfg = bt_self_component_source_configuration;
204 template <typename UserCompClsT>
205 class SrcCompClsBridge final :
206 public CompClsBridge<UserCompClsT, SrcCompClsLibTypes>,
207 public CompClsBridgeWithOutputPorts<SrcCompClsBridge<UserCompClsT>, SrcCompClsLibTypes>
211 struct FltCompClsLibTypes final
213 using SelfCompCls = bt_self_component_class_filter;
214 using SelfComp = bt_self_component_filter;
215 using SelfCompCfg = bt_self_component_filter_configuration;
218 template <typename UserCompClsT>
219 class FltCompClsBridge final :
220 public CompClsBridge<UserCompClsT, FltCompClsLibTypes>,
221 public CompClsBridgeWithInputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsLibTypes>,
222 public CompClsBridgeWithOutputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsLibTypes>
226 struct SinkCompClsLibTypes final
228 using SelfCompCls = bt_self_component_class_sink;
229 using SelfComp = bt_self_component_sink;
230 using SelfCompCfg = bt_self_component_sink_configuration;
233 template <typename UserCompClsT>
234 class SinkCompClsBridge final :
235 CompClsBridge<UserCompClsT, SinkCompClsLibTypes>,
236 CompClsBridgeWithInputPorts<SinkCompClsBridge<UserCompClsT>, SinkCompClsLibTypes>
239 using CompClsBridge<UserCompClsT, SinkCompClsLibTypes>::userCompFromLibSelfCompPtr;
242 static bt_component_class_sink_consume_method_status
243 consume(bt_self_component_sink * const libSelfCompPtr) noexcept
246 if (userCompFromLibSelfCompPtr(libSelfCompPtr).consume()) {
247 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
249 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
251 } catch (const TryAgain&) {
252 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
253 } catch (const std::bad_alloc&) {
254 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
255 } catch (const Error&) {
256 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
258 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
259 static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
260 unhandledExcLogTag(), unhandledExcLogStr());
261 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
265 static bt_component_class_sink_graph_is_configured_method_status
266 graphIsConfigured(bt_self_component_sink * const libSelfCompPtr) noexcept
269 userCompFromLibSelfCompPtr(libSelfCompPtr).graphIsConfigured();
270 } catch (const std::bad_alloc&) {
271 return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_MEMORY_ERROR;
272 } catch (const Error&) {
273 return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
275 BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
276 static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
277 unhandledExcLogTag(), unhandledExcLogStr());
278 return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
283 template <typename UserMsgIterT>
284 class MsgIterClsBridge final
288 userMsgIterFromLibSelfMsgIterPtr(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
290 return bt2::wrap(libSelfMsgIterPtr).data<UserMsgIterT>();
293 static bt_message_iterator_class_initialize_method_status
294 init(bt_self_message_iterator * const libSelfMsgIterPtr,
295 bt_self_message_iterator_configuration * const libSelfMsgIterConfigPtr,
296 bt_self_component_port_output * const libSelfCompPortPtr) noexcept
298 const auto selfMsgIter = bt2::wrap(libSelfMsgIterPtr);
301 const auto msgIter = new UserMsgIterT {selfMsgIter, bt2::wrap(libSelfMsgIterConfigPtr),
302 bt2::wrap(libSelfCompPortPtr)};
304 selfMsgIter.data(*msgIter);
305 } catch (const std::bad_alloc&) {
306 return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
307 } catch (const bt2::Error&) {
308 return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
310 BT_LOG_WRITE_CUR_LVL(
312 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
313 unhandledExcLogTag(), unhandledExcLogStr());
314 return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
317 return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
320 static void finalize(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
322 delete &userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr);
325 static bt_message_iterator_class_next_method_status
326 next(bt_self_message_iterator * const libSelfMsgIterPtr, bt_message_array_const libMsgsPtr,
327 const uint64_t capacity, uint64_t * const count) noexcept
330 auto msgArray = bt2::ConstMessageArray::wrapEmpty(libMsgsPtr, capacity);
331 auto& msgIter = userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr);
333 msgIter.next(msgArray);
334 *count = msgArray.release();
336 if (G_LIKELY(*count > 0)) {
337 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
339 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
341 } catch (const bt2::TryAgain&) {
342 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
343 } catch (const std::bad_alloc&) {
344 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
345 } catch (const bt2::Error&) {
346 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
348 BT_LOG_WRITE_CUR_LVL(
350 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
351 unhandledExcLogTag(), unhandledExcLogStr());
352 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
356 static bt_message_iterator_class_can_seek_beginning_method_status
357 canSeekBeginning(bt_self_message_iterator * const libSelfMsgIterPtr,
358 bt_bool * const canSeek) noexcept
361 *canSeek = static_cast<bt_bool>(
362 userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).canSeekBeginning());
363 } catch (const bt2::TryAgain&) {
364 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_AGAIN;
365 } catch (const std::bad_alloc&) {
366 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_MEMORY_ERROR;
367 } catch (const bt2::Error&) {
368 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR;
370 BT_LOG_WRITE_CUR_LVL(
372 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
373 unhandledExcLogTag(), unhandledExcLogStr());
374 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR;
377 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_OK;
380 static bt_message_iterator_class_seek_beginning_method_status
381 seekBeginning(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
384 userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).seekBeginning();
385 } catch (const bt2::TryAgain&) {
386 return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_AGAIN;
387 } catch (const std::bad_alloc&) {
388 return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_MEMORY_ERROR;
389 } catch (const bt2::Error&) {
390 return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR;
392 BT_LOG_WRITE_CUR_LVL(
394 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
395 unhandledExcLogTag(), unhandledExcLogStr());
396 return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR;
399 return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_OK;
402 static bt_message_iterator_class_can_seek_ns_from_origin_method_status
403 canSeekNsFromOrigin(bt_self_message_iterator * const libSelfMsgIterPtr,
404 const std::int64_t nsFromOrigin, bt_bool * const canSeek) noexcept
407 *canSeek = static_cast<bt_bool>(userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr)
408 .canSeekNsFromOrigin(nsFromOrigin));
409 } catch (const bt2::TryAgain&) {
410 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_AGAIN;
411 } catch (const std::bad_alloc&) {
412 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_MEMORY_ERROR;
413 } catch (const bt2::Error&) {
414 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
416 BT_LOG_WRITE_CUR_LVL(
418 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
419 unhandledExcLogTag(), unhandledExcLogStr());
420 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
423 return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK;
426 static bt_message_iterator_class_seek_ns_from_origin_method_status
427 seekNsFromOrigin(bt_self_message_iterator * const libSelfMsgIterPtr,
428 const std::int64_t nsFromOrigin) noexcept
431 userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).seekNsFromOrigin(nsFromOrigin);
432 } catch (const bt2::TryAgain&) {
433 return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_AGAIN;
434 } catch (const std::bad_alloc&) {
435 return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_MEMORY_ERROR;
436 } catch (const bt2::Error&) {
437 return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
439 BT_LOG_WRITE_CUR_LVL(
441 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
442 unhandledExcLogTag(), unhandledExcLogStr());
443 return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
446 return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK;
450 } /* namespace internal */
452 template <typename UserMessageIteratorT, typename UserComponentT>
453 class UserMessageIterator;
456 * Base class of any user component.
458 * See the specific `bt2::UserSourceComponent`,
459 * `bt2::UserFilterComponent`, and `bt2::UserSinkComponent`.
461 template <typename SelfCompT>
464 /* Give a related message iterator access to this logger */
465 template <typename, typename>
466 friend class UserMessageIterator;
469 explicit UserComponent(const SelfCompT selfComp, const std::string& logTag) :
470 _mLogger {selfComp, fmt::format("{}/[{}]", logTag, selfComp.name())}, _mSelfComp {selfComp}
475 bt2c::CStringView _name() const noexcept
477 return _mSelfComp.name();
480 LoggingLevel _loggingLevel() const noexcept
482 return _mSelfComp.loggingLevel();
485 std::uint64_t _graphMipVersion() const noexcept
487 return _mSelfComp.graphMipVersion();
490 SelfCompT _selfComp() noexcept
495 bt2c::Logger _mLogger;
498 SelfCompT _mSelfComp;
502 * Base class of a user source component `UserComponentT` (CRTP).
504 * `UserComponentT::UserComponentT()` must accept a
505 * `bt2::SelfSourceComponent` parameter, which it needs to forward to
506 * bt2::UserSourceComponent::UserSourceComponent(), and a
507 * `bt2::ConstValue` parameter (initialization parameters).
509 template <typename UserComponentT>
510 class UserSourceComponent : public UserComponent<SelfSourceComponent>
513 using _OutputPorts = SelfSourceComponent::OutputPorts;
515 explicit UserSourceComponent(const SelfSourceComponent selfComp, const std::string& logTag) :
516 UserComponent<SelfSourceComponent> {selfComp, logTag}
521 static Value::Shared query(const SelfComponentClass selfCompCls,
522 const PrivateQueryExecutor privQueryExec,
523 const bt2c::CStringView obj, const ConstValue params)
525 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
528 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
529 const ConstValue params, const LoggingLevel loggingLevel,
530 const UnsignedIntegerRangeSet ranges)
532 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
535 void outputPortConnected(const SelfComponentOutputPort outputPort,
536 const ConstInputPort inputPort)
538 static_cast<UserComponentT&>(*this).outputPortConnected(outputPort, inputPort);
543 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
546 throw UnknownObject {};
550 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
551 const UnsignedIntegerRangeSet ranges)
553 ranges.addRange(0, 0);
557 void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
561 template <typename DataT>
562 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT * const data)
564 return this->_selfComp().addOutputPort(name, data);
567 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
569 return this->_selfComp().addOutputPort(name);
572 _OutputPorts _outputPorts() noexcept
574 return this->_selfComp().outputPorts();
579 * Base class of a user filter component `UserComponentT` (CRTP).
581 * `UserComponentT::UserComponentT()` must accept a
582 * `bt2::SelfFilterComponent` parameter, which it needs to forward to
583 * bt2::UserFilterComponent::UserFilterComponent(), and a
584 * `bt2::ConstValue` parameter (initialization parameters).
586 template <typename UserComponentT>
587 class UserFilterComponent : public UserComponent<SelfFilterComponent>
590 using _InputPorts = SelfFilterComponent::InputPorts;
591 using _OutputPorts = SelfFilterComponent::OutputPorts;
593 explicit UserFilterComponent(const SelfFilterComponent selfComp, const std::string& logTag) :
594 UserComponent<SelfFilterComponent> {selfComp, logTag}
599 static Value::Shared query(const SelfComponentClass selfCompCls,
600 const PrivateQueryExecutor privQueryExec,
601 const bt2c::CStringView obj, const ConstValue params)
603 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
606 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
607 const ConstValue params, const LoggingLevel loggingLevel,
608 const UnsignedIntegerRangeSet ranges)
610 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
613 void inputPortConnected(const SelfComponentInputPort inputPort,
614 const ConstOutputPort outputPort)
616 static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
619 void outputPortConnected(const SelfComponentOutputPort outputPort,
620 const ConstInputPort inputPort)
622 static_cast<UserComponentT&>(*this)._outputPortConnected(outputPort, inputPort);
627 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
630 throw UnknownObject {};
634 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
635 const UnsignedIntegerRangeSet ranges)
637 ranges.addRange(0, 0);
641 void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
646 void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
650 template <typename DataT>
651 _OutputPorts::Port _addInputPort(const bt2c::CStringView name, DataT * const data)
653 return this->_selfComp().addInputPort(name, data);
656 _InputPorts::Port _addInputPort(const bt2c::CStringView name)
658 return this->_selfComp().addInputPort(name);
661 _InputPorts _inputPorts() noexcept
663 return this->_selfComp().inputPorts();
666 template <typename DataT>
667 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT * const data)
669 return this->_selfComp().addOutputPort(name, data);
672 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
674 return this->_selfComp().addOutputPort(name);
677 _OutputPorts _outputPorts() noexcept
679 return this->_selfComp().outputPorts();
684 * Base class of a user sink component `UserComponentT` (CRTP).
686 * `UserComponentT::UserComponentT()` must accept a
687 * `bt2::SelfSinkComponent` parameter, which it needs to forward to
688 * bt2::UserSinkComponent::UserSinkComponent(), and a `bt2::ConstValue`
689 * parameter (initialization parameters).
691 * `UserComponentT` must implement:
695 * This method returns `true` if the sink component still needs to
696 * consume, or `false` if it's finished.
698 template <typename UserComponentT>
699 class UserSinkComponent : public UserComponent<SelfSinkComponent>
702 using _InputPorts = SelfSinkComponent::InputPorts;
704 explicit UserSinkComponent(const SelfSinkComponent selfComp, const std::string& logTag) :
705 UserComponent<SelfSinkComponent> {selfComp, logTag}
710 static Value::Shared query(const SelfComponentClass selfCompCls,
711 const PrivateQueryExecutor privQueryExec,
712 const bt2c::CStringView obj, const ConstValue params)
714 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
717 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
718 const ConstValue params, const LoggingLevel loggingLevel,
719 const UnsignedIntegerRangeSet ranges)
721 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
724 void graphIsConfigured()
726 static_cast<UserComponentT&>(*this)._graphIsConfigured();
729 void inputPortConnected(const SelfComponentInputPort inputPort,
730 const ConstOutputPort outputPort)
732 static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
737 return static_cast<UserComponentT&>(*this)._consume();
742 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
745 throw UnknownObject {};
749 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
750 const UnsignedIntegerRangeSet ranges)
752 ranges.addRange(0, 0);
756 void _graphIsConfigured()
761 void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
765 MessageIterator::Shared _createMessageIterator(const _InputPorts::Port port)
767 return this->_selfComp().createMessageIterator(port);
770 template <typename DataT>
771 _InputPorts::Port _addInputPort(const bt2c::CStringView name, DataT * const data)
773 return this->_selfComp().addInputPort(name, data);
776 _InputPorts::Port _addInputPort(const bt2c::CStringView name)
778 return this->_selfComp().addInputPort(name);
781 _InputPorts _inputPorts() noexcept
783 return this->_selfComp().inputPorts();
788 * Base class of a user message iterator `UserMessageIteratorT` (CRTP)
789 * of which the parent user component class is `UserComponentT`.
791 * `UserMessageIteratorT::UserMessageIteratorT()` must accept a
792 * `bt2::SelfMessageIterator` parameter, which it needs to forward to
793 * bt2::UserMessageIterator::UserMessageIterator().
795 * The public next() method below (called by the bridge) implements the
796 * very common pattern of appending messages into the output array, and,
799 * If it catches a `bt2::TryAgain` exception:
800 * If the message array isn't empty, transform this into a success
805 * If it catches an error:
806 * If the message array isn't empty, transform this into a success
807 * (don't throw), but save the error of the current thread and the
808 * type of error to throw the next time the user calls next().
812 * `UserMessageIteratorT` must implement:
814 * void _next(bt2::ConstMessageArray& messages);
816 * This method fills `messages` with at most `messages.capacity()`
817 * messages and may throw `bt2::TryAgain` or a valid error whenever.
818 * Leaving an empty `messages` means the end of iteration.
820 template <typename UserMessageIteratorT, typename UserComponentT>
821 class UserMessageIterator
824 /* Type of `_mExcToThrowType` */
825 enum class _ExcToThrowType
833 explicit UserMessageIterator(const SelfMessageIterator selfMsgIter,
834 const std::string& logTagSuffix) :
835 _mSelfMsgIter {selfMsgIter},
836 _mLogger {selfMsgIter,
837 fmt::format("{}/{}", this->_component()._mLogger.tag(), logTagSuffix)}
842 ~UserMessageIterator()
847 void next(bt2::ConstMessageArray& messages)
849 /* Any saved error? Now is the time to throw */
850 if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::NONE)) {
851 /* Move `_mSavedLibError`, if any, as current thread error */
852 if (_mSavedLibError) {
853 BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(_mSavedLibError);
856 /* Throw the corresponding exception */
857 if (_mExcToThrowType == _ExcToThrowType::ERROR) {
860 BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MEM_ERROR);
861 throw bt2::MemoryError {};
866 * When catching some exception below, if our message array
867 * isn't empty, then return immediately before throwing to
868 * provide those messages to downstream.
870 * When catching an error, also save the current thread error,
871 * if any, so that we can restore it later (see the beginning of
874 BT_ASSERT_DBG(_mExcToThrowType == _ExcToThrowType::NONE);
877 this->_userObj()._next(messages);
879 /* We're done: everything below is exception handling */
881 } catch (const bt2::TryAgain&) {
882 if (messages.isEmpty()) {
885 } catch (const std::bad_alloc&) {
886 if (messages.isEmpty()) {
890 _mExcToThrowType = _ExcToThrowType::MEM_ERROR;
891 } catch (const bt2::Error&) {
892 if (messages.isEmpty()) {
896 _mExcToThrowType = _ExcToThrowType::ERROR;
899 if (_mExcToThrowType != _ExcToThrowType::NONE) {
901 "An error occurred, but there are {} messages to return: delaying the error reporting.",
903 BT_ASSERT(!_mSavedLibError);
904 _mSavedLibError = bt_current_thread_take_error();
908 bool canSeekBeginning()
911 return this->_userObj()._canSeekBeginning();
917 return this->_userObj()._seekBeginning();
920 bool canSeekNsFromOrigin(const std::int64_t nsFromOrigin)
923 return this->_userObj()._canSeekNsFromOrigin(nsFromOrigin);
926 void seekNsFromOrigin(const std::int64_t nsFromOrigin)
929 this->_userObj()._seekNsFromOrigin(nsFromOrigin);
934 bool _canSeekBeginning() noexcept
940 void _seekBeginning() noexcept
945 bool _canSeekNsFromOrigin(std::int64_t) noexcept
951 void _seekNsFromOrigin(std::int64_t) noexcept
955 MessageIterator::Shared _createMessageIterator(const SelfComponentInputPort port)
957 return _mSelfMsgIter.createMessageIterator(port);
960 UserComponentT& _component() noexcept
962 return _mSelfMsgIter.component().template data<UserComponentT>();
965 SelfComponentOutputPort _port() noexcept
967 return _mSelfMsgIter.port();
970 bool _isInterrupted() const noexcept
972 return _mSelfMsgIter.isInterrupted();
976 UserMessageIteratorT& _userObj() noexcept
978 return static_cast<UserMessageIteratorT&>(*this);
981 void _resetError() noexcept
983 _mExcToThrowType = _ExcToThrowType::NONE;
985 if (_mSavedLibError) {
986 bt_error_release(_mSavedLibError);
990 SelfMessageIterator _mSelfMsgIter;
993 * next() may accumulate messages, and then catch an error before
994 * returning. In that case, it saves the error of the current thread
995 * here so that it can return its accumulated messages and throw the
998 * It also saves the type of the exception to throw the next time.
1000 _ExcToThrowType _mExcToThrowType = _ExcToThrowType::NONE;
1001 const bt_error *_mSavedLibError = nullptr;
1004 bt2c::Logger _mLogger;
1007 } /* namespace bt2 */
1009 #define BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID( \
1010 _pluginId, _componentClassId, _name, _userComponentClass, _userMessageIteratorClass) \
1011 BT_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID( \
1012 _pluginId, _componentClassId, _name, \
1013 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::next); \
1014 BT_PLUGIN_SOURCE_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID( \
1015 _pluginId, _componentClassId, bt2::internal::SrcCompClsBridge<_userComponentClass>::init); \
1016 BT_PLUGIN_SOURCE_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID( \
1017 _pluginId, _componentClassId, \
1018 bt2::internal::SrcCompClsBridge<_userComponentClass>::finalize); \
1019 BT_PLUGIN_SOURCE_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID( \
1020 _pluginId, _componentClassId, \
1021 bt2::internal::SrcCompClsBridge<_userComponentClass>::getSupportedMipVersions); \
1022 BT_PLUGIN_SOURCE_COMPONENT_CLASS_OUTPUT_PORT_CONNECTED_METHOD_WITH_ID( \
1023 _pluginId, _componentClassId, \
1024 bt2::internal::SrcCompClsBridge<_userComponentClass>::outputPortConnected); \
1025 BT_PLUGIN_SOURCE_COMPONENT_CLASS_QUERY_METHOD_WITH_ID( \
1026 _pluginId, _componentClassId, \
1027 bt2::internal::SrcCompClsBridge<_userComponentClass>::query); \
1028 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_WITH_ID( \
1029 _pluginId, _componentClassId, \
1030 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::init); \
1031 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD_WITH_ID( \
1032 _pluginId, _componentClassId, \
1033 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::finalize); \
1034 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHODS_WITH_ID( \
1035 _pluginId, _componentClassId, \
1036 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::seekBeginning, \
1037 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::canSeekBeginning); \
1038 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHODS_WITH_ID( \
1039 _pluginId, _componentClassId, \
1040 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::seekNsFromOrigin, \
1041 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::canSeekNsFromOrigin);
1043 #define BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID( \
1044 _pluginId, _componentClassId, _name, _userComponentClass, _userMessageIteratorClass) \
1045 BT_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID( \
1046 _pluginId, _componentClassId, _name, \
1047 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::next); \
1048 BT_PLUGIN_FILTER_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID( \
1049 _pluginId, _componentClassId, bt2::internal::FltCompClsBridge<_userComponentClass>::init); \
1050 BT_PLUGIN_FILTER_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID( \
1051 _pluginId, _componentClassId, \
1052 bt2::internal::FltCompClsBridge<_userComponentClass>::finalize); \
1053 BT_PLUGIN_FILTER_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID( \
1054 _pluginId, _componentClassId, \
1055 bt2::internal::FltCompClsBridge<_userComponentClass>::getSupportedMipVersions); \
1056 BT_PLUGIN_FILTER_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD_WITH_ID( \
1057 _pluginId, _componentClassId, \
1058 bt2::internal::FltCompClsBridge<_userComponentClass>::inputPortConnected); \
1059 BT_PLUGIN_FILTER_COMPONENT_CLASS_OUTPUT_PORT_CONNECTED_METHOD_WITH_ID( \
1060 _pluginId, _componentClassId, \
1061 bt2::internal::FltCompClsBridge<_userComponentClass>::outputPortConnected); \
1062 BT_PLUGIN_FILTER_COMPONENT_CLASS_QUERY_METHOD_WITH_ID( \
1063 _pluginId, _componentClassId, \
1064 bt2::internal::FltCompClsBridge<_userComponentClass>::query); \
1065 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_WITH_ID( \
1066 _pluginId, _componentClassId, \
1067 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::init); \
1068 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD_WITH_ID( \
1069 _pluginId, _componentClassId, \
1070 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::finalize); \
1071 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHODS_WITH_ID( \
1072 _pluginId, _componentClassId, \
1073 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::seekBeginning, \
1074 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::canSeekBeginning); \
1075 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHODS_WITH_ID( \
1076 _pluginId, _componentClassId, \
1077 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::seekNsFromOrigin, \
1078 bt2::internal::MsgIterClsBridge<_userMessageIteratorClass>::canSeekNsFromOrigin);
1080 #define BT_CPP_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID(_pluginId, _componentClassId, _name, \
1081 _userComponentClass) \
1082 BT_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID( \
1083 _pluginId, _componentClassId, _name, \
1084 bt2::internal::SinkCompClsBridge<_userComponentClass>::consume); \
1085 BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID( \
1086 _pluginId, _componentClassId, \
1087 bt2::internal::SinkCompClsBridge<_userComponentClass>::init); \
1088 BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID( \
1089 _pluginId, _componentClassId, \
1090 bt2::internal::SinkCompClsBridge<_userComponentClass>::finalize); \
1091 BT_PLUGIN_SINK_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID( \
1092 _pluginId, _componentClassId, \
1093 bt2::internal::SinkCompClsBridge<_userComponentClass>::getSupportedMipVersions); \
1094 BT_PLUGIN_SINK_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD_WITH_ID( \
1095 _pluginId, _componentClassId, \
1096 bt2::internal::SinkCompClsBridge<_userComponentClass>::inputPortConnected); \
1097 BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD_WITH_ID( \
1098 _pluginId, _componentClassId, \
1099 bt2::internal::SinkCompClsBridge<_userComponentClass>::graphIsConfigured); \
1100 BT_PLUGIN_SINK_COMPONENT_CLASS_QUERY_METHOD_WITH_ID( \
1101 _pluginId, _componentClassId, \
1102 bt2::internal::SinkCompClsBridge<_userComponentClass>::query);
1104 #define BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS(_name, _userComponentClass, \
1105 _userMessageIteratorClass) \
1106 BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass, \
1107 _userMessageIteratorClass)
1109 #define BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS(_name, _userComponentClass, \
1110 _userMessageIteratorClass) \
1111 BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass, \
1112 _userMessageIteratorClass)
1114 #define BT_CPP_PLUGIN_SINK_COMPONENT_CLASS(_name, _userComponentClass) \
1115 BT_CPP_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass)
1117 #endif /* BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP */