RoutingServiceImpl.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2017.
 * All rights reserved.
 *
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */
 
#ifndef RTI_ROUTING_ROUTING_SERVICE_IMPL_HPP_
#define RTI_ROUTING_ROUTING_SERVICE_IMPL_HPP_
 
#include <dds/core/refmacros.hpp>
#include <rti/core/detail/SelfReference.hpp>
#include "routingservice/routingservice_adapter.h"
#include "routingservice/routingservice_service.h"
#include "routingservice/routingservice_log.h"
 
#include <rti/routing/ServiceProperty.hpp>
#include <rti/routing/adapter/detail/AdapterForwarder.hpp>
#include <rti/routing/transf/detail/TransformationPluginForwarder.hpp>
#include <rti/routing/processor/detail/ProcessorPluginForwarder.hpp>
#include <rti/routing/detail/ShutdownHookForwarder.hpp>
 
namespace rti { namespace routing {
 
class RoutingServiceImpl
        : public rti::core::detail::RetainableType<RoutingServiceImpl> {
public:
 
    template <typename HookFunc>
    explicit RoutingServiceImpl(
            const ServiceProperty& property,
            HookFunc& shutdown_hook)
            : native_(RTI_RoutingService_new(&property.native())),
            shutdown_hook_fwd_(
                    new rti::routing::detail::ShutdownHookForwarder<HookFunc>(
                            shutdown_hook))
    {
        rti::core::check_create_entity(native_, "RoutingService");
        RTI_RoutingService_set_remote_shutdown_hook(
                native_,
                shutdown_hook_fwd_->native());
    }
 
    explicit RoutingServiceImpl(const ServiceProperty& property)
            : native_(RTI_RoutingService_new(&property.native())),
              shutdown_hook_fwd_(nullptr)
    {
        rti::core::check_create_entity(native_, "RoutingService");
    }
 
    RoutingServiceImpl(const RTI_RoutingServiceProperty& property)
            : native_(RTI_RoutingService_new(&property)),
            shutdown_hook_fwd_(NULL)
    {
        rti::core::check_create_entity(native_, "RoutingService");
    }
 
    RoutingServiceImpl(RTI_RoutingService *native)
            : native_(native), shutdown_hook_fwd_(NULL)
    {
        rti::core::check_create_entity(native_, "RoutingService");
    }
 
    ~RoutingServiceImpl()
    {
        RTI_RoutingService_delete(native_);
        delete shutdown_hook_fwd_;
    }
 
    void start()
    {
        if (!RTI_RoutingService_start(native_)) {
            throw dds::core::Error("failed to start RoutingService");
        }
    }
 
    void stop()
    {
        if (!RTI_RoutingService_stop(native_)) {
            throw dds::core::Error("failed to stop RoutingService");
        }
    }
 
    void attach_adapter_plugin(
            rti::routing::adapter::AdapterPlugin *adapter_plugin,
            const std::string& registered_name)
    {
        RTI_RoutingServiceAdapterPluginExt *native_plugin =
                adapter::detail::AdapterForwarder::create_plugin(adapter_plugin);
        if (!RTI_RoutingService_attach_adapter_plugin(
                native_,
                native_plugin,
                registered_name.c_str())) {
            throw dds::core::Error("failed to attach native adapter");
        }
    }
 
    void attach_transformation_plugin(
            rti::routing::transf::TransformationPlugin *transformation_plugin,
            const std::string& registered_name)
    {
        RTI_RoutingServiceTransformationPlugin *native_plugin =
                transf::detail::TransformationPluginForwarder::create_plugin(
                        transformation_plugin);
        if (!RTI_RoutingService_attach_transformation_plugin(
                native_,
                native_plugin,
                registered_name.c_str())) {
            throw dds::core::Error("failed to attach native transformation");
        }
    }
 
    void attach_processor_plugin(
            rti::routing::processor::ProcessorPlugin *processor_plugin,
            const std::string& registered_name)
    {
        RTI_RoutingServiceProcessorPlugin *native_plugin =
                processor::detail::ProcessorPluginForwarder::create_plugin(
                        processor_plugin);
        if (!RTI_RoutingService_attach_processor_plugin(
                native_,
                native_plugin,
                registered_name.c_str())) {
            throw dds::core::Error("failed to attach native processor");
        }
    }
 
    RTI_RoutingService* native() const
    {
        return native_;
    }
 
private:
    RTI_RoutingService *native_;
    rti::routing::detail::AbstractShutdownHookForwarder *shutdown_hook_fwd_;
};
 
}}
 
#endif // RTI_ROUTINGv_ROUTING_SERVICE_IMPL_HPP_