cpp-common/bt2: add component class creation methods
[babeltrace.git] / src / cpp-common / bt2 / component-class-dev.hpp
CommitLineData
212313d9
SM
1/*
2 * Copyright (c) 2024 EfficiOS, Inc.
3 *
4 * SPDX-License-Identifier: MIT
5 */
6
7#ifndef BABELTRACE_CPP_COMMON_BT2_COMPONENT_CLASS_DEV_HPP
8#define BABELTRACE_CPP_COMMON_BT2_COMPONENT_CLASS_DEV_HPP
9
10#include <cstdint>
11
12#include <glib.h>
13
14#include "cpp-common/bt2c/c-string-view.hpp"
15#include "cpp-common/bt2c/logging.hpp"
16#include "cpp-common/vendor/fmt/core.h"
17
18#include "exc.hpp"
ee137c4e 19#include "internal/comp-cls-bridge.hpp"
212313d9
SM
20#include "private-query-executor.hpp"
21#include "self-component-port.hpp"
22
23namespace bt2 {
24
25template <typename UserMessageIteratorT, typename UserComponentT>
26class UserMessageIterator;
27
28/*
29 * Base class of any user component.
30 *
31 * See the specific `bt2::UserSourceComponent`,
32 * `bt2::UserFilterComponent`, and `bt2::UserSinkComponent`.
33 */
34template <typename SelfCompT, typename InitDataT, typename QueryDataT>
35class UserComponent
36{
37 /* Give a related message iterator access to this logger */
38 template <typename, typename>
39 friend class UserMessageIterator;
40
41public:
42 using InitData = InitDataT;
43 using QueryData = QueryDataT;
44
ee137c4e
PP
45 static constexpr auto description = nullptr;
46 static constexpr auto help = nullptr;
47
212313d9
SM
48protected:
49 explicit UserComponent(const SelfCompT selfComp, const std::string& logTag) :
50 _mLogger {selfComp, fmt::format("{}/[{}]", logTag, selfComp.name())}, _mSelfComp {selfComp}
51 {
52 }
53
54protected:
55 bt2c::CStringView _name() const noexcept
56 {
57 return _mSelfComp.name();
58 }
59
60 LoggingLevel _loggingLevel() const noexcept
61 {
62 return _mSelfComp.loggingLevel();
63 }
64
65 std::uint64_t _graphMipVersion() const noexcept
66 {
67 return _mSelfComp.graphMipVersion();
68 }
69
70 SelfCompT _selfComp() noexcept
71 {
72 return _mSelfComp;
73 }
74
75 bt2c::Logger _mLogger;
76
77private:
78 SelfCompT _mSelfComp;
79};
80
81/*
82 * Base class of a user source component `UserComponentT` (CRTP).
83 *
ee137c4e
PP
84 * `UserComponentT` must define a static member `name` of type
85 * `const char *` to provide the name of the component class.
86 *
87 * `UserComponentT` may define the static members `description` and/or
88 * `help` of type `const char *` to provide the description and/or help
89 * of the component class.
90 *
212313d9
SM
91 * UserComponentT::UserComponentT() must accept, in this order:
92 *
93 * 1. A `bt2::SelfSourceComponent` parameter, which it needs to forward
94 * to bt2::UserSourceComponent::UserSourceComponent().
95 *
96 * 2. A `bt2::ConstValue` parameter (the initialization parameters).
97 *
98 * 3. An `InitDataT *` parameter (the initialization method data).
99 *
100 * `UserMessageIteratorT`, the message iterator class to use, must inherit
101 * `UserMessageIterator`.
102 *
103 * UserComponentT::_query() receives a query method data pointer of type
104 * `QueryDataT *` as its last parameter.
105 */
106template <typename UserComponentT, typename UserMessageIteratorT, typename InitDataT = void,
107 typename QueryDataT = void>
108class UserSourceComponent : public UserComponent<SelfSourceComponent, InitDataT, QueryDataT>
109{
110 static_assert(std::is_base_of<UserMessageIterator<UserMessageIteratorT, UserComponentT>,
111 UserMessageIteratorT>::value,
112 "`UserMessageIteratorT` inherits `UserMessageIterator`");
113
114public:
115 using MessageIterator = UserMessageIteratorT;
116
117protected:
118 using _OutputPorts = SelfSourceComponent::OutputPorts;
119
120 explicit UserSourceComponent(const SelfSourceComponent selfComp, const std::string& logTag) :
121 UserComponent<SelfSourceComponent, InitDataT, QueryDataT> {selfComp, logTag}
122 {
123 }
124
125public:
126 static Value::Shared query(const SelfComponentClass selfCompCls,
127 const PrivateQueryExecutor privQueryExec,
128 const bt2c::CStringView obj, const ConstValue params,
129 QueryDataT * const data)
130 {
131 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params, data);
132 }
133
134 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
135 const ConstValue params, const LoggingLevel loggingLevel,
136 const UnsignedIntegerRangeSet ranges)
137 {
138 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
139 }
140
141 void outputPortConnected(const SelfComponentOutputPort outputPort,
142 const ConstInputPort inputPort)
143 {
144 static_cast<UserComponentT&>(*this)._outputPortConnected(outputPort, inputPort);
145 }
146
147protected:
148 /* Overloadable */
149 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
150 ConstValue, QueryDataT *)
151 {
152 throw UnknownObject {};
153 }
154
155 /* Overloadable */
156 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
157 const UnsignedIntegerRangeSet ranges)
158 {
159 ranges.addRange(0, 0);
160 }
161
162 /* Overloadable */
163 void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
164 {
165 }
166
167 template <typename DataT>
168 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT& data)
169 {
170 return this->_selfComp().addOutputPort(name, data);
171 }
172
173 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
174 {
175 return this->_selfComp().addOutputPort(name);
176 }
177
178 _OutputPorts _outputPorts() noexcept
179 {
180 return this->_selfComp().outputPorts();
181 }
182};
183
184/*
185 * Base class of a user filter component `UserComponentT` (CRTP).
186 *
ee137c4e
PP
187 * `UserComponentT` must define a static member `name` of type
188 * `const char *` to provide the name of the component class.
189 *
190 * `UserComponentT` may define the static members `description` and/or
191 * `help` of type `const char *` to provide the description and/or help
192 * of the component class.
193 *
212313d9
SM
194 * UserComponentT::UserComponentT() must accept, in this order:
195 *
196 * 1. A `bt2::SelfFilterComponent` parameter, which it needs to forward
197 * to bt2::UserFilterComponent::UserFilterComponent().
198 *
199 * 2. A `bt2::ConstValue` parameter (the initialization parameters).
200 *
201 * 3. An `InitDataT *` parameter (the initialization method data).
202 *
203 * `UserMessageIteratorT`, the message iterator class to use, must inherit
204 * `UserMessageIterator`.
205 *
206 * UserComponentT::_query() receives a query method data pointer of type
207 * `QueryDataT *` as its last parameter.
208 */
209template <typename UserComponentT, typename UserMessageIteratorT, typename InitDataT = void,
210 typename QueryDataT = void>
211class UserFilterComponent : public UserComponent<SelfFilterComponent, InitDataT, QueryDataT>
212{
213 static_assert(std::is_base_of<UserMessageIterator<UserMessageIteratorT, UserComponentT>,
214 UserMessageIteratorT>::value,
215 "`UserMessageIteratorT` inherits `UserMessageIterator`");
216
217public:
218 using MessageIterator = UserMessageIteratorT;
219
220protected:
221 using _InputPorts = SelfFilterComponent::InputPorts;
222 using _OutputPorts = SelfFilterComponent::OutputPorts;
223
224 explicit UserFilterComponent(const SelfFilterComponent selfComp, const std::string& logTag) :
225 UserComponent<SelfFilterComponent, InitDataT, QueryDataT> {selfComp, logTag}
226 {
227 }
228
229public:
230 static Value::Shared query(const SelfComponentClass selfCompCls,
231 const PrivateQueryExecutor privQueryExec,
232 const bt2c::CStringView obj, const ConstValue params,
233 QueryDataT * const data)
234 {
235 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params, data);
236 }
237
238 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
239 const ConstValue params, const LoggingLevel loggingLevel,
240 const UnsignedIntegerRangeSet ranges)
241 {
242 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
243 }
244
245 void inputPortConnected(const SelfComponentInputPort inputPort,
246 const ConstOutputPort outputPort)
247 {
248 static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
249 }
250
251 void outputPortConnected(const SelfComponentOutputPort outputPort,
252 const ConstInputPort inputPort)
253 {
254 static_cast<UserComponentT&>(*this)._outputPortConnected(outputPort, inputPort);
255 }
256
257protected:
258 /* Overloadable */
259 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
260 ConstValue, QueryDataT *)
261 {
262 throw UnknownObject {};
263 }
264
265 /* Overloadable */
266 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
267 const UnsignedIntegerRangeSet ranges)
268 {
269 ranges.addRange(0, 0);
270 }
271
272 /* Overloadable */
273 void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
274 {
275 }
276
277 /* Overloadable */
278 void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
279 {
280 }
281
282 template <typename DataT>
283 _OutputPorts::Port _addInputPort(const bt2c::CStringView name, DataT& data)
284 {
285 return this->_selfComp().addInputPort(name, data);
286 }
287
288 _InputPorts::Port _addInputPort(const bt2c::CStringView name)
289 {
290 return this->_selfComp().addInputPort(name);
291 }
292
293 _InputPorts _inputPorts() noexcept
294 {
295 return this->_selfComp().inputPorts();
296 }
297
298 template <typename DataT>
299 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT& data)
300 {
301 return this->_selfComp().addOutputPort(name, data);
302 }
303
304 _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
305 {
306 return this->_selfComp().addOutputPort(name);
307 }
308
309 _OutputPorts _outputPorts() noexcept
310 {
311 return this->_selfComp().outputPorts();
312 }
313};
314
315/*
316 * Base class of a user sink component `UserComponentT` (CRTP).
317 *
ee137c4e
PP
318 * `UserComponentT` must define a static member `name` of type
319 * `const char *` to provide the name of the component class.
320 *
321 * `UserComponentT` may define the static members `description` and/or
322 * `help` of type `const char *` to provide the description and/or help
323 * of the component class.
324 *
212313d9
SM
325 * UserComponentT::UserComponentT() must accept, in this order:
326 *
327 * 1. A `bt2::SelfSinkComponent` parameter, which it needs to forward
328 * to bt2::UserSinkComponent::UserSinkComponent().
329 *
330 * 2. A `bt2::ConstValue` parameter (the initialization parameters).
331 *
332 * 3. An `InitDataT *` parameter (the initialization method data).
333 *
334 * `UserComponentT` must implement:
335 *
336 * bool _consume();
337 *
338 * This method returns `true` if the sink component still needs to
339 * consume, or `false` if it's finished.
340 *
341 * UserComponentT::_query() receives a query method data pointer of type
342 * `QueryDataT *` as its last parameter.
343
344 */
345template <typename UserComponentT, typename InitDataT = void, typename QueryDataT = void>
346class UserSinkComponent : public UserComponent<SelfSinkComponent, InitDataT, QueryDataT>
347{
348protected:
349 using _InputPorts = SelfSinkComponent::InputPorts;
350
351 explicit UserSinkComponent(const SelfSinkComponent selfComp, const std::string& logTag) :
352 UserComponent<SelfSinkComponent, InitDataT, QueryDataT> {selfComp, logTag}
353 {
354 }
355
356public:
357 static Value::Shared query(const SelfComponentClass selfCompCls,
358 const PrivateQueryExecutor privQueryExec,
359 const bt2c::CStringView obj, const ConstValue params,
360 QueryDataT * const data)
361 {
362 return UserComponentT::_query(selfCompCls, privQueryExec, obj, params, data);
363 }
364
365 static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
366 const ConstValue params, const LoggingLevel loggingLevel,
367 const UnsignedIntegerRangeSet ranges)
368 {
369 UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
370 }
371
372 void graphIsConfigured()
373 {
374 static_cast<UserComponentT&>(*this)._graphIsConfigured();
375 }
376
377 void inputPortConnected(const SelfComponentInputPort inputPort,
378 const ConstOutputPort outputPort)
379 {
380 static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
381 }
382
383 bool consume()
384 {
385 return static_cast<UserComponentT&>(*this)._consume();
386 }
387
388protected:
389 /* Overloadable */
390 static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
391 ConstValue, QueryDataT *)
392 {
393 throw UnknownObject {};
394 }
395
396 /* Overloadable */
397 static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
398 const UnsignedIntegerRangeSet ranges)
399 {
400 ranges.addRange(0, 0);
401 }
402
403 /* Overloadable */
404 void _graphIsConfigured()
405 {
406 }
407
408 /* Overloadable */
409 void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
410 {
411 }
412
413 MessageIterator::Shared _createMessageIterator(const _InputPorts::Port port)
414 {
415 return this->_selfComp().createMessageIterator(port);
416 }
417
418 template <typename DataT>
419 _InputPorts::Port _addInputPort(const bt2c::CStringView name, DataT& data)
420 {
421 return this->_selfComp().addInputPort(name, data);
422 }
423
424 _InputPorts::Port _addInputPort(const bt2c::CStringView name)
425 {
426 return this->_selfComp().addInputPort(name);
427 }
428
429 _InputPorts _inputPorts() noexcept
430 {
431 return this->_selfComp().inputPorts();
432 }
433};
434
435/*
436 * Base class of a user message iterator `UserMessageIteratorT` (CRTP)
437 * of which the parent user component class is `UserComponentT`.
438 *
439 * `UserMessageIteratorT::UserMessageIteratorT()` must accept a
440 * `bt2::SelfMessageIterator` parameter, which it needs to forward to
441 * bt2::UserMessageIterator::UserMessageIterator().
442 *
443 * The public next() method below (called by the bridge) implements the
444 * very common pattern of appending messages into the output array, and,
445 * meanwhile:
446 *
447 * If it catches a `bt2::TryAgain` exception:
448 * If the message array isn't empty, transform this into a success
449 * (don't throw).
450 *
451 * Otherwise rethrow.
452 *
453 * If it catches an error:
454 * If the message array isn't empty, transform this into a success
455 * (don't throw), but save the error of the current thread and the
456 * type of error to throw the next time the user calls next().
457 *
458 * Otherwise rethrow.
459 *
460 * `UserMessageIteratorT` must implement:
461 *
462 * void _next(bt2::ConstMessageArray& messages);
463 *
464 * This method fills `messages` with at most `messages.capacity()`
465 * messages and may throw `bt2::TryAgain` or a valid error whenever.
466 * Leaving an empty `messages` means the end of iteration.
467 */
468template <typename UserMessageIteratorT, typename UserComponentT>
469class UserMessageIterator
470{
471private:
472 /* Type of `_mExcToThrowType` */
473 enum class _ExcToThrowType
474 {
475 NONE,
476 ERROR,
477 MEM_ERROR,
478 };
479
480protected:
481 explicit UserMessageIterator(const SelfMessageIterator selfMsgIter,
482 const std::string& logTagSuffix) :
483 _mSelfMsgIter {selfMsgIter},
484 _mLogger {selfMsgIter,
485 fmt::format("{}/{}", this->_component()._mLogger.tag(), logTagSuffix)}
486 {
487 }
488
489public:
490 ~UserMessageIterator()
491 {
492 this->_resetError();
493 }
494
495 void next(bt2::ConstMessageArray& messages)
496 {
497 /* Any saved error? Now is the time to throw */
498 if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::NONE)) {
499 /* Move `_mSavedLibError`, if any, as current thread error */
500 if (_mSavedLibError) {
501 BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(_mSavedLibError);
502 }
503
504 /* Throw the corresponding exception */
505 if (_mExcToThrowType == _ExcToThrowType::ERROR) {
506 throw bt2::Error {};
507 } else {
508 BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MEM_ERROR);
509 throw bt2::MemoryError {};
510 }
511 }
512
513 /*
514 * When catching some exception below, if our message array
515 * isn't empty, then return immediately before throwing to
516 * provide those messages to downstream.
517 *
518 * When catching an error, also save the current thread error,
519 * if any, so that we can restore it later (see the beginning of
520 * this method).
521 */
522 BT_ASSERT_DBG(_mExcToThrowType == _ExcToThrowType::NONE);
523
524 try {
525 this->_userObj()._next(messages);
526
527 /* We're done: everything below is exception handling */
528 return;
529 } catch (const bt2::TryAgain&) {
530 if (messages.isEmpty()) {
531 throw;
532 }
533 } catch (const std::bad_alloc&) {
534 if (messages.isEmpty()) {
535 throw;
536 }
537
538 _mExcToThrowType = _ExcToThrowType::MEM_ERROR;
539 } catch (const bt2::Error&) {
540 if (messages.isEmpty()) {
541 throw;
542 }
543
544 _mExcToThrowType = _ExcToThrowType::ERROR;
545 }
546
547 if (_mExcToThrowType != _ExcToThrowType::NONE) {
548 BT_CPPLOGE(
549 "An error occurred, but there are {} messages to return: delaying the error reporting.",
550 messages.length());
551 BT_ASSERT(!_mSavedLibError);
552 _mSavedLibError = bt_current_thread_take_error();
553 }
554 }
555
556 bool canSeekBeginning()
557 {
558 this->_resetError();
559 return this->_userObj()._canSeekBeginning();
560 }
561
562 void seekBeginning()
563 {
564 this->_resetError();
565 return this->_userObj()._seekBeginning();
566 }
567
568 bool canSeekNsFromOrigin(const std::int64_t nsFromOrigin)
569 {
570 this->_resetError();
571 return this->_userObj()._canSeekNsFromOrigin(nsFromOrigin);
572 }
573
574 void seekNsFromOrigin(const std::int64_t nsFromOrigin)
575 {
576 this->_resetError();
577 this->_userObj()._seekNsFromOrigin(nsFromOrigin);
578 }
579
580protected:
581 /* Overloadable */
582 bool _canSeekBeginning() noexcept
583 {
584 return false;
585 }
586
587 /* Overloadable */
588 void _seekBeginning() noexcept
589 {
590 }
591
592 /* Overloadable */
593 bool _canSeekNsFromOrigin(std::int64_t) noexcept
594 {
595 return false;
596 }
597
598 /* Overloadable */
599 void _seekNsFromOrigin(std::int64_t) noexcept
600 {
601 }
602
603 MessageIterator::Shared _createMessageIterator(const SelfComponentInputPort port)
604 {
605 return _mSelfMsgIter.createMessageIterator(port);
606 }
607
608 UserComponentT& _component() noexcept
609 {
610 return _mSelfMsgIter.component().template data<UserComponentT>();
611 }
612
613 SelfComponentOutputPort _port() noexcept
614 {
615 return _mSelfMsgIter.port();
616 }
617
618 bool _isInterrupted() const noexcept
619 {
620 return _mSelfMsgIter.isInterrupted();
621 }
622
623private:
624 UserMessageIteratorT& _userObj() noexcept
625 {
626 return static_cast<UserMessageIteratorT&>(*this);
627 }
628
629 void _resetError() noexcept
630 {
631 _mExcToThrowType = _ExcToThrowType::NONE;
632
633 if (_mSavedLibError) {
634 bt_error_release(_mSavedLibError);
635 }
636 }
637
638 SelfMessageIterator _mSelfMsgIter;
639
640 /*
641 * next() may accumulate messages, and then catch an error before
642 * returning. In that case, it saves the error of the current thread
643 * here so that it can return its accumulated messages and throw the
644 * next time.
645 *
646 * It also saves the type of the exception to throw the next time.
647 */
648 _ExcToThrowType _mExcToThrowType = _ExcToThrowType::NONE;
649 const bt_error *_mSavedLibError = nullptr;
650
651protected:
652 bt2c::Logger _mLogger;
653};
654
ee137c4e
PP
655namespace internal {
656
657template <typename UserComponentT, typename CompClsBridgeT, typename LibSpecCompClsPtrT,
658 typename AsCompClsFuncT, typename SetInitMethodFuncT, typename SetFinalizeMethodFuncT,
659 typename SetGetSupportedMipVersionsMethodFuncT, typename SetQueryMethodFuncT>
660void setCompClsCommonProps(
661 LibSpecCompClsPtrT * const libSpecCompClsPtr, AsCompClsFuncT&& asCompClsFunc,
662 SetInitMethodFuncT&& setInitMethodFunc, SetFinalizeMethodFuncT&& setFinalizeMethodFunc,
663 SetGetSupportedMipVersionsMethodFuncT&& setGetSupportedMipVersionsMethodFunc,
664 SetQueryMethodFuncT&& setQueryMethodFunc)
665{
666 const auto libCompClsPtr = asCompClsFunc(libSpecCompClsPtr);
667
668 if (UserComponentT::description != nullptr) {
669 const auto status =
670 bt_component_class_set_description(libCompClsPtr, UserComponentT::description);
671
672 if (status == BT_COMPONENT_CLASS_SET_DESCRIPTION_STATUS_MEMORY_ERROR) {
673 throw MemoryError {};
674 }
675 }
676
677 if (UserComponentT::help != nullptr) {
678 const auto status = bt_component_class_set_help(libCompClsPtr, UserComponentT::help);
679
680 if (status == BT_COMPONENT_CLASS_SET_HELP_STATUS_MEMORY_ERROR) {
681 throw MemoryError {};
682 }
683 }
684
685 {
686 const auto status = setInitMethodFunc(libSpecCompClsPtr, CompClsBridgeT::init);
687
688 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
689 }
690
691 {
692 const auto status = setFinalizeMethodFunc(libSpecCompClsPtr, CompClsBridgeT::finalize);
693
694 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
695 }
696
697 {
698 const auto status = setGetSupportedMipVersionsMethodFunc(
699 libSpecCompClsPtr, CompClsBridgeT::getSupportedMipVersions);
700
701 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
702 }
703
704 {
705 const auto status = setQueryMethodFunc(libSpecCompClsPtr, CompClsBridgeT::query);
706
707 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
708 }
709}
710
711template <typename MsgIterClsBridgeT>
712bt_message_iterator_class *createLibMsgIterCls()
713{
714 const auto libMsgIterClsPtr = bt_message_iterator_class_create(MsgIterClsBridgeT::next);
715
716 if (!libMsgIterClsPtr) {
717 throw MemoryError {};
718 }
719
720 {
721 const auto status = bt_message_iterator_class_set_initialize_method(
722 libMsgIterClsPtr, MsgIterClsBridgeT::init);
723
724 BT_ASSERT(status == BT_MESSAGE_ITERATOR_CLASS_SET_METHOD_STATUS_OK);
725 }
726
727 {
728 const auto status = bt_message_iterator_class_set_finalize_method(
729 libMsgIterClsPtr, MsgIterClsBridgeT::finalize);
730
731 BT_ASSERT(status == BT_MESSAGE_ITERATOR_CLASS_SET_METHOD_STATUS_OK);
732 }
733
734 return libMsgIterClsPtr;
735}
736
737template <typename UserComponentT>
738bt_component_class_source *createSourceCompCls()
739{
740 static_assert(
741 std::is_base_of<UserSourceComponent<
742 UserComponentT, typename UserComponentT::MessageIterator,
743 typename UserComponentT::InitData, typename UserComponentT::QueryData>,
744 UserComponentT>::value,
745 "`UserComponentT` inherits `UserSourceComponent`");
746
747 using CompClsBridge = internal::SrcCompClsBridge<UserComponentT>;
748 using MsgIterClsBridge = internal::MsgIterClsBridge<typename UserComponentT::MessageIterator>;
749
750 const auto libMsgIterClsPtr = createLibMsgIterCls<MsgIterClsBridge>();
751 const auto libCompClsPtr =
752 bt_component_class_source_create(UserComponentT::name, libMsgIterClsPtr);
753
754 bt_message_iterator_class_put_ref(libMsgIterClsPtr);
755
756 if (!libCompClsPtr) {
757 throw MemoryError {};
758 }
759
760 setCompClsCommonProps<UserComponentT, CompClsBridge>(
761 libCompClsPtr, bt_component_class_source_as_component_class,
762 bt_component_class_source_set_initialize_method,
763 bt_component_class_source_set_finalize_method,
764 bt_component_class_source_set_get_supported_mip_versions_method,
765 bt_component_class_source_set_query_method);
766
767 {
768 const auto status = bt_component_class_source_set_output_port_connected_method(
769 libCompClsPtr, CompClsBridge::outputPortConnected);
770
771 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
772 }
773
774 return libCompClsPtr;
775}
776
777template <typename UserComponentT>
778bt_component_class_filter *createFilterCompCls()
779{
780 static_assert(
781 std::is_base_of<UserFilterComponent<
782 UserComponentT, typename UserComponentT::MessageIterator,
783 typename UserComponentT::InitData, typename UserComponentT::QueryData>,
784 UserComponentT>::value,
785 "`UserComponentT` inherits `UserFilterComponent`");
786
787 using CompClsBridge = internal::FltCompClsBridge<UserComponentT>;
788 using MsgIterClsBridge = internal::MsgIterClsBridge<typename UserComponentT::MessageIterator>;
789
790 const auto libMsgIterClsPtr = createLibMsgIterCls<MsgIterClsBridge>();
791 const auto libCompClsPtr =
792 bt_component_class_filter_create(UserComponentT::name, libMsgIterClsPtr);
793
794 bt_message_iterator_class_put_ref(libMsgIterClsPtr);
795
796 if (!libCompClsPtr) {
797 throw MemoryError {};
798 }
799
800 setCompClsCommonProps<UserComponentT, CompClsBridge>(
801 libCompClsPtr, bt_component_class_filter_as_component_class,
802 bt_component_class_filter_set_initialize_method,
803 bt_component_class_filter_set_finalize_method,
804 bt_component_class_filter_set_get_supported_mip_versions_method,
805 bt_component_class_filter_set_query_method);
806
807 {
808 const auto status = bt_component_class_filter_set_input_port_connected_method(
809 libCompClsPtr, CompClsBridge::inputPortConnected);
810
811 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
812 }
813
814 {
815 const auto status = bt_component_class_filter_set_output_port_connected_method(
816 libCompClsPtr, CompClsBridge::outputPortConnected);
817
818 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
819 }
820
821 return libCompClsPtr;
822}
823
824template <typename UserComponentT>
825bt_component_class_sink *createSinkCompCls()
826{
827 static_assert(
828 std::is_base_of<UserSinkComponent<UserComponentT, typename UserComponentT::InitData,
829 typename UserComponentT::QueryData>,
830 UserComponentT>::value,
831 "`UserComponentT` inherits `UserSinkComponent`");
832
833 using CompClsBridge = internal::SinkCompClsBridge<UserComponentT>;
834
835 const auto libCompClsPtr =
836 bt_component_class_sink_create(UserComponentT::name, CompClsBridge::consume);
837
838 if (!libCompClsPtr) {
839 throw MemoryError {};
840 }
841
842 setCompClsCommonProps<UserComponentT, CompClsBridge>(
843 libCompClsPtr, bt_component_class_sink_as_component_class,
844 bt_component_class_sink_set_initialize_method, bt_component_class_sink_set_finalize_method,
845 bt_component_class_sink_set_get_supported_mip_versions_method,
846 bt_component_class_sink_set_query_method);
847
848 {
849 const auto status = bt_component_class_sink_set_graph_is_configured_method(
850 libCompClsPtr, CompClsBridge::graphIsConfigured);
851
852 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
853 }
854
855 {
856 const auto status = bt_component_class_sink_set_input_port_connected_method(
857 libCompClsPtr, CompClsBridge::inputPortConnected);
858
859 BT_ASSERT(status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
860 }
861
862 return libCompClsPtr;
863}
864
865} /* namespace internal */
212313d9
SM
866} /* namespace bt2 */
867
868#endif /* BABELTRACE_CPP_COMMON_BT2_COMPONENT_CLASS_DEV_HPP */
This page took 0.057299 seconds and 4 git commands to generate.