XNSim/XNCore_Win/XNDDSManager/XNDDSManager.h

#pragma once
#include "XNBaseFrameObject/XNBaseFrameObject.h"
#include "XNBaseFrameObject/XNBaseFrameObject_p.h"

namespace XNSim {
struct XNDDSManagerPrivate : public XNBaseFrameObjectPrivate {
  XNDDSParticipantPtr participant_;
  XNDDSTopicMap topics_;
  std::mutex mutex_;
};

class XNDDSManager : public XNBaseFrameObject {
  XN_METATYPE(XNDDSManager, XNBaseFrameObject)
  XN_DECLARE_PRIVATE(XNDDSManager)
public:
  XNDDSManager();
  ~XNDDSManager();

protected:
  XNDDSManager(PrivateType *p);

public:
  virtual XN_BOOL Initialize() override;

  virtual XN_BOOL PrepareForExecute() override;

  void SetDomainID(XN_UINT32 domainID);

public:
  template <typename T>
  XNDDSDataWriterPtr RegisterPublisher(const XN_STRING &topicName,
                                       XN_UINT32 publisherID) {
    T_D();
    std::lock_guard<std::mutex> lock(d->mutex_);
    if (d->topics_.find(topicName) == d->topics_.end()) {
      d->topics_[topicName] = TopicInfo();
      TopicInfo &tmp = d->topics_[topicName];
      XNDDSTypeSupport typeSupport(new T());
      typeSupport.register_type(d->participant_);
      tmp.topic = d->participant_->create_topic(
          topicName, typeSupport.get_type_name(), XN_DDS::TOPIC_QOS_DEFAULT);
      if (tmp.topic == nullptr) {
        LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
        d->topics_.erase(topicName);
        return nullptr;
      }
    }
    TopicInfo &tmp = d->topics_[topicName];
    tmp.publishers_[publisherID] = PublisherInfo();
    tmp.publishers_[publisherID].publisher = d->participant_->create_publisher(
        XN_DDS::PUBLISHER_QOS_DEFAULT, nullptr);
    if (tmp.publishers_[publisherID].publisher == nullptr) {
      LOG_ERROR("0x2131 Create Publisher %1 for Topic %2 Failed!", publisherID,
                topicName);
      return nullptr;
    }

    // 设置数据写入器QoS策略
    XNDDSDataWriterQos dataWriterQos;
    // 设置数据写入器的历史记录策略, 只保留最新的一个数据
    // dataWriterQos.history().kind  = FAST_DDS_MACRO::KEEP_LAST_HISTORY_QOS;
    // dataWriterQos.history().depth = 1;
    // 设置数据写入器的可靠性策略, 使用最佳努力可靠性
    // dataWriterQos.reliability().kind =
    // FAST_DDS_MACRO::BEST_EFFORT_RELIABILITY_QOS; 设置数据写入器的持久性策略,
    // 使用瞬态本地持久性
    dataWriterQos.durability().kind = XN_DDS::VOLATILE_DURABILITY_QOS;
    // 设置数据写入器的生命周期策略, 设置为5秒
    dataWriterQos.lifespan().duration = XN_DDS::Duration_t(5, 0);

    tmp.publishers_[publisherID].dataWriter =
        tmp.publishers_[publisherID].publisher->create_datawriter(
            tmp.topic, dataWriterQos, nullptr);
    if (tmp.publishers_[publisherID].dataWriter == nullptr) {
      LOG_ERROR("0x2132 Create DataWriter %1 for Topic %2 Failed!", publisherID,
                topicName);
      return nullptr;
    }
    LOG_INFO("0x2133 Create Publisher %1 for Topic %2 Success!", publisherID,
             topicName);
    return tmp.publishers_[publisherID].dataWriter;
  }

  template <typename T>
  void RegisterSubscriber(const XN_STRING &topicName, XN_UINT32 subscriberID,
                          XNDDSCallBack<typename T::type> fun) {
    T_D();
    std::lock_guard<std::mutex> lock(d->mutex_);
    if (d->topics_.find(topicName) == d->topics_.end()) {
      d->topics_[topicName] = TopicInfo();
      TopicInfo &tmp = d->topics_[topicName];
      XNDDSTypeSupport typeSupport(new T());
      typeSupport.register_type(d->participant_);
      tmp.topic = d->participant_->create_topic(
          topicName, typeSupport.get_type_name(), XN_DDS::TOPIC_QOS_DEFAULT);
      if (tmp.topic == nullptr) {
        LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
        d->topics_.erase(topicName);
        return;
      }
    }
    TopicInfo &tmp = d->topics_[topicName];
    tmp.subscribers_[subscriberID] = SubscriberInfo();
    tmp.subscribers_[subscriberID].subscriber =
        d->participant_->create_subscriber(XN_DDS::SUBSCRIBER_QOS_DEFAULT,
                                           nullptr);
    if (tmp.subscribers_[subscriberID].subscriber == nullptr) {
      LOG_ERROR("0x2135 Create Subscriber %1 for Topic %2 Failed!",
                subscriberID, topicName);
    }
    XN_DDS::DataReaderQos dataReaderQos;
    dataReaderQos.durability().kind = XN_DDS::VOLATILE_DURABILITY_QOS;
    XN_DDS::DataReaderListener *listener =
        new DataReaderListenerImpl<typename T::type>(fun);
    tmp.subscribers_[subscriberID].dataReader =
        tmp.subscribers_[subscriberID].subscriber->create_datareader(
            tmp.topic, dataReaderQos, listener);
    if (tmp.subscribers_[subscriberID].dataReader == nullptr) {
      LOG_ERROR("0x2136 Create DataReader %1 for Topic %2 Failed!",
                subscriberID, topicName);
    }
    LOG_INFO("0x2137 Create Subscriber %1 for Topic %2 Success!", subscriberID,
             topicName);
  }
};
} // namespace XNSim