qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/DDS/Generic/generic_data_writer.h

#pragma once

#include <dds/pub/DataWriter.hpp>
#include <dds/sub/SampleInfo.hpp>
#include <dds/topic/find.hpp>
#include <dds/topic/Topic.hpp>

#include <DDS/Generic/generic_logger.h>
#include <DDS/Generic/generic_base.h>

namespace DDSGeneric
{

template <typename TOPICTYPE>
class GenericDataWriter final
{
public:
  using TopicType  = TOPICTYPE;
  using DataWriter = dds::pub::DataWriter<TopicType>;
  using DataTopic  = dds::topic::Topic<TopicType>;

  GenericDataWriter()
    : m_dataWriter(nullptr)
    , m_ddsTopic(nullptr)
    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicType>::value(), DDS::DataType::DATA_WRITER))
  {}

  bool create(const dds::domain::DomainParticipant &participant,
              const dds::pub::Publisher &ddsPublisher,
              const std::string &topicName = DDS::Helper::getShortTopicName(DDS::topic_type_name<TopicType>::value()))
  {
    DEBUG_LOG() << "IN GenericDataWriter::create ("
                        << DDS::topic_type_name<TopicType>::value()
                        << ")";

    if (participant == nullptr)
    {
      ERROR_LOG() << "Participant not available, aborting. ";
      return false;
    }

    if (m_ddsTopic != nullptr)
    {
      ERROR_LOG() << "Type '"
                          << DDS::topic_type_name<TopicType>::value()
                          << "' already created";
      return false;
    }

    try {

      DEBUG_LOG() << "Creating write topic " << topicName << " with type: "
                          << DDS::topic_type_name<TopicType>::value();

      m_ddsTopic = dds::topic::find<DataTopic>(participant, topicName);
      if (m_ddsTopic == nullptr)
        m_ddsTopic = DataTopic(participant, topicName);

      m_dataWriter = DataWriter(ddsPublisher,
                                m_ddsTopic,
                                ddsPublisher.default_datawriter_qos());

      if (m_dataWriter == nullptr)
      {
        ERROR_LOG() << "Initialisation of "
                            << DDS::topic_type_name<TopicType>::value()
                            << " failed ";
        return false;
      }

    }
    catch ( const dds::core::Exception &ex )
    {
      ERROR_LOG() << ex.what();
      return false;
    }

    DEBUG_LOG() << "dataWriter created ("
                        << DDS::topic_type_name<TopicType>::value()
                        << ")";

    return true;
  }

  bool write(const TopicType &data,
             const dds::core::optional<dds::sub::SampleInfo> &si = dds::core::optional<dds::sub::SampleInfo>())
  {
    DEBUG_LOG() << "IN write ("
                        << DDS::topic_type_name<TopicType>::value()
                        << ") ";

    if (m_dataWriter == nullptr) {
      ERROR_LOG() << "No dataWriter initialised ";
      return false;
    }

    if (si.is_set())
    {
      rti::pub::WriteParams writeParams;
      rti::core::SampleIdentity sampleIdentity(si.get()->source_guid(), si.get()->publication_sequence_number());
      writeParams.related_sample_identity(sampleIdentity);

      m_dataWriter->write(data, writeParams);
    } else {
      m_dataWriter.write(data);
    }
    return true;
  }

  bool remove(const TopicType &data, bool errorMsgIfNotExists = true)
  {
    DEBUG_LOG() << "IN remove ("
                        << DDS::topic_type_name<TopicType>::value()
                        << ") ";

    if (m_dataWriter == nullptr) {
      ERROR_LOG() << "No dataWriter initialised ";
      return false;
    }
    const dds::core::InstanceHandle ih = m_dataWriter.lookup_instance(data);
    if (ih.is_nil()) {
      if (errorMsgIfNotExists)
        ERROR_LOG() << "Could not find instance for topic "
                            << DDS::topic_type_name<TopicType>::value()
                            << " for unregistering!";
      return false;
    }
    m_dataWriter.dispose_instance(ih);
    return true;
  }

  DataWriter dataWriter() const { return m_dataWriter; }

private:
  DataWriter m_dataWriter;
  DataTopic  m_ddsTopic;
};

}