#include "cpp-common/bt2c/c-string-view.hpp"
#include "logging/log-api.h"
-#include "../wrap.hpp"
+#include "../integer-range-set.hpp"
+#include "../logging.hpp"
+#include "../private-query-executor.hpp"
+#include "../self-component-class.hpp"
+#include "../self-component-port.hpp"
+#include "../self-message-iterator-configuration.hpp"
+#include "../self-message-iterator.hpp"
+#include "../value.hpp"
namespace bt2 {
namespace internal {
/*
* Base class of any component class bridge.
*
- * `UserCompClsT` is the actual C++ user component class and `LibTypesT`
- * is a structure offering the following specific library types:
+ * `UserCompClsT` is the actual C++ user component class and `TypesT`
+ * is a structure offering the following specific types:
*
- * `SelfCompCls`:
- * Self component class.
+ * `LibSelfCompCls`:
+ * Self component class library type.
*
- * `SelfComp`:
- * Self component.
+ * `LibSelfComp`:
+ * Self component library type.
+ *
+ * `LibSelfCompCfg`:
+ * Self component configuration library type.
*
- * `SelfCompCfg`:
- * Self component configuration.
+ * `SelfComp`:
+ * Self component type.
*/
-template <typename UserCompClsT, typename LibTypesT>
+template <typename UserCompClsT, typename TypesT>
class CompClsBridge
{
private:
- using _LibSelfCompPtr = typename LibTypesT::SelfComp *;
+ using _LibSelfCompPtr = typename TypesT::LibSelfComp *;
public:
static UserCompClsT& userCompFromLibSelfCompPtr(const _LibSelfCompPtr libSelfCompPtr) noexcept
{
- return wrap(libSelfCompPtr).template data<UserCompClsT>();
+ return typename TypesT::SelfComp {libSelfCompPtr}.template data<UserCompClsT>();
}
static bt_component_class_initialize_method_status init(const _LibSelfCompPtr libSelfCompPtr,
- typename LibTypesT::SelfCompCfg *,
+ typename TypesT::LibSelfCompCfg *,
const bt_value * const libParamsPtr,
void * const initData) noexcept
{
- const auto selfComp = wrap(libSelfCompPtr);
+ const auto selfComp = typename TypesT::SelfComp {libSelfCompPtr};
try {
const auto comp =
- new UserCompClsT {selfComp, wrap(libParamsPtr).asMap(),
+ new UserCompClsT {selfComp, ConstMapValue {libParamsPtr},
static_cast<typename UserCompClsT::InitData *>(initData)};
selfComp.data(*comp);
}
static bt_component_class_get_supported_mip_versions_method_status
- getSupportedMipVersions(typename LibTypesT::SelfCompCls * const libSelfCompClsPtr,
+ getSupportedMipVersions(typename TypesT::LibSelfCompCls * const libSelfCompClsPtr,
const bt_value * const libParamsPtr, void *,
const bt_logging_level logLevel,
bt_integer_range_set_unsigned * const libSupportedVersionsPtr) noexcept
{
try {
UserCompClsT::getSupportedMipVersions(
- wrap(libSelfCompClsPtr), wrap(libParamsPtr).asMap(),
- static_cast<LoggingLevel>(logLevel), wrap(libSupportedVersionsPtr));
+ SelfComponentClass {libSelfCompClsPtr}, ConstMapValue {libParamsPtr},
+ static_cast<LoggingLevel>(logLevel),
+ UnsignedIntegerRangeSet {libSupportedVersionsPtr});
return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_OK;
} catch (const std::bad_alloc&) {
return BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_MEMORY_ERROR;
}
static bt_component_class_query_method_status
- query(typename LibTypesT::SelfCompCls * const libSelfCompClsPtr,
+ query(typename TypesT::LibSelfCompCls * const libSelfCompClsPtr,
bt_private_query_executor * const libPrivQueryExecPtr, const char * const object,
const bt_value * const libParamsPtr, void * const data,
const bt_value ** const libResultPtr) noexcept
{
- const auto privQueryExec = wrap(libPrivQueryExecPtr);
+ const auto privQueryExec = PrivateQueryExecutor {libPrivQueryExecPtr};
try {
auto result = UserCompClsT::query(
- wrap(libSelfCompClsPtr), privQueryExec, object, wrap(libParamsPtr),
- static_cast<typename UserCompClsT::QueryData *>(data));
+ SelfComponentClass {libSelfCompClsPtr}, privQueryExec, object,
+ ConstValue {libParamsPtr}, static_cast<typename UserCompClsT::QueryData *>(data));
*libResultPtr = result.release().libObjPtr();
return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
}
};
-template <typename SpecCompClsBridgeT, typename LibTypesT>
+template <typename SpecCompClsBridgeT, typename TypesT>
struct CompClsBridgeWithInputPorts
{
static bt_component_class_port_connected_method_status
- inputPortConnected(typename LibTypesT::SelfComp * const libSelfCompPtr,
+ inputPortConnected(typename TypesT::LibSelfComp * const libSelfCompPtr,
bt_self_component_port_input * const libSelfCompPortPtr,
const bt_port_output * const libOtherPortPtr) noexcept
{
try {
SpecCompClsBridgeT::userCompFromLibSelfCompPtr(libSelfCompPtr)
- .inputPortConnected(wrap(libSelfCompPortPtr), wrap(libOtherPortPtr));
+ .inputPortConnected(SelfComponentInputPort {libSelfCompPortPtr},
+ ConstOutputPort {libOtherPortPtr});
} catch (const std::bad_alloc&) {
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_MEMORY_ERROR;
} catch (const Error&) {
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
} catch (...) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
- unhandledExcLogTag(), unhandledExcLogStr());
+ BT_LOG_WRITE_CUR_LVL(
+ BT_LOG_WARNING,
+ static_cast<int>(typename TypesT::SelfComp {libSelfCompPtr}.loggingLevel()),
+ unhandledExcLogTag(), unhandledExcLogStr());
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
}
}
};
-template <typename SpecCompClsBridgeT, typename LibTypesT>
+template <typename SpecCompClsBridgeT, typename TypesT>
struct CompClsBridgeWithOutputPorts
{
static bt_component_class_port_connected_method_status
- outputPortConnected(typename LibTypesT::SelfComp * const libSelfCompPtr,
+ outputPortConnected(typename TypesT::LibSelfComp * const libSelfCompPtr,
bt_self_component_port_output * const libSelfCompPortPtr,
const bt_port_input * const libOtherPortPtr) noexcept
{
try {
SpecCompClsBridgeT::userCompFromLibSelfCompPtr(libSelfCompPtr)
- .outputPortConnected(wrap(libSelfCompPortPtr), wrap(libOtherPortPtr));
+ .outputPortConnected(SelfComponentOutputPort {libSelfCompPortPtr},
+ ConstInputPort {libOtherPortPtr});
} catch (const std::bad_alloc&) {
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_MEMORY_ERROR;
} catch (const Error&) {
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
} catch (...) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
- unhandledExcLogTag(), unhandledExcLogStr());
+ BT_LOG_WRITE_CUR_LVL(
+ BT_LOG_WARNING,
+ static_cast<int>(typename TypesT::SelfComp {libSelfCompPtr}.loggingLevel()),
+ unhandledExcLogTag(), unhandledExcLogStr());
return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
}
}
};
-struct SrcCompClsLibTypes final
+struct SrcCompClsTypes final
{
- using SelfCompCls = bt_self_component_class_source;
- using SelfComp = bt_self_component_source;
- using SelfCompCfg = bt_self_component_source_configuration;
+ using LibSelfCompCls = bt_self_component_class_source;
+ using LibSelfComp = bt_self_component_source;
+ using LibSelfCompCfg = bt_self_component_source_configuration;
+ using SelfComp = SelfSourceComponent;
};
template <typename UserCompClsT>
class SrcCompClsBridge final :
- public CompClsBridge<UserCompClsT, SrcCompClsLibTypes>,
- public CompClsBridgeWithOutputPorts<SrcCompClsBridge<UserCompClsT>, SrcCompClsLibTypes>
+ public CompClsBridge<UserCompClsT, SrcCompClsTypes>,
+ public CompClsBridgeWithOutputPorts<SrcCompClsBridge<UserCompClsT>, SrcCompClsTypes>
{
};
-struct FltCompClsLibTypes final
+struct FltCompClsTypes final
{
- using SelfCompCls = bt_self_component_class_filter;
- using SelfComp = bt_self_component_filter;
- using SelfCompCfg = bt_self_component_filter_configuration;
+ using LibSelfCompCls = bt_self_component_class_filter;
+ using LibSelfComp = bt_self_component_filter;
+ using LibSelfCompCfg = bt_self_component_filter_configuration;
+ using SelfComp = SelfFilterComponent;
};
template <typename UserCompClsT>
class FltCompClsBridge final :
- public CompClsBridge<UserCompClsT, FltCompClsLibTypes>,
- public CompClsBridgeWithInputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsLibTypes>,
- public CompClsBridgeWithOutputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsLibTypes>
+ public CompClsBridge<UserCompClsT, FltCompClsTypes>,
+ public CompClsBridgeWithInputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsTypes>,
+ public CompClsBridgeWithOutputPorts<FltCompClsBridge<UserCompClsT>, FltCompClsTypes>
{
};
-struct SinkCompClsLibTypes final
+struct SinkCompClsTypes final
{
- using SelfCompCls = bt_self_component_class_sink;
- using SelfComp = bt_self_component_sink;
- using SelfCompCfg = bt_self_component_sink_configuration;
+ using LibSelfCompCls = bt_self_component_class_sink;
+ using LibSelfComp = bt_self_component_sink;
+ using LibSelfCompCfg = bt_self_component_sink_configuration;
+ using SelfComp = SelfSinkComponent;
};
template <typename UserCompClsT>
class SinkCompClsBridge final :
- public CompClsBridge<UserCompClsT, SinkCompClsLibTypes>,
- public CompClsBridgeWithInputPorts<SinkCompClsBridge<UserCompClsT>, SinkCompClsLibTypes>
+ public CompClsBridge<UserCompClsT, SinkCompClsTypes>,
+ public CompClsBridgeWithInputPorts<SinkCompClsBridge<UserCompClsT>, SinkCompClsTypes>
{
public:
- using CompClsBridge<UserCompClsT, SinkCompClsLibTypes>::userCompFromLibSelfCompPtr;
+ using CompClsBridge<UserCompClsT, SinkCompClsTypes>::userCompFromLibSelfCompPtr;
static bt_component_class_sink_consume_method_status
consume(bt_self_component_sink * const libSelfCompPtr) noexcept
} catch (const Error&) {
return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
} catch (...) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
- unhandledExcLogTag(), unhandledExcLogStr());
+ BT_LOG_WRITE_CUR_LVL(
+ BT_LOG_WARNING, static_cast<int>(SelfSinkComponent {libSelfCompPtr}.loggingLevel()),
+ unhandledExcLogTag(), unhandledExcLogStr());
return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
}
}
} catch (const Error&) {
return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
} catch (...) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfCompPtr).loggingLevel()),
- unhandledExcLogTag(), unhandledExcLogStr());
+ BT_LOG_WRITE_CUR_LVL(
+ BT_LOG_WARNING, static_cast<int>(SelfSinkComponent {libSelfCompPtr}.loggingLevel()),
+ unhandledExcLogTag(), unhandledExcLogStr());
return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
}
}
static UserMsgIterT&
userMsgIterFromLibSelfMsgIterPtr(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
{
- return wrap(libSelfMsgIterPtr).data<UserMsgIterT>();
+ return SelfMessageIterator {libSelfMsgIterPtr}.data<UserMsgIterT>();
}
static bt_message_iterator_class_initialize_method_status
bt_self_message_iterator_configuration * const libSelfMsgIterConfigPtr,
bt_self_component_port_output * const libSelfCompPortPtr) noexcept
{
- const auto selfMsgIter = wrap(libSelfMsgIterPtr);
+ const auto selfMsgIter = SelfMessageIterator {libSelfMsgIterPtr};
try {
- const auto msgIter = new UserMsgIterT {selfMsgIter, wrap(libSelfMsgIterConfigPtr),
- wrap(libSelfCompPortPtr)};
+ const auto msgIter = new UserMsgIterT {
+ selfMsgIter, SelfMessageIteratorConfiguration {libSelfMsgIterConfigPtr},
+ SelfComponentOutputPort {libSelfCompPortPtr}};
selfMsgIter.data(*msgIter);
} catch (const std::bad_alloc&) {
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
}
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
}
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR;
}
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR;
}
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
}
} catch (...) {
BT_LOG_WRITE_CUR_LVL(
BT_LOG_WARNING,
- static_cast<int>(wrap(libSelfMsgIterPtr).component().loggingLevel()),
+ static_cast<int>(
+ SelfMessageIterator {libSelfMsgIterPtr}.component().loggingLevel()),
unhandledExcLogTag(), unhandledExcLogStr());
return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
}