XNSim/Release/include/XNCore/XNModelObject.h

/**
 * @file XNModelObject.h
 * @author	jinchao
 * @brief 模型基类头文件
 * @version	1.0
 * @date 2024-11-07
 *
 * @copyright Copyright (c) 2024 XN
 *
 */
#pragma once
#include "XNObject.h"
#include "XNEventManager.h"

struct XNModelObjectPrivate;

/**
 * @brief 模型基类
 * @details 所有模型系统中模型的基类，预先实现了部分模型共有的功能。
 */
class XNModelObject : public XNObject
{
	XN_METATYPE(XNModelObject, XNObject)
	XN_DECLARE_PRIVATE(XNModelObject)

public:
	/**
	 * @brief 模型基类默认构造函数
	 */
	XNModelObject();

	/**
	 * @brief 模型基类默认析构函数
	 */
	virtual ~XNModelObject();

protected:
	/**
	 * @brief 模型基类带参构造函数
	 * @param p:XNModelObjectPrivate类型，私有结构体指针
	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
	 */
	XNModelObject(PrivateType *p);

public:
	void SetFramework(XNFrameworkPtr framework);

protected:
	XNFrameworkPtr GetFramework() const;

public:
	/**
	 * @brief 获取模型描述
	 * @return const QString&:模型描述
	 */
	const std::string &GetDescription();

	/**
	 * @brief 设置模型描述
	 * @param sDescription:QString类型，模型描述
	 */
	void SetDescription(const std::string &sDescription);

	/**
	 * @brief 获取作者
	 * @return const QString&:	作者
	 */
	const std::string &GetAuthor();

	/**
	 * @brief 设置作者
	 * @param sAuthor:	QString类型，作者
	 */
	void SetAuthor(const std::string &sAuthor);

	/**
	 * @brief 获取模型配置文件路径
	 * @return const QString&:	模型配置文件路径
	 */
	const std::string &GetXmlPath();

	/**
	 * @brief 设置模型配置文件路径
	 * @param sXmlPath:QString类型，模型配置文件路径
	 */
	void SetXmlPath(const std::string &sXmlPath);

	/**
	 * @brief 获取模型创建时间
	 * @return const XNTimePoint&:模型创建时间
	 */
	const XNTimePoint &GetCreateTime();

	/**
	 * @brief 设置模型创建时间
	 * @param cTime:	XNTimePoint类型，模型创建时间
	 */
	void SetCreateTime(const XNTimePoint &cTime);

	/**
	 * @brief 获取模型修改时间
	 * @return const XNTimePoint&:模型修改时间
	 */
	const XNTimePoint &GetChangeTime();

	/**
	 * @brief 设置模型修改时间
	 * @param cTime:	XNTimePoint类型，模型修改时间
	 */
	void SetChangeTime(const XNTimePoint &cTime);

	/**
	 * @brief 获取模型版本号
	 * @return const XNString&:	模型版本号
	 */
	const std::string &GetVersion();

	/**
	 * @brief 设置模型版本号
	 * @param sVersion:	std::string类型，模型版本号
	 */
	void SetVersion(const std::string &sVersion);

	/**
	 * @brief 获取模型运行频率组
	 * @return uint32_t:	模型运行频率组
	 */
	uint32_t GetRunFreq() const;

	/**
	 * @brief 设置模型运行频率组
	 * @param runFreq:	uint32_t类型，模型运行频率组
	 */
	void SetRunFreq(uint32_t runFreq);

	/**
	 * @brief 获取模型运行节点
	 * @return uint32_t:	模型运行节点
	 */
	uint32_t GetRunNode() const;

	/**
	 * @brief 设置模型运行节点
	 * @param runNode:	uint32_t类型，模型运行节点
	 */
	void SetRunNode(uint32_t runNode);

	/**
	 * @brief 获取模型运行优先级
	 * @return uint32_t:	模型运行优先级
	 */
	uint32_t GetRunPriority() const;

	/**
	 * @brief 设置模型运行优先级
	 * @param runPriority:	uint32_t类型，模型运行优先级
	 */
	void SetRunPriority(uint32_t runPriority);

	/**
	 * @brief 获取模型设置频率
	 * @return double:	模型设置频率
	 */
	double GetSetFreq() const;

	/**
	 * @brief 设置模型设置频率
	 * @param setFreq:	double类型，模型设置频率
	 */
	void SetSetFreq(double setFreq);

	/**
	 * @brief 单步执行函数
	 * @details 模型默认的周期性执行函数
	 */
	virtual void StepUpdate();

	/**
	 * @brief 注册事件处理器
	 * @param eventName: 事件名称
	 * @param callback: 事件处理回调函数
	 * @param async: 是否异步处理
	 * @return: 返回处理器ID，失败返回-1
	 */
	int RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
							 bool async					= false,
							 XNEvent::Priority priority = XNEvent::Priority::Normal);

	/**
	 * @brief 触发事件
	 * @param eventName: 要触发的事件名称
	 * @param eventData: 事件携带的数据
	 * @param forceAsync: 强制异步处理
	 */
	void TriggerEvent(const std::string &eventName, const std::any &eventData = std::any(),
					  bool forceAsync			 = false,
					  XNEvent::Priority priority = XNEvent::Priority::Normal);

	/**
	 * @brief 注册实时事件处理器
	 * @param eventName: 事件名称
	 * @param callback: 事件处理回调函数
	 * @return: 返回处理器ID，失败返回-1
	 */
	int RegisterRTEventHandler(const std::string &eventName, XNEventCallback callback)
	{
		return RegisterEventHandler(eventName, callback, true, XNEvent::Priority::RealTime);
	}

	/**
	 * @brief 触发实时事件
	 * @param eventName: 要触发的事件名称
	 * @param eventData: 事件携带的数据
	 */
	void TriggerRTEvent(const std::string &eventName, const std::any &eventData = std::any())
	{
		TriggerEvent(eventName, eventData, true, XNEvent::Priority::RealTime);
	}

	void SetInitializeType(uint32_t initialType);

	void SetThreadID(uint32_t threadID);

	uint32_t GetThreadID() const;

	/**
	 * @brief 初始化函数
	 * @details
	 * 模型的初始化函数接口，子类继承时要调用父类初始化接口，或在此函数中使用AddMyFunction方法注册需要被线程调用的函数
	 */
	virtual void Initialize();

	/**
	 * @brief 仿真系统运行前做最后处理
	 * @details	系统运行前模型做最后处理的接口
	 */
	virtual void PrepareForExecute();

public:
	virtual void RegisterDDSParticipant();
};

#define XN_DECLARE_DDS()                                                                           \
public:                                                                                            \
	virtual void RegisterDDSParticipant() override;

#define XN_REGISTER_PARTICIPANT_BEGIN(class)                                                       \
	void class ::RegisterDDSParticipant()                                                          \
	{                                                                                              \
		XNModelObject::RegisterDDSParticipant();                                                   \
		T_D();                                                                                     \
		auto framework = GetFramework();                                                           \
		if (!framework)                                                                            \
			return;                                                                                \
		XNDDSManagerPtr ddsManager = framework->GetDDSManager();                                   \
		if (!ddsManager)                                                                           \
			return;                                                                                \
		uint32_t MyID = GetUniqueId();

#define XN_PUBLISHTOPIC(topic)                                                                     \
	d->_dataWriters[#topic] = ddsManager->RegisterPublisher<topic##PubSubType>(#topic, MyID);

#define XN_SUBSCRIBETOPIC(topic, fun)                                                              \
	ddsManager->RegisterSubscriber<topic##PubSubType>(                                             \
		#topic, MyID, std::bind(fun, this, std::placeholders::_1));

#define XN_REGISTER_PARTICIPANT_END(class) }

#define XN_MODEL_INITIALIZE(ClassName)                                                             \
	extern "C" XNModelObjectPtr Initial##ClassName()                                               \
	{                                                                                              \
		ClassName##Ptr obj = std::make_shared<ClassName>();                                        \
		return obj;                                                                                \
	}