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>
#include <memory>
#include <optional>
 
namespace rad {
namespace cii {
 
template <typename TOPIC_TYPE>
class Publisher {
   public:
    explicit 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();
    }
 
    std::shared_ptr<::elt::mal::Mal> GetMal() const {
        RAD_TRACE(GetLogger());
        return m_publisher->getMal();
    }
 
    template<class T>
    std::shared_ptr<T> CreateDataEntity() 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