ros2/openvehicle-api
3
0
Fork 0
mirror of https://github.com/eclipse-openvehicle-api/openvehicle-api.git synced 2026-02-05 15:18:45 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity
Files
main
openvehicle-api/export/support/component_impl.h

954 lines
39 KiB
C
Raw Permalink Normal View History

Precommit (#1) * first commit * cleanup
2025-11-04 13:28:06 +01:00
/**
*
* @file component_impl.h
* @brief This file provides all necessary definitions to implement SDV object.
* @version 0.1
* @date 2022.11.14
* @author Thomas.pfleiderer@zf.com
* @copyright Copyright ZF Friedrichshaven AG (c) 2022
*
*/
#ifndef COMPONENT_IMPL_H
#define COMPONENT_IMPL_H
#include <cstring>
#include <mutex>
#include <shared_mutex>
#include <vector>
#include "../interfaces/core_types.h"
#include "../interfaces/core.h"
#include "../interfaces/repository.h"
#include "interface_ptr.h"
#include "local_service_access.h"
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
/**
* @brief Stringize helper.
*/
#define SDV_STRINGIZE_HELPER2(txt) #txt
/**
* @brief Stringize helper.
*/
#define SDV_STRINGIZE_HELPER(txt) SDV_STRINGIZE_HELPER2(txt)
// NOLINTEND(cppcoreguidelines-macro-usage)
#ifdef _WIN32
// Resolve conflict
#pragma push_macro("interface")
#undef interface
#pragma push_macro("GetObject")
#undef GetObject
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <WinSock2.h>
#include <Windows.h>
#include <objbase.h>
// Resolve conflict
#pragma pop_macro("GetObject")
#pragma pop_macro("interface")
#ifdef GetClassInfo
#undef GetClassInfo
#endif
#elif defined __unix__
#else
#error OS is not supported!
#endif // defined _MSC_VER
/**
* @brief Software Defined Vehicle framework.
*/
namespace sdv
{
// Forward declarations
class CSdvObject;
////////////////////////////////////
// Object control classes //
////////////////////////////////////
/**
* @brief SDV object create interface.
* @remarks This is an internal interface not exposed through IInterfaceAccess.
*/
struct ISdvObjectClassInfo
{
public:
/**
* @brief Get the class information struct.
* @return Returns the class information struct.
*/
virtual sdv::SClassInfo GetClassInfo() const = 0;
/**
* @brief Create the SDV object.
* @return Returns an instance of the SDV object or nullptr when the object could not be created.
*/
virtual std::unique_ptr<CSdvObject> CreateObject() = 0;
};
/**
* @brief Top level SDV object to solve ambiguities in the use of IInterfaceAccess. THis class is used by
* CSdvObjectClass during the instantiation of the SDV object.
*/
class CSdvObjectAccess : public IInterfaceAccess
{
public:
/**
* @brief Default constructor
*/
CSdvObjectAccess() = default;
CSdvObjectAccess(CSdvObjectAccess&) = delete;
CSdvObjectAccess& operator=(CSdvObjectAccess&) = delete;
CSdvObjectAccess(CSdvObjectAccess&&) = delete;
CSdvObjectAccess& operator=(CSdvObjectAccess&&) = delete;
/**
* @brief Default virtual destructor
*/
virtual ~CSdvObjectAccess() = default;
/**
* @brief Get access to the implemented IInterfaceAccess interface.
* @return Returns a pointer to the implementation of IInterfaceAccess.
*/
IInterfaceAccess* GetObjectAccess()
{
return static_cast<IInterfaceAccess*>(this);
}
// Interface map
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
};
/**
* @brief Lifetime cookie to automatically manage the module lifetime.
* @details The lifetime cookie uses an increment and decrement function to increment for every assigned instantiation of
* the cookie and to decrement every previously instantiated cookie. This allows the classfactory to keep track of its lifetime
* even with dynamically created objects.
*/
class CLifetimeCookie
{
public:
/**
* @brief Default constructor.
*/
CLifetimeCookie() = default;
/**
* @brief Assignment constructor, assigning the increment and decrement functions.
* @details Assign the increment and decrement functions and increase the incrementation.
* @param[in] fnLifetimeIncr Increment function object.
* @param[in] fnLifetimeDecr Decrement function object.
*/
CLifetimeCookie(std::function<void()> fnLifetimeIncr, std::function<void()> fnLifetimeDecr) :
m_fnLifetimeIncr(fnLifetimeIncr), m_fnLifetimeDecr(fnLifetimeDecr)
{
if (m_fnLifetimeIncr) m_fnLifetimeIncr();
}
/**
* @brief Copy constructor.
* @details Construct a lifetime cookie object and copy the increment and decrement functions and call the increment
* function if valid.
* @param[in] rCookie Reference to the cookie to copy from.
*/
CLifetimeCookie(const CLifetimeCookie& rCookie) :
m_fnLifetimeIncr(rCookie.m_fnLifetimeIncr), m_fnLifetimeDecr(rCookie.m_fnLifetimeDecr)
{
if (m_fnLifetimeIncr) m_fnLifetimeIncr();
}
/**
* @brief Move constructor.
* @details Construct a lifetime cookie object and move the functions from the provided cookie. Then reset the functions
* of the provided cookie.
* @param[in] rCookie Reference to the cookie to copy from.
*/
CLifetimeCookie(CLifetimeCookie&& rCookie) noexcept :
m_fnLifetimeIncr(rCookie.m_fnLifetimeIncr), m_fnLifetimeDecr(rCookie.m_fnLifetimeDecr)
{
rCookie.m_fnLifetimeIncr = nullptr;
rCookie.m_fnLifetimeDecr = nullptr;
}
/**
* @brief Destroy the lifetime cookie.
* @details Decrement the lifetime by calling the decrement function if valid and destroy the cookie object.
*/
~CLifetimeCookie()
{
if (m_fnLifetimeDecr) m_fnLifetimeDecr();
}
/**
* @brief Assignment operator.
* @details Release the current lifetime by calling the decrement function and assign the increment and decrement functions
* of the provided cookie and call the increment function if valid.
* @param[in] rCookie Reference to the cookie to copy from.
* @return Reference to this class.
*/
CLifetimeCookie& operator=(const CLifetimeCookie& rCookie)
{
if (m_fnLifetimeDecr) m_fnLifetimeDecr();
m_fnLifetimeIncr = rCookie.m_fnLifetimeIncr;
m_fnLifetimeDecr = rCookie.m_fnLifetimeDecr;
if (m_fnLifetimeIncr) m_fnLifetimeIncr();
return *this;
}
/**
* @brief Move operator.
* @details Release the current lifetime by calling the decrement function and move the functions from the provided cookie.
* Then reset the functions of the provided cookie.
* @param[in] rCookie Reference to the cookie to copy from.
* @return Reference to this class.
*/
CLifetimeCookie& operator=(CLifetimeCookie&& rCookie) noexcept
{
if (m_fnLifetimeDecr) m_fnLifetimeDecr();
m_fnLifetimeIncr = rCookie.m_fnLifetimeIncr;
m_fnLifetimeDecr = rCookie.m_fnLifetimeDecr;
rCookie.m_fnLifetimeIncr = nullptr;
rCookie.m_fnLifetimeDecr = nullptr;
return *this;
}
private:
std::function<void()> m_fnLifetimeIncr; ///< Lifetime increment function
std::function<void()> m_fnLifetimeDecr; ///< Lifetime decrement function
};
/**
* @brief Global tracking of active objects. Functions in this class will only be called by CSdvObject and CSdvObjectClass
*/
class CObjectFactory : public IInterfaceAccess, public IObjectFactory
{
// Friend class SDV object and definition
friend class CSdvObject; ///< SDV object base class.
template <class TSdvObject>
friend class CSdvObjectClass; ///< SDV object creator class.
public:
/**
* @brief Constructor
*/
CObjectFactory() = default;
/**
* @brief Interface map.
*/
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_ENTRY(IObjectFactory)
END_SDV_INTERFACE_MAP()
/**
* @brief Create a lifetime cookie that keeps track of the module lifetime as long as it is alive.
* @return Returns a lifetime cookie.
*/
CLifetimeCookie CreateLifetimeCookie()
{
return CLifetimeCookie([this]() { m_uiActiveObjectCount++; },
[this]() { if (m_uiActiveObjectCount) m_uiActiveObjectCount--; });
}
/**
* @brief Gets the amount of active SDV objects.
* @return Returns the number of active SDV objects.
*/
uint32_t GetActiveObjects() const
{
return m_uiActiveObjectCount;
}
/**
* @brief Get the module manifest.
* @return Returns the pointer to a zero terminated string containing the module manifest or NULL when there is no string.
*/
const char* GetManifest()
{
if (m_ssManifest.empty())
BuildManifest();
return m_ssManifest.c_str();
}
/**
* @brief Create or get the object using the name from the object class info. Overload of
* sdv::IObjectFactory::CreateObject.
* @attention The objects lifetime is ended by a call to the DestroyObject function or the unloading of he module.
* @param[in] ssClassName The name of the class object to instantiate.
* @return Pointer to IInterfaceAccess interface of the object or NULL when the requested object doesn't exist.
*/
virtual IInterfaceAccess* CreateObject(const sdv::u8string& ssClassName) override;
/**
* @brief Destroy an instantiated object using the name of the object class info. Overload of
* sdv::IObjectFactory::DestroyObject.
* @param[in] object The object to destroy.
*/
virtual void DestroyObject(IInterfaceAccess* object) override;
/**
* @brief Destroys all active objects in reverse order of creation
*/
virtual void DestroyAllObjects() override;
protected:
/**
* @brief Build the module manifest.
*/
void BuildManifest()
{
std::stringstream sstream;
sstream << R"code(# Module manifest
[Interface]
Version = )code" << SDVFrameworkInterfaceVersion
<< R"code(
)code";
std::shared_lock<std::shared_mutex> lock(m_mtxObjectClasses);
for (const ISdvObjectClassInfo* pClassInfo : m_vecObjectClasses)
{
sdv::SClassInfo sInfo = pClassInfo->GetClassInfo();
sstream << "[[Component]]" << std::endl;
sstream << "Class=\"" << sInfo.ssClassName << "\"" << std::endl;
if (!sInfo.seqClassAliases.empty())
{
sstream << "Aliases=[";
bool bInitialAlias = true;
for (const sdv::u8string& rssAlias : sInfo.seqClassAliases)
{
if (!bInitialAlias)
sstream << ", ";
bInitialAlias = false;
sstream << "\"" << rssAlias << "\"";
}
sstream << "]" << std::endl;
}
if (!sInfo.ssDefaultObjectName.empty())
sstream << "DefaultName=\"" << sInfo.ssDefaultObjectName << "\"" << std::endl;
bool bSkip = false;
switch (sInfo.eType)
{
case sdv::EObjectType::SystemObject:
sstream << "Type=\""
<< "System"
<< "\"" << std::endl;
break;
case sdv::EObjectType::Device:
sstream << "Type=\""
<< "Device"
<< "\"" << std::endl;
break;
case sdv::EObjectType::BasicService:
sstream << "Type=\""
<< "BasicService"
<< "\"" << std::endl;
break;
case sdv::EObjectType::ComplexService:
sstream << "Type=\""
<< "ComplexService"
<< "\"" << std::endl;
break;
case sdv::EObjectType::Application:
sstream << "Type=\""
<< "App"
<< "\"" << std::endl;
break;
case sdv::EObjectType::Proxy:
sstream << "Type=\""
<< "Proxy"
<< "\"" << std::endl;
break;
case sdv::EObjectType::Stub:
sstream << "Type=\""
<< "Stub"
<< "\"" << std::endl;
break;
case sdv::EObjectType::Utility:
sstream << "Type=\""
<< "Utility"
<< "\"" << std::endl;
break;
default:
bSkip = true;
break;
}
if (bSkip)
continue;
if (sInfo.uiFlags & static_cast<uint32_t>(sdv::EObjectFlags::singleton))
sstream << "Singleton=true" << std::endl;
if (!sInfo.seqDependencies.empty())
{
sstream << "Dependencies=[";
bool bInitialDependency = true;
for (const sdv::u8string& rssDependsOn : sInfo.seqDependencies)
{
if (!bInitialDependency)
sstream << ", ";
bInitialDependency = false;
sstream << "\"" << rssDependsOn << "\"";
}
sstream << "]" << std::endl;
}
}
m_ssManifest = sstream.str();
}
/**
* @brief Expose the object prototype by placing it into the object prototype list.
* @details Expose the object class to allow class access. This function is called by the constructor of the
* class object.
* @param[in] pObjectClassInfo The object class internal interface.
*/
void ExposeObjectClass(ISdvObjectClassInfo* pObjectClassInfo)
{
if (pObjectClassInfo)
{
std::unique_lock<std::shared_mutex> lock(m_mtxObjectClasses);
m_vecObjectClasses.push_back(pObjectClassInfo);
// Attention: pObjectClass is a pointer to ISdvObjectClassInfo even if the class was derived.
// Virtual functions are not available yet at this stage.
}
}
/**
* @brief Revoke the object prototype from the object prototype list.
* @param[in] pObjectClassInfo The object class internal interface.
*/
void RevokeObjectClass(const ISdvObjectClassInfo* pObjectClassInfo)
{
std::unique_lock<std::shared_mutex> lock(m_mtxObjectClasses);
auto itObjectClass = std::find(m_vecObjectClasses.begin(), m_vecObjectClasses.end(), pObjectClassInfo);
if (itObjectClass != m_vecObjectClasses.end())
m_vecObjectClasses.erase(itObjectClass);
// TODO EVE: Updated through cppcheck warning
//for (auto objectClassIter = m_vecObjectClasses.begin(); objectClassIter != m_vecObjectClasses.end();
// objectClassIter++)
//{
// if (*objectClassIter == pObjectClassInfo)
// {
// m_vecObjectClasses.erase(objectClassIter);
// break;
// }
//}
}
private:
std::atomic<uint32_t> m_uiActiveObjectCount{0}; ///< The amount of active SDV objects.
mutable std::mutex m_mtxActiveObjects; ///< Synchronize access to m_vecActiveObjects
std::vector<std::unique_ptr<CSdvObject>> m_vecActiveObjects; ///< List of objects actively kept alive
mutable std::shared_mutex m_mtxObjectClasses; ///< Synchronize access to the object classes.
std::vector<ISdvObjectClassInfo*> m_vecObjectClasses; ///< List of object classes contained in this module.
std::string m_ssManifest; ///< Manifest of this module.
};
////////////////////////////////////
// Framework module classes //
////////////////////////////////////
/**
* @brief Class that manages the object instantiation and module lifetime.
* @remarks A pointer to an instance of this class is exposed across dll boundaries and used to implement
* CModuleInstance for SDV DLLs
* The instance is created by the DEFINE_SDV_OBJECT macro and the macro also registers a helper capable of
* instantiating the SDV object with the instance (see CObjectFactory for details)
*/
class CModule
: public CSdvObjectAccess
, public CObjectFactory
{
public:
/**
* @brief Default constructor
*/
CModule() = default;
/**
* @brief Interface map.
*/
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_CHAIN_BASE(CObjectFactory)
END_SDV_INTERFACE_MAP()
/**
* @brief Check whether the requested interface version corresponds to the one implemented here and return this
* object.
* @param[in] interfaceVersion The version of module interface that is requested for.
* @return Returns the IInterfaceAccess interface of the module if the interface versions match, nullptr otherwise
*/
IInterfaceAccess* GetModuleControl(uint32_t interfaceVersion)
{
// No compatibility interfacing available yet.
return interfaceVersion == SDVFrameworkInterfaceVersion ? GetObjectAccess() : nullptr;
}
};
/**
* @brief Module access (global per module).
* @return Reference to the global module.
*/
inline CModule& GetModule()
{
static CModule module;
return module;
}
/**
* @brief Create a lifetime cookie that keeps track of the module lifetime as long as it is alive.
* @return Returns a lifetime cookie.
*/
inline CLifetimeCookie CreateLifetimeCookie()
{
return GetModule().CreateLifetimeCookie();
}
////////////////////////////
// Component object class //
////////////////////////////
/**
* @brief SDV object creator class. Used to define the SDV class object and register its definition into the system
* as welll a as providing the creation interface for creating an object instance.
* @tparam TSdvObject Class type of the SDV object derived from CSdvObject.
*/
template <class TSdvObject>
class CSdvObjectClass
: public ISdvObjectClassInfo
{
public:
/**
* @brief Constructor assigning the SDV prototype to the module.
*/
CSdvObjectClass()
{
// Add this object definition to the definition list.
GetModule().ExposeObjectClass(this);
}
CSdvObjectClass(CSdvObjectClass&) = delete;
CSdvObjectClass(CSdvObjectClass&&) = delete;
CSdvObjectClass& operator=(CSdvObjectClass&) = delete;
CSdvObjectClass& operator=(CSdvObjectClass&&) = delete;
/**
* @brief Destructor revoking the object prototype.
*/
virtual ~CSdvObjectClass()
{
GetModule().RevokeObjectClass(this);
}
/**
* @brief Gets the object class name.
* @return Returns the class name of the object.
* @remarks Default implementation gets the information from the object class if not defined in the definition.
*/
virtual sdv::u8string GetClassName() const
{
return TSdvObject::GetClassNameStatic();
}
/**
* @brief Gets the class name aliases.
* @return Returns a sequence containing zero or more class name aliases.
* @remarks Default implementation gets the information from the object class if not defined in the definition.
*/
virtual sdv::sequence<sdv::u8string> GetClassAliases() const
{
return TSdvObject::GetClassAliasesStatic();
}
/**
* @brief Gets the default object name.
* @return Returns the default name of the object if exists.
*/
virtual sdv::u8string GetDefaultObjectName() const
{
return TSdvObject::GetDefaultObjectNameStatic();
}
/**
* @brief Is the object marked as singleton.
* @return Returns whether the object is a singleton object.
*/
virtual bool IsSingleton() const
{
return TSdvObject::IsSingletonStatic();
}
/**
* @brief Get object dependencies.
* @return Returns a vector containing the class names of the objects this component is dependent on.
*/
virtual sdv::sequence<sdv::u8string> GetObjectDependencies() const
{
return TSdvObject::GetObjectDependenciesStatic();
}
/**
* @brief Gets the object type.
* @return Returns the type of the object
* @remarks Default implementation gets the information from the object class if not defined in the definition.
*/
virtual EObjectType GetObjectType() const
{
return TSdvObject::GetObjectType();
}
protected:
/**
* @brief Helper function to retrieve the object creation flags.
* @return Returns the current flags of the object
*/
uint32_t GetObjectFlags() const
{
uint32_t flags = 0;
if (IsSingleton()) flags |= static_cast<uint32_t>(EObjectFlags::singleton);
// Currently no other flags known.
return flags;
}
/**
* @brief Get the class information struct. Overload of ISdvObjectClassInfo::GetClassInfo.
* @return Returns the class information struct.
*/
sdv::SClassInfo GetClassInfo() const override
{
sdv::SClassInfo classInfo{};
classInfo.ssClassName = GetClassName();
classInfo.seqClassAliases = GetClassAliases();
classInfo.ssDefaultObjectName = GetDefaultObjectName();
classInfo.eType = GetObjectType();
classInfo.uiFlags = GetObjectFlags();
classInfo.seqDependencies = GetObjectDependencies();
return classInfo;
}
/**
* @brief Create the SDV object. Overload of ISdvObjectClassInfo::CreateObject.
* @return Returns an instance of the SDV object or nullptr when the object could not be created (exception thrown during construction).
*/
std::unique_ptr<CSdvObject> CreateObject() override
{
std::unique_ptr<CSdvObject> ret;
try
{
ret = std::make_unique<TSdvObject>();
}
catch(...)
{
SDV_LOG(core::ELogSeverity::error, "Failed to instantiate object of class ", GetClassName(), " - exception thrown during construction! ");
}
return ret;
}
};
/**
* @brief SDV object base class.
*/
class CSdvObject : public CSdvObjectAccess
{
public:
/**
* @brief Use the default object creator class.
*/
template <class TSdvObject>
using TSdvObjectCreator = CSdvObjectClass<TSdvObject>;
/**
* @brief Constructor
*/
CSdvObject() = default;
CSdvObject(CSdvObject&) = delete;
CSdvObject& operator=(CSdvObject&) = delete;
CSdvObject(CSdvObject&&) = delete;
CSdvObject& operator=(CSdvObject&&) = delete;
/**
* @brief Destructor
*/
~CSdvObject() override
{}
/**
* @brief Class aliases sequence if not provided.
* @return An empty sequence of class aliases.
*/
static sdv::sequence<sdv::u8string> GetClassAliasesStatic() { return {}; }
/**
* @brief Default object name is not set.
* @return The empty default object name
*/
static sdv::u8string GetDefaultObjectNameStatic() { return {}; }
/**
* @brief Return whether the object is a singleton object (only one instance will be created of the object).
* @return Returns whether the object is a singleton.
*/
static bool IsSingletonStatic() { return false; }
/**
* @brief Get object dependencies.
* @return Returns a vector containing the class names of the objects this component is dependent on.
*/
static sdv::sequence<sdv::u8string> GetObjectDependenciesStatic() { return sdv::sequence<sdv::u8string>(); }
/**
* @brief Interface map
*/
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
};
/////////////////////////////////////////
// Object control class implementation //
/////////////////////////////////////////
inline IInterfaceAccess* CObjectFactory::CreateObject(const sdv::u8string& ssClassName)
{
if (ssClassName.empty())
{
return nullptr;
}
std::shared_lock<std::shared_mutex> lock(m_mtxObjectClasses);
for (ISdvObjectClassInfo* pObjectClassInfo : m_vecObjectClasses)
{
if (pObjectClassInfo == nullptr)continue;
sdv::SClassInfo sClassInfo = pObjectClassInfo->GetClassInfo();
// Check for the class name.
bool bFound = sClassInfo.ssClassName == ssClassName;
// If not found, check for all aliases.
for (auto itAlias = sClassInfo.seqClassAliases.begin(); !bFound && itAlias != sClassInfo.seqClassAliases.end(); itAlias++)
bFound = *itAlias == ssClassName;
if (!bFound) continue;
++m_uiActiveObjectCount;
auto object = pObjectClassInfo->CreateObject();
lock.unlock();
if(!object)
{
--m_uiActiveObjectCount;
return nullptr;
}
auto ret = object.get()->GetObjectAccess();
std::unique_lock<std::mutex> lockObjects (m_mtxActiveObjects);
m_vecActiveObjects.emplace_back(std::move(object));
return ret;
}
return nullptr;
}
inline void CObjectFactory::DestroyObject(IInterfaceAccess* object)
{
if (object == nullptr)
{
return;
}
std::unique_lock<std::mutex> lockObjects(m_mtxActiveObjects);
for(auto iter = m_vecActiveObjects.begin(); iter!= m_vecActiveObjects.end();++iter)
{
if(iter->get()->GetObjectAccess() == object)
{
auto objectPtr = std::move(*iter);
m_vecActiveObjects.erase(iter);
lockObjects.unlock();
objectPtr = nullptr;
if (m_uiActiveObjectCount) --m_uiActiveObjectCount;
return;
}
}
}
inline void CObjectFactory::DestroyAllObjects()
{
std::unique_lock<std::mutex> lockObjects(m_mtxActiveObjects);
auto objects = std::move(m_vecActiveObjects);
lockObjects.unlock();
while(!objects.empty())
{
objects.pop_back();
if (m_uiActiveObjectCount) --m_uiActiveObjectCount;
}
}
} // namespace sdv
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
/**
* @brief Define the SDV object (derived from CSdvObject) to be exposed to the framework.
* @param sdv_object_class The object class must derive from sdv::CSdvObject.
*/
#define DEFINE_SDV_OBJECT(sdv_object_class) \
struct SObjectClassInstance_##sdv_object_class \
{ \
public: \
SObjectClassInstance_##sdv_object_class() \
{ \
/* Enforce derivation of sdv::CSdvObject. */ \
static_assert(std::is_base_of<sdv::CSdvObject, sdv_object_class>::value, \
"CSdvObject is not base of sdv_object_class"); \
/* Call the static function once to instantiate the definition. */ \
GetObjectClassInstance(); \
} \
static sdv_object_class::TSdvObjectCreator<sdv_object_class>& GetObjectClassInstance() \
{ \
static sdv_object_class::TSdvObjectCreator<sdv_object_class> object_class; \
return object_class; \
} \
}; \
static SObjectClassInstance_##sdv_object_class g_##sdv_object_class; \
extern "C" SDV_SYMBOL_PUBLIC bool HasActiveObjects(); \
extern "C" SDV_SYMBOL_PUBLIC sdv::IInterfaceAccess* GetModuleFactory(uint32_t uiInterfaceVersion); \
extern "C" SDV_SYMBOL_PUBLIC const char* GetManifest();
/**
* @brief Define the SDV object (derived from CSdvObject) to be exposed to the framework. Do not define export functions.
* @param sdv_object_class The object class must derive from sdv::CSdvObject.
*/
#define DEFINE_SDV_OBJECT_NO_EXPORT(sdv_object_class) \
struct SObjectClassInstance_##sdv_object_class \
{ \
public: \
SObjectClassInstance_##sdv_object_class() \
{ \
/* Enforce derivation of sdv::CSdvObject. */ \
static_assert(std::is_base_of<sdv::CSdvObject, sdv_object_class>::value, \
"CSdvObject is not base of sdv_object_class"); \
/* Call the static function once to instantiate the definition. */ \
GetObjectClassInstance(); \
} \
static sdv_object_class::TSdvObjectCreator<sdv_object_class>& GetObjectClassInstance() \
{ \
static sdv_object_class::TSdvObjectCreator<sdv_object_class> object_class; \
return object_class; \
} \
}; \
static SObjectClassInstance_##sdv_object_class g_##sdv_object_class; \
bool HasActiveObjects(); \
sdv::IInterfaceAccess* GetModuleFactory(uint32_t uiInterfaceVersion); \
const char* GetManifest();
/**
* @brief Declare the object class type. To be placed in the SDV object class derived from CSdvObject.
update parser (#5)
2026-01-16 11:40:02 +01:00
* @param class_type The type of the object (EObjectType).
Precommit (#1) * first commit * cleanup
2025-11-04 13:28:06 +01:00
*/
#define DECLARE_OBJECT_CLASS_TYPE(class_type) \
/** \
* @brief Declare the object class type. To be placed in the SDV object class derived from CSdvObject. \
* @return Returns the type of the object (EObjectType). \
*/ \
constexpr static sdv::EObjectType GetObjectType() \
{ \
return class_type; \
}
/**
* @brief Declare the object class name. To be placed in the SDV object class derived from CSdvObject.
* @param class_name_string The UTF-8 string containing the name of the object.
*/
#define DECLARE_OBJECT_CLASS_NAME(class_name_string) \
static sdv::u8string GetClassNameStatic() \
{ \
return class_name_string; \
}
/**
* @brief Declare the object class aliases. To be placed in the SDV object class derived from CSdvObject.
* @param ... Multiple UTF-8 strings containing the alias names for the object class.
*/
#define DECLARE_OBJECT_CLASS_ALIAS(...) \
static sdv::sequence<sdv::u8string> GetClassAliasesStatic() \
{ \
return sdv::sequence<sdv::u8string>({__VA_ARGS__}); \
}
/**
* @brief Declare the default object name. To be placed in the SDV object class derived from CSdvObject.
* @param object_name_string The UTF-8 string containing the name of the object.
*/
#define DECLARE_DEFAULT_OBJECT_NAME(object_name_string) \
static sdv::u8string GetDefaultObjectNameStatic() \
{ \
return object_name_string; \
}
/**
* @brief Declare the object to be a singleton object (only one instance will be created of the object).
*/
#define DECLARE_OBJECT_SINGLETON() \
static bool IsSingletonStatic() { return true; }
/**
* @brief Declare the object to be a singleton object (only one instance will be created of the object).
* One or more strings with the class/default names of the objects the component is dependent on.
*/
#define DECLARE_OBJECT_DEPENDENCIES(...) \
static sdv::sequence<sdv::u8string> GetObjectDependenciesStatic() { return sdv::sequence<sdv::u8string>({__VA_ARGS__}); }
// NOLINTEND(cppcoreguidelines-macro-usage)
/*
* @brief Returns whether or not instances of objects implemented by this module are running. If none, the module can be unloaded.
* @remarks Unloading the module with running instances could cause a crash and should be prevented at all costs. Unloading the
* module removes the code of the objects still running.
* @return Returns true when object instances are running; otherwise returns 'false'.
*/
inline extern bool HasActiveObjects()
{
return sdv::GetModule().GetActiveObjects() != 0;
}
/*
* @brief Get the module factory interface with a specific version.
* @details This function provides access to the objects being implemented in this module.
* @param[in] interfaceVersion Request the module factory for a specific interface version. Using another interface version than
* the one returned from the manifest, might cause the function to fail.
* @return Returns pointer to the IInterfaceAccess interface of the module factory object.
*/
inline extern sdv::IInterfaceAccess* GetModuleFactory(uint32_t interfaceVersion)
{
return sdv::GetModule().GetModuleControl(interfaceVersion);
}
/*
* @brief Get the the module manifest.
* @details Each module contains a manifest containing general information as well as information about the component classes. This
* allows installing the component without having to instantiate the classes.
* @return Returns the pointer to a zero terminated string containing the module manifest or NULL when there is no string.
*/
inline extern const char* GetManifest()
{
return sdv::GetModule().GetManifest();
}
#endif // !defined COMPONENT_IMPL_H
Reference in New Issue Copy Permalink