src/cpp-common/bt2/plugin-dev.hpp

   1 /*
   2  * Copyright (c) 2023 Simon Marchi <simon.marchi@efficios.com>
   3  * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
   4  *
   5  * SPDX-License-Identifier: MIT
   6  */
   7
   8 #ifndef BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP
   9 #define BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP
  10
  11 #include <cstdint>
  12
  13 #include <glib.h>
  14
  15 #include <babeltrace2/babeltrace.h>
  16
  17 #include "cpp-common/bt2c/c-string-view.hpp"
  18 #include "cpp-common/bt2c/logging.hpp"
  19 #include "cpp-common/vendor/fmt/core.h"
  20
  21 #include "exc.hpp"
  22 #include "wrap.hpp"
  23
  24 namespace bt2 {
  25 namespace internal {
  26
  27 constexpr bt2c::CStringView unhandledExcLogStr() noexcept
  28 {
  29     return "Unhandled exception.";
  30 }
  31
  32 constexpr bt2c::CStringView unhandledExcLogTag() noexcept
  33 {
  34     return "PLUGIN-DEV-HPP";
  35 }
  36
  37 /*
  38  * Base class of any component class bridge.
  39  *
  40  * `UserCompClsT` is the actual C++ user component class and `LibTypesT`
  41  * is a structure offering the following specific library types:
  42  *
  43  * `SelfCompCls`:
  44  *     Self component class.
  45  *
  46  * `SelfComp`:
  47  *     Self component.
  48  *
  49  * `SelfCompCfg`:
  50  *     Self component configuration.
  51  */
  52 template <typename UserCompClsT, typename LibTypesT>
  53 class CompClsBridge
  54 {
  55 private:
  56     using _LibSelfCompPtr = typename LibTypesT::SelfComp *;
  57
  58 public:
  59     static UserCompClsT& userCompFromLibSelfCompPtr(const _LibSelfCompPtr libSelfCompPtr) noexcept
  60     {
  61         return wrap(libSelfCompPtr).template data<UserCompClsT>();
  62     }
  63
  64     static bt_component_class_initialize_method_status init(const _LibSelfCompPtr libSelfCompPtr,
  65                                                             typename LibTypesT::SelfCompCfg *,
  66                                                             const bt_value * const libParamsPtr,
  67                                                             void *) noexcept
  68     {
  69         const auto selfComp = wrap(libSelfCompPtr);
  70
  71         try {
  72             const auto comp = new UserCompClsT {selfComp, wrap(libParamsPtr).asMap()};
  73
  74             selfComp.data(*comp);
  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;
  79         } catch (...) {
  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;
  83         }
  84
  85         return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
  86     }
  87
  88     static void finalize(const _LibSelfCompPtr libSelfCompPtr) noexcept
  89     {
  90         delete &userCompFromLibSelfCompPtr(libSelfCompPtr);
  91     }
  92
  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
  98     {
  99         try {
 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;
 108         } catch (...) {
 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;
 112         }
 113     }
 114
 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
 120     {
 121         const auto privQueryExec = wrap(libPrivQueryExecPtr);
 122
 123         try {
 124             auto result = UserCompClsT::query(wrap(libSelfCompClsPtr), privQueryExec, object,
 125                                               wrap(libParamsPtr));
 126
 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;
 137         } catch (...) {
 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;
 141         }
 142     }
 143 };
 144
 145 template <typename SpecCompClsBridgeT, typename LibTypesT>
 146 struct CompClsBridgeWithInputPorts
 147 {
 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
 152     {
 153         try {
 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;
 160         } catch (...) {
 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;
 165         }
 166
 167         return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
 168     }
 169 };
 170
 171 template <typename SpecCompClsBridgeT, typename LibTypesT>
 172 struct CompClsBridgeWithOutputPorts
 173 {
 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
 178     {
 179         try {
 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;
 186         } catch (...) {
 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;
 191         }
 192
 193         return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
 194     }
 195 };
 196
 197 struct SrcCompClsLibTypes final
 198 {
 199     using SelfCompCls = bt_self_component_class_source;
 200     using SelfComp = bt_self_component_source;
 201     using SelfCompCfg = bt_self_component_source_configuration;
 202 };
 203
 204 template <typename UserCompClsT>
 205 class SrcCompClsBridge final :
 206     public CompClsBridge<UserCompClsT, SrcCompClsLibTypes>,
 207     public CompClsBridgeWithOutputPorts<SrcCompClsBridge<UserCompClsT>, SrcCompClsLibTypes>
 208 {
 209 };
 210
 211 struct FltCompClsLibTypes final
 212 {
 213     using SelfCompCls = bt_self_component_class_filter;
 214     using SelfComp = bt_self_component_filter;
 215     using SelfCompCfg = bt_self_component_filter_configuration;
 216 };
 217
 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>
 223 {
 224 };
 225
 226 struct SinkCompClsLibTypes final
 227 {
 228     using SelfCompCls = bt_self_component_class_sink;
 229     using SelfComp = bt_self_component_sink;
 230     using SelfCompCfg = bt_self_component_sink_configuration;
 231 };
 232
 233 template <typename UserCompClsT>
 234 class SinkCompClsBridge final :
 235     CompClsBridge<UserCompClsT, SinkCompClsLibTypes>,
 236     CompClsBridgeWithInputPorts<SinkCompClsBridge<UserCompClsT>, SinkCompClsLibTypes>
 237 {
 238 private:
 239     using CompClsBridge<UserCompClsT, SinkCompClsLibTypes>::userCompFromLibSelfCompPtr;
 240
 241 public:
 242     static bt_component_class_sink_consume_method_status
 243     consume(bt_self_component_sink * const libSelfCompPtr) noexcept
 244     {
 245         try {
 246             if (userCompFromLibSelfCompPtr(libSelfCompPtr).consume()) {
 247                 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
 248             } else {
 249                 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
 250             }
 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;
 257         } catch (...) {
 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;
 262         }
 263     }
 264
 265     static bt_component_class_sink_graph_is_configured_method_status
 266     graphIsConfigured(bt_self_component_sink * const libSelfCompPtr) noexcept
 267     {
 268         try {
 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;
 274         } catch (...) {
 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;
 279         }
 280     }
 281 };
 282
 283 template <typename UserMsgIterT>
 284 class MsgIterClsBridge final
 285 {
 286 public:
 287     static UserMsgIterT&
 288     userMsgIterFromLibSelfMsgIterPtr(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
 289     {
 290         return bt2::wrap(libSelfMsgIterPtr).data<UserMsgIterT>();
 291     }
 292
 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
 297     {
 298         const auto selfMsgIter = bt2::wrap(libSelfMsgIterPtr);
 299
 300         try {
 301             const auto msgIter = new UserMsgIterT {selfMsgIter, bt2::wrap(libSelfMsgIterConfigPtr),
 302                                                    bt2::wrap(libSelfCompPortPtr)};
 303
 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;
 309         } catch (...) {
 310             BT_LOG_WRITE_CUR_LVL(
 311                 BT_LOG_WARNING,
 312                 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
 313                 unhandledExcLogTag(), unhandledExcLogStr());
 314             return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
 315         }
 316
 317         return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
 318     }
 319
 320     static void finalize(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
 321     {
 322         delete &userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr);
 323     }
 324
 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
 328     {
 329         try {
 330             auto msgArray = bt2::ConstMessageArray::wrapEmpty(libMsgsPtr, capacity);
 331             auto& msgIter = userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr);
 332
 333             msgIter.next(msgArray);
 334             *count = msgArray.release();
 335
 336             if (G_LIKELY(*count > 0)) {
 337                 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
 338             } else {
 339                 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
 340             }
 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;
 347         } catch (...) {
 348             BT_LOG_WRITE_CUR_LVL(
 349                 BT_LOG_WARNING,
 350                 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
 351                 unhandledExcLogTag(), unhandledExcLogStr());
 352             return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
 353         }
 354     }
 355
 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
 359     {
 360         try {
 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;
 369         } catch (...) {
 370             BT_LOG_WRITE_CUR_LVL(
 371                 BT_LOG_WARNING,
 372                 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
 373                 unhandledExcLogTag(), unhandledExcLogStr());
 374             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR;
 375         }
 376
 377         return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_OK;
 378     }
 379
 380     static bt_message_iterator_class_seek_beginning_method_status
 381     seekBeginning(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
 382     {
 383         try {
 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;
 391         } catch (...) {
 392             BT_LOG_WRITE_CUR_LVL(
 393                 BT_LOG_WARNING,
 394                 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
 395                 unhandledExcLogTag(), unhandledExcLogStr());
 396             return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR;
 397         }
 398
 399         return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_OK;
 400     }
 401
 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
 405     {
 406         try {
 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;
 415         } catch (...) {
 416             BT_LOG_WRITE_CUR_LVL(
 417                 BT_LOG_WARNING,
 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;
 421         }
 422
 423         return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK;
 424     }
 425
 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
 429     {
 430         try {
 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;
 438         } catch (...) {
 439             BT_LOG_WRITE_CUR_LVL(
 440                 BT_LOG_WARNING,
 441                 static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
 442                 unhandledExcLogTag(), unhandledExcLogStr());
 443             return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
 444         }
 445
 446         return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK;
 447     }
 448 };
 449
 450 } /* namespace internal */
 451
 452 template <typename UserMessageIteratorT, typename UserComponentT>
 453 class UserMessageIterator;
 454
 455 /*
 456  * Base class of any user component.
 457  *
 458  * See the specific `bt2::UserSourceComponent`,
 459  * `bt2::UserFilterComponent`, and `bt2::UserSinkComponent`.
 460  */
 461 template <typename SelfCompT>
 462 class UserComponent
 463 {
 464     /* Give a related message iterator access to this logger */
 465     template <typename, typename>
 466     friend class UserMessageIterator;
 467
 468 protected:
 469     explicit UserComponent(const SelfCompT selfComp, const std::string& logTag) :
 470         _mLogger {selfComp, fmt::format("{}/[{}]", logTag, selfComp.name())}, _mSelfComp {selfComp}
 471     {
 472     }
 473
 474 protected:
 475     bt2c::CStringView _name() const noexcept
 476     {
 477         return _mSelfComp.name();
 478     }
 479
 480     LoggingLevel _loggingLevel() const noexcept
 481     {
 482         return _mSelfComp.loggingLevel();
 483     }
 484
 485     std::uint64_t _graphMipVersion() const noexcept
 486     {
 487         return _mSelfComp.graphMipVersion();
 488     }
 489
 490     SelfCompT _selfComp() noexcept
 491     {
 492         return _mSelfComp;
 493     }
 494
 495     bt2c::Logger _mLogger;
 496
 497 private:
 498     SelfCompT _mSelfComp;
 499 };
 500
 501 /*
 502  * Base class of a user source component `UserComponentT` (CRTP).
 503  *
 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).
 508  *
 509  * `UserMessageIteratorT`, the message iterator class to use, must inherit
 510  * `UserMessageIterator`.
 511  */
 512 template <typename UserComponentT, typename UserMessageIteratorT>
 513 class UserSourceComponent : public UserComponent<SelfSourceComponent>
 514 {
 515     static_assert(std::is_base_of<UserMessageIterator<UserMessageIteratorT, UserComponentT>,
 516                                   UserMessageIteratorT>::value,
 517                   "`UserMessageIteratorT` inherits `UserMessageIterator`");
 518
 519 public:
 520     using MessageIterator = UserMessageIteratorT;
 521
 522 protected:
 523     using _OutputPorts = SelfSourceComponent::OutputPorts;
 524
 525     explicit UserSourceComponent(const SelfSourceComponent selfComp, const std::string& logTag) :
 526         UserComponent<SelfSourceComponent> {selfComp, logTag}
 527     {
 528     }
 529
 530 public:
 531     static Value::Shared query(const SelfComponentClass selfCompCls,
 532                                const PrivateQueryExecutor privQueryExec,
 533                                const bt2c::CStringView obj, const ConstValue params)
 534     {
 535         return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
 536     }
 537
 538     static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
 539                                         const ConstValue params, const LoggingLevel loggingLevel,
 540                                         const UnsignedIntegerRangeSet ranges)
 541     {
 542         UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
 543     }
 544
 545     void outputPortConnected(const SelfComponentOutputPort outputPort,
 546                              const ConstInputPort inputPort)
 547     {
 548         static_cast<UserComponentT&>(*this).outputPortConnected(outputPort, inputPort);
 549     }
 550
 551 protected:
 552     /* Overloadable */
 553     static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
 554                                 ConstValue)
 555     {
 556         throw UnknownObject {};
 557     }
 558
 559     /* Overloadable */
 560     static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
 561                                          const UnsignedIntegerRangeSet ranges)
 562     {
 563         ranges.addRange(0, 0);
 564     }
 565
 566     /* Overloadable */
 567     void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
 568     {
 569     }
 570
 571     template <typename DataT>
 572     _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT * const data)
 573     {
 574         return this->_selfComp().addOutputPort(name, data);
 575     }
 576
 577     _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
 578     {
 579         return this->_selfComp().addOutputPort(name);
 580     }
 581
 582     _OutputPorts _outputPorts() noexcept
 583     {
 584         return this->_selfComp().outputPorts();
 585     }
 586 };
 587
 588 /*
 589  * Base class of a user filter component `UserComponentT` (CRTP).
 590  *
 591  * `UserComponentT::UserComponentT()` must accept a
 592  * `bt2::SelfFilterComponent` parameter, which it needs to forward to
 593  * bt2::UserFilterComponent::UserFilterComponent(), and a
 594  * `bt2::ConstValue` parameter (initialization parameters).
 595  *
 596  * `UserMessageIteratorT`, the message iterator class to use, must inherit
 597  * `UserMessageIterator`.
 598  */
 599 template <typename UserComponentT, typename UserMessageIteratorT>
 600 class UserFilterComponent : public UserComponent<SelfFilterComponent>
 601 {
 602     static_assert(std::is_base_of<UserMessageIterator<UserMessageIteratorT, UserComponentT>,
 603                                   UserMessageIteratorT>::value,
 604                   "`UserMessageIteratorT` inherits `UserMessageIterator`");
 605
 606 public:
 607     using MessageIterator = UserMessageIteratorT;
 608
 609 protected:
 610     using _InputPorts = SelfFilterComponent::InputPorts;
 611     using _OutputPorts = SelfFilterComponent::OutputPorts;
 612
 613     explicit UserFilterComponent(const SelfFilterComponent selfComp, const std::string& logTag) :
 614         UserComponent<SelfFilterComponent> {selfComp, logTag}
 615     {
 616     }
 617
 618 public:
 619     static Value::Shared query(const SelfComponentClass selfCompCls,
 620                                const PrivateQueryExecutor privQueryExec,
 621                                const bt2c::CStringView obj, const ConstValue params)
 622     {
 623         return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
 624     }
 625
 626     static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
 627                                         const ConstValue params, const LoggingLevel loggingLevel,
 628                                         const UnsignedIntegerRangeSet ranges)
 629     {
 630         UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
 631     }
 632
 633     void inputPortConnected(const SelfComponentInputPort inputPort,
 634                             const ConstOutputPort outputPort)
 635     {
 636         static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
 637     }
 638
 639     void outputPortConnected(const SelfComponentOutputPort outputPort,
 640                              const ConstInputPort inputPort)
 641     {
 642         static_cast<UserComponentT&>(*this)._outputPortConnected(outputPort, inputPort);
 643     }
 644
 645 protected:
 646     /* Overloadable */
 647     static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
 648                                 ConstValue)
 649     {
 650         throw UnknownObject {};
 651     }
 652
 653     /* Overloadable */
 654     static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
 655                                          const UnsignedIntegerRangeSet ranges)
 656     {
 657         ranges.addRange(0, 0);
 658     }
 659
 660     /* Overloadable */
 661     void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
 662     {
 663     }
 664
 665     /* Overloadable */
 666     void _outputPortConnected(SelfComponentOutputPort, ConstInputPort)
 667     {
 668     }
 669
 670     template <typename DataT>
 671     _OutputPorts::Port _addInputPort(const bt2c::CStringView name, DataT * const data)
 672     {
 673         return this->_selfComp().addInputPort(name, data);
 674     }
 675
 676     _InputPorts::Port _addInputPort(const bt2c::CStringView name)
 677     {
 678         return this->_selfComp().addInputPort(name);
 679     }
 680
 681     _InputPorts _inputPorts() noexcept
 682     {
 683         return this->_selfComp().inputPorts();
 684     }
 685
 686     template <typename DataT>
 687     _OutputPorts::Port _addOutputPort(const bt2c::CStringView name, DataT * const data)
 688     {
 689         return this->_selfComp().addOutputPort(name, data);
 690     }
 691
 692     _OutputPorts::Port _addOutputPort(const bt2c::CStringView name)
 693     {
 694         return this->_selfComp().addOutputPort(name);
 695     }
 696
 697     _OutputPorts _outputPorts() noexcept
 698     {
 699         return this->_selfComp().outputPorts();
 700     }
 701 };
 702
 703 /*
 704  * Base class of a user sink component `UserComponentT` (CRTP).
 705  *
 706  * `UserComponentT::UserComponentT()` must accept a
 707  * `bt2::SelfSinkComponent` parameter, which it needs to forward to
 708  * bt2::UserSinkComponent::UserSinkComponent(), and a `bt2::ConstValue`
 709  * parameter (initialization parameters).
 710  *
 711  * `UserComponentT` must implement:
 712  *
 713  *     bool _consume();
 714  *
 715  * This method returns `true` if the sink component still needs to
 716  * consume, or `false` if it's finished.
 717  */
 718 template <typename UserComponentT>
 719 class UserSinkComponent : public UserComponent<SelfSinkComponent>
 720 {
 721 protected:
 722     using _InputPorts = SelfSinkComponent::InputPorts;
 723
 724     explicit UserSinkComponent(const SelfSinkComponent selfComp, const std::string& logTag) :
 725         UserComponent<SelfSinkComponent> {selfComp, logTag}
 726     {
 727     }
 728
 729 public:
 730     static Value::Shared query(const SelfComponentClass selfCompCls,
 731                                const PrivateQueryExecutor privQueryExec,
 732                                const bt2c::CStringView obj, const ConstValue params)
 733     {
 734         return UserComponentT::_query(selfCompCls, privQueryExec, obj, params);
 735     }
 736
 737     static void getSupportedMipVersions(const SelfComponentClass selfCompCls,
 738                                         const ConstValue params, const LoggingLevel loggingLevel,
 739                                         const UnsignedIntegerRangeSet ranges)
 740     {
 741         UserComponentT::_getSupportedMipVersions(selfCompCls, params, loggingLevel, ranges);
 742     }
 743
 744     void graphIsConfigured()
 745     {
 746         static_cast<UserComponentT&>(*this)._graphIsConfigured();
 747     }
 748
 749     void inputPortConnected(const SelfComponentInputPort inputPort,
 750                             const ConstOutputPort outputPort)
 751     {
 752         static_cast<UserComponentT&>(*this)._inputPortConnected(inputPort, outputPort);
 753     }
 754
 755     bool consume()
 756     {
 757         return static_cast<UserComponentT&>(*this)._consume();
 758     }
 759
 760 protected:
 761     /* Overloadable */
 762     static Value::Shared _query(SelfComponentClass, PrivateQueryExecutor, bt2c::CStringView,
 763                                 ConstValue)
 764     {
 765         throw UnknownObject {};
 766     }
 767
 768     /* Overloadable */
 769     static void _getSupportedMipVersions(SelfComponentClass, ConstValue, LoggingLevel,
 770                                          const UnsignedIntegerRangeSet ranges)
 771     {
 772         ranges.addRange(0, 0);
 773     }
 774
 775     /* Overloadable */
 776     void _graphIsConfigured()
 777     {
 778     }
 779
 780     /* Overloadable */
 781     void _inputPortConnected(SelfComponentInputPort, ConstOutputPort)
 782     {
 783     }
 784
 785     MessageIterator::Shared _createMessageIterator(const _InputPorts::Port port)
 786     {
 787         return this->_selfComp().createMessageIterator(port);
 788     }
 789
 790     template <typename DataT>
 791     _InputPorts::Port _addInputPort(const bt2c::CStringView name, DataT * const data)
 792     {
 793         return this->_selfComp().addInputPort(name, data);
 794     }
 795
 796     _InputPorts::Port _addInputPort(const bt2c::CStringView name)
 797     {
 798         return this->_selfComp().addInputPort(name);
 799     }
 800
 801     _InputPorts _inputPorts() noexcept
 802     {
 803         return this->_selfComp().inputPorts();
 804     }
 805 };
 806
 807 /*
 808  * Base class of a user message iterator `UserMessageIteratorT` (CRTP)
 809  * of which the parent user component class is `UserComponentT`.
 810  *
 811  * `UserMessageIteratorT::UserMessageIteratorT()` must accept a
 812  * `bt2::SelfMessageIterator` parameter, which it needs to forward to
 813  * bt2::UserMessageIterator::UserMessageIterator().
 814  *
 815  * The public next() method below (called by the bridge) implements the
 816  * very common pattern of appending messages into the output array, and,
 817  * meanwhile:
 818  *
 819  * If it catches a `bt2::TryAgain` exception:
 820  *     If the message array isn't empty, transform this into a success
 821  *     (don't throw).
 822  *
 823  *     Otherwise rethrow.
 824  *
 825  * If it catches an error:
 826  *     If the message array isn't empty, transform this into a success
 827  *     (don't throw), but save the error of the current thread and the
 828  *     type of error to throw the next time the user calls next().
 829  *
 830  *     Otherwise rethrow.
 831  *
 832  * `UserMessageIteratorT` must implement:
 833  *
 834  *     void _next(bt2::ConstMessageArray& messages);
 835  *
 836  * This method fills `messages` with at most `messages.capacity()`
 837  * messages and may throw `bt2::TryAgain` or a valid error whenever.
 838  * Leaving an empty `messages` means the end of iteration.
 839  */
 840 template <typename UserMessageIteratorT, typename UserComponentT>
 841 class UserMessageIterator
 842 {
 843 private:
 844     /* Type of `_mExcToThrowType` */
 845     enum class _ExcToThrowType
 846     {
 847         NONE,
 848         ERROR,
 849         MEM_ERROR,
 850     };
 851
 852 protected:
 853     explicit UserMessageIterator(const SelfMessageIterator selfMsgIter,
 854                                  const std::string& logTagSuffix) :
 855         _mSelfMsgIter {selfMsgIter},
 856         _mLogger {selfMsgIter,
 857                   fmt::format("{}/{}", this->_component()._mLogger.tag(), logTagSuffix)}
 858     {
 859     }
 860
 861 public:
 862     ~UserMessageIterator()
 863     {
 864         this->_resetError();
 865     }
 866
 867     void next(bt2::ConstMessageArray& messages)
 868     {
 869         /* Any saved error? Now is the time to throw */
 870         if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::NONE)) {
 871             /* Move `_mSavedLibError`, if any, as current thread error */
 872             if (_mSavedLibError) {
 873                 BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(_mSavedLibError);
 874             }
 875
 876             /* Throw the corresponding exception */
 877             if (_mExcToThrowType == _ExcToThrowType::ERROR) {
 878                 throw bt2::Error {};
 879             } else {
 880                 BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MEM_ERROR);
 881                 throw bt2::MemoryError {};
 882             }
 883         }
 884
 885         /*
 886          * When catching some exception below, if our message array
 887          * isn't empty, then return immediately before throwing to
 888          * provide those messages to downstream.
 889          *
 890          * When catching an error, also save the current thread error,
 891          * if any, so that we can restore it later (see the beginning of
 892          * this method).
 893          */
 894         BT_ASSERT_DBG(_mExcToThrowType == _ExcToThrowType::NONE);
 895
 896         try {
 897             this->_userObj()._next(messages);
 898
 899             /* We're done: everything below is exception handling */
 900             return;
 901         } catch (const bt2::TryAgain&) {
 902             if (messages.isEmpty()) {
 903                 throw;
 904             }
 905         } catch (const std::bad_alloc&) {
 906             if (messages.isEmpty()) {
 907                 throw;
 908             }
 909
 910             _mExcToThrowType = _ExcToThrowType::MEM_ERROR;
 911         } catch (const bt2::Error&) {
 912             if (messages.isEmpty()) {
 913                 throw;
 914             }
 915
 916             _mExcToThrowType = _ExcToThrowType::ERROR;
 917         }
 918
 919         if (_mExcToThrowType != _ExcToThrowType::NONE) {
 920             BT_CPPLOGE(
 921                 "An error occurred, but there are {} messages to return: delaying the error reporting.",
 922                 messages.length());
 923             BT_ASSERT(!_mSavedLibError);
 924             _mSavedLibError = bt_current_thread_take_error();
 925         }
 926     }
 927
 928     bool canSeekBeginning()
 929     {
 930         this->_resetError();
 931         return this->_userObj()._canSeekBeginning();
 932     }
 933
 934     void seekBeginning()
 935     {
 936         this->_resetError();
 937         return this->_userObj()._seekBeginning();
 938     }
 939
 940     bool canSeekNsFromOrigin(const std::int64_t nsFromOrigin)
 941     {
 942         this->_resetError();
 943         return this->_userObj()._canSeekNsFromOrigin(nsFromOrigin);
 944     }
 945
 946     void seekNsFromOrigin(const std::int64_t nsFromOrigin)
 947     {
 948         this->_resetError();
 949         this->_userObj()._seekNsFromOrigin(nsFromOrigin);
 950     }
 951
 952 protected:
 953     /* Overloadable */
 954     bool _canSeekBeginning() noexcept
 955     {
 956         return false;
 957     }
 958
 959     /* Overloadable */
 960     void _seekBeginning() noexcept
 961     {
 962     }
 963
 964     /* Overloadable */
 965     bool _canSeekNsFromOrigin(std::int64_t) noexcept
 966     {
 967         return false;
 968     }
 969
 970     /* Overloadable */
 971     void _seekNsFromOrigin(std::int64_t) noexcept
 972     {
 973     }
 974
 975     MessageIterator::Shared _createMessageIterator(const SelfComponentInputPort port)
 976     {
 977         return _mSelfMsgIter.createMessageIterator(port);
 978     }
 979
 980     UserComponentT& _component() noexcept
 981     {
 982         return _mSelfMsgIter.component().template data<UserComponentT>();
 983     }
 984
 985     SelfComponentOutputPort _port() noexcept
 986     {
 987         return _mSelfMsgIter.port();
 988     }
 989
 990     bool _isInterrupted() const noexcept
 991     {
 992         return _mSelfMsgIter.isInterrupted();
 993     }
 994
 995 private:
 996     UserMessageIteratorT& _userObj() noexcept
 997     {
 998         return static_cast<UserMessageIteratorT&>(*this);
 999     }
1000
1001     void _resetError() noexcept
1002     {
1003         _mExcToThrowType = _ExcToThrowType::NONE;
1004
1005         if (_mSavedLibError) {
1006             bt_error_release(_mSavedLibError);
1007         }
1008     }
1009
1010     SelfMessageIterator _mSelfMsgIter;
1011
1012     /*
1013      * next() may accumulate messages, and then catch an error before
1014      * returning. In that case, it saves the error of the current thread
1015      * here so that it can return its accumulated messages and throw the
1016      * next time.
1017      *
1018      * It also saves the type of the exception to throw the next time.
1019      */
1020     _ExcToThrowType _mExcToThrowType = _ExcToThrowType::NONE;
1021     const bt_error *_mSavedLibError = nullptr;
1022
1023 protected:
1024     bt2c::Logger _mLogger;
1025 };
1026
1027 } /* namespace bt2 */
1028
1029 #define BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID(_pluginId, _componentClassId, _name,          \
1030                                                      _userComponentClass)                          \
1031     BT_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID(                                                      \
1032         _pluginId, _componentClassId, _name,                                                       \
1033         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::next);              \
1034     BT_PLUGIN_SOURCE_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID(                                    \
1035         _pluginId, _componentClassId, bt2::internal::SrcCompClsBridge<_userComponentClass>::init); \
1036     BT_PLUGIN_SOURCE_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID(                                      \
1037         _pluginId, _componentClassId,                                                              \
1038         bt2::internal::SrcCompClsBridge<_userComponentClass>::finalize);                           \
1039     BT_PLUGIN_SOURCE_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID(                    \
1040         _pluginId, _componentClassId,                                                              \
1041         bt2::internal::SrcCompClsBridge<_userComponentClass>::getSupportedMipVersions);            \
1042     BT_PLUGIN_SOURCE_COMPONENT_CLASS_OUTPUT_PORT_CONNECTED_METHOD_WITH_ID(                         \
1043         _pluginId, _componentClassId,                                                              \
1044         bt2::internal::SrcCompClsBridge<_userComponentClass>::outputPortConnected);                \
1045     BT_PLUGIN_SOURCE_COMPONENT_CLASS_QUERY_METHOD_WITH_ID(                                         \
1046         _pluginId, _componentClassId,                                                              \
1047         bt2::internal::SrcCompClsBridge<_userComponentClass>::query);                              \
1048     BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_WITH_ID(             \
1049         _pluginId, _componentClassId,                                                              \
1050         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::init);              \
1051     BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD_WITH_ID(               \
1052         _pluginId, _componentClassId,                                                              \
1053         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::finalize);          \
1054     BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHODS_WITH_ID(        \
1055         _pluginId, _componentClassId,                                                              \
1056         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::seekBeginning,      \
1057         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::canSeekBeginning);  \
1058     BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHODS_WITH_ID(   \
1059         _pluginId, _componentClassId,                                                              \
1060         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::seekNsFromOrigin,   \
1061         bt2::internal::MsgIterClsBridge<                                                           \
1062             _userComponentClass::MessageIterator>::canSeekNsFromOrigin);
1063
1064 #define BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID(_pluginId, _componentClassId, _name,          \
1065                                                      _userComponentClass)                          \
1066     BT_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID(                                                      \
1067         _pluginId, _componentClassId, _name,                                                       \
1068         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::next);              \
1069     BT_PLUGIN_FILTER_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID(                                    \
1070         _pluginId, _componentClassId, bt2::internal::FltCompClsBridge<_userComponentClass>::init); \
1071     BT_PLUGIN_FILTER_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID(                                      \
1072         _pluginId, _componentClassId,                                                              \
1073         bt2::internal::FltCompClsBridge<_userComponentClass>::finalize);                           \
1074     BT_PLUGIN_FILTER_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID(                    \
1075         _pluginId, _componentClassId,                                                              \
1076         bt2::internal::FltCompClsBridge<_userComponentClass>::getSupportedMipVersions);            \
1077     BT_PLUGIN_FILTER_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD_WITH_ID(                          \
1078         _pluginId, _componentClassId,                                                              \
1079         bt2::internal::FltCompClsBridge<_userComponentClass>::inputPortConnected);                 \
1080     BT_PLUGIN_FILTER_COMPONENT_CLASS_OUTPUT_PORT_CONNECTED_METHOD_WITH_ID(                         \
1081         _pluginId, _componentClassId,                                                              \
1082         bt2::internal::FltCompClsBridge<_userComponentClass>::outputPortConnected);                \
1083     BT_PLUGIN_FILTER_COMPONENT_CLASS_QUERY_METHOD_WITH_ID(                                         \
1084         _pluginId, _componentClassId,                                                              \
1085         bt2::internal::FltCompClsBridge<_userComponentClass>::query);                              \
1086     BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_WITH_ID(             \
1087         _pluginId, _componentClassId,                                                              \
1088         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::init);              \
1089     BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD_WITH_ID(               \
1090         _pluginId, _componentClassId,                                                              \
1091         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::finalize);          \
1092     BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHODS_WITH_ID(        \
1093         _pluginId, _componentClassId,                                                              \
1094         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::seekBeginning,      \
1095         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::canSeekBeginning);  \
1096     BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHODS_WITH_ID(   \
1097         _pluginId, _componentClassId,                                                              \
1098         bt2::internal::MsgIterClsBridge<_userComponentClass::MessageIterator>::seekNsFromOrigin,   \
1099         bt2::internal::MsgIterClsBridge<                                                           \
1100             _userComponentClass::MessageIterator>::canSeekNsFromOrigin);
1101
1102 #define BT_CPP_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID(_pluginId, _componentClassId, _name,            \
1103                                                    _userComponentClass)                            \
1104     BT_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID(                                                        \
1105         _pluginId, _componentClassId, _name,                                                       \
1106         bt2::internal::SinkCompClsBridge<_userComponentClass>::consume);                           \
1107     BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD_WITH_ID(                                      \
1108         _pluginId, _componentClassId,                                                              \
1109         bt2::internal::SinkCompClsBridge<_userComponentClass>::init);                              \
1110     BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD_WITH_ID(                                        \
1111         _pluginId, _componentClassId,                                                              \
1112         bt2::internal::SinkCompClsBridge<_userComponentClass>::finalize);                          \
1113     BT_PLUGIN_SINK_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_WITH_ID(                      \
1114         _pluginId, _componentClassId,                                                              \
1115         bt2::internal::SinkCompClsBridge<_userComponentClass>::getSupportedMipVersions);           \
1116     BT_PLUGIN_SINK_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD_WITH_ID(                            \
1117         _pluginId, _componentClassId,                                                              \
1118         bt2::internal::SinkCompClsBridge<_userComponentClass>::inputPortConnected);                \
1119     BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD_WITH_ID(                             \
1120         _pluginId, _componentClassId,                                                              \
1121         bt2::internal::SinkCompClsBridge<_userComponentClass>::graphIsConfigured);                 \
1122     BT_PLUGIN_SINK_COMPONENT_CLASS_QUERY_METHOD_WITH_ID(                                           \
1123         _pluginId, _componentClassId,                                                              \
1124         bt2::internal::SinkCompClsBridge<_userComponentClass>::query);
1125
1126 #define BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS(_name, _userComponentClass)                           \
1127     BT_CPP_PLUGIN_SOURCE_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass)
1128
1129 #define BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS(_name, _userComponentClass)                           \
1130     BT_CPP_PLUGIN_FILTER_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass)
1131
1132 #define BT_CPP_PLUGIN_SINK_COMPONENT_CLASS(_name, _userComponentClass)                             \
1133     BT_CPP_PLUGIN_SINK_COMPONENT_CLASS_WITH_ID(auto, _name, #_name, _userComponentClass)
1134
1135 #endif /* BABELTRACE_CPP_COMMON_BT2_PLUGIN_DEV_HPP */