publisher.hpp

Go to the documentation of this file.

#ifndef RAD_MAL_PUBLISHER_HPP
#define RAD_MAL_PUBLISHER_HPP

#include <rad/assert.hpp>
#include <rad/logger.hpp>

#include <mal/Cii.hpp>
#include <mal/Mal.hpp>
#include <mal/utility/LoadMal.hpp>

#include <chrono>

namespace rad {
namespace cii {

template <typename TOPIC_TYPE>
class Publisher {
   public:
    Publisher(const elt::mal::Uri& uri,
              const std::optional<elt::mal::Mal::Properties> mal_properties = {})
        : m_publisher() {
        RAD_TRACE(GetLogger());

        m_publisher = elt::mal::CiiFactory::getInstance().getPublisher<TOPIC_TYPE>(
            elt::mal::Uri(uri), elt::mal::ps::qos::QoS::DEFAULT,
            mal_properties ? *mal_properties : elt::mal::Mal::Properties());
        RAD_ASSERTPTR(m_publisher);

#if 0
        elt::mal::CiiFactory& factory = elt::mal::CiiFactory::getInstance();

        elt::mal::Mal::Properties mal_properties;
        auto mal_instance = elt::mal::loadMal(malType, mal_properties);

        auto uri = elt::mal::Uri(uriStr);
        std::string scheme = uri.scheme().to_string();
        factory.registerMal(scheme, mal_instance);

        m_publisher = factory.getPublisher<TOPIC_TYPE>(uri, elt::mal::ps::qos::QoS::DEFAULT, mal_properties);
        if (m_publisher == nullptr) {
            throw std::runtime_error("Cannot create publisher");
        }

        auto topicInstance = m_publisher->createDataEntity();
        if (topicInstance == nullptr) {
            throw std::runtime_error("Publisher cannot create data entity");
        }

        m_instance_publisher = m_publisher->createInstancePublisher(*topicInstance);
        if (m_instance_publisher == nullptr) {
            throw std::runtime_error("Publisher cannot create instance publisher");
        }
#endif
#if 0
        auto sample = m_instance_publisher->createDataEntity();
        if (sample == nullptr) {
            throw std::runtime_error("Instance publisher cannot create data entity");
        }
#endif
    }

    ~Publisher() { RAD_TRACE(GetLogger()); }

    std::shared_ptr<TOPIC_TYPE> CreateTopic() const {
        RAD_TRACE(GetLogger());
        return m_publisher->createDataEntity();
    }

    void Publish(const TOPIC_TYPE& topic) {
        RAD_TRACE(GetLogger());
        m_publisher->publish(topic,
                             std::chrono::milliseconds(0) /* timeout = 0 for async publishing */);
    }

    Publisher(const Publisher&) = delete;
    Publisher& operator=(const Publisher&) = delete;

   private:
    std::unique_ptr<elt::mal::ps::Publisher<TOPIC_TYPE>> m_publisher;  // MAL topic publisher.
    // std::unique_ptr<elt::mal::ps::InstancePublisher<TOPIC_TYPE>> m_instance_publisher;
};

}  // namespace cii
}  // namespace rad

#endif  // RAD_MAL_SUBSCRIBER_HPP