RoutingService.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_HPP_
#define RTI_ROUTING_ROUTING_SERVICE_HPP_

#include <dds/core/Reference.hpp>
#include <rti/config/Logger.hpp>

#include "routingservice/routingservice_adapter_new.h"

#include <rti/routing/ServiceProperty.hpp>
#include <rti/routing/detail/RoutingServiceImpl.hpp>
#include <rti/routing/adapter/AdapterPlugin.hpp>
#include <rti/routing/processor/ProcessorPlugin.hpp>

namespace rti { namespace routing {

/*e \defgroup RTI_RoutingServiceLibModule RTI Routing Service API
 * \ingroup ROUTER
 * 
 * @brief @product  can be deployed as a native library linked into your
 * application in select architectures.
 *
 * This API allows you to create, configure and start @product instances from
 * your application.
 *
 * The following code shows the typical use of the API:
 *
 * \code
 *
 * int main ()
 * {
 *     rti::routing::RoutingService service(
 *             rti::routing::ServiceProperty()
 *             .cfg_file("MyRouter.xml")
 *             .cfg_name("MyRouter"));
 *     ...
 * 
 *     service.start();
 *
 *     while(keep_running) {
 *         sleep();
 *         ...
 *     }
 *
 *     return 0;
 * }
 *
 * \endcode
 *
 * Instead of a file, you can use XML strings to configure @product.
 * See ServiceProperty for more information.
 * <p>
 * To build your application you need to link with the @product native library
 * in <b> &lt;@ndds home&gt;/bin/&lt;architecture&gt;/ </b>.
 *
 * ### Development Requirements
 *
 * |                 | Unix-based Systems                      | Windows Systems           |
 * | --------------: | :----------------:                      | :-------------:           |
 * | Shared Libraries| libnddscpp2.so                          | nddscpp2.dll              |
 * | ^               | librtirsinfrastructure.so               | rtirsinfrastructure.dll   |
 * | ^               | librtidlc.so                            | rtidlc.dll                |
 * | ^               | libnddsmetp.so                          | nddsmetp.dll              |
 * | ^               | libnddsc.so                             | nddsc.dll                 |
 * | ^               | librtixml2.so                           | rtixml2.dll               |
 * | ^               | libnddscore.so                          | nddscore.dll              |
 * | Headers         | rti/routing/RoutingService.hpp          ||
 * 
 */

class RoutingService : public dds::core::Reference<RoutingServiceImpl> {
public:
    typedef dds::core::Reference<RoutingServiceImpl> Base;
    OMG_DDS_REF_TYPE_NOTYPENAME(
            RoutingService,
            dds::core::Reference,
            RoutingServiceImpl);

    explicit RoutingService(const ServiceProperty& property)
            : Base(new RoutingServiceImpl(property))
    {
        this->delegate()->remember_reference(this->delegate());
    }

    RoutingService(const RTI_RoutingServiceProperty& property)
            : Base(new RoutingServiceImpl(property))
    {
        this->delegate()->remember_reference(this->delegate());
    }
    
    explicit RoutingService(Base::DELEGATE_REF_T reference) : Base(reference)
    {
        if (this->delegate()) {
            this->delegate()->remember_reference(this->delegate());
        }
    }

    void start()
    {
        this->delegate()->start();
    }

    void stop()
    {
        this->delegate()->stop();
    }

    void attach_adapter_plugin(
            rti::routing::adapter::AdapterPlugin *adapter_plugin,
            const std::string& plugin_name)
    {         
        this->delegate()->attach_adapter_plugin(
                adapter_plugin,
                plugin_name);
    }

    void attach_processor_plugin(
            rti::routing::processor::ProcessorPlugin *processor_plugin,
            const std::string& plugin_name)
    {
        this->delegate()->attach_processor_plugin(
                processor_plugin,
                plugin_name);
    }

    void attach_transformation_plugin(
            rti::routing::transf::TransformationPlugin *transformation_plugin,
            const std::string& plugin_name)
    {         
        this->delegate()->attach_transformation_plugin(
                transformation_plugin,
                plugin_name);
    }


    static void finalize_globals()
    {
        RoutingServiceImpl::finalize_globals();
    }

};

class Logger
{
public:

    typedef rti::config::Verbosity Verbosity;
    typedef rti::config::LogCategory LogCategory;
    typedef rti::config::LoggerMode LoggerMode;
    typedef rti::config::PrintFormat PrintFormat;

    static Logger& instance()
    {
        static Logger singleton;
        return singleton;
    }

    void service_verbosity(rti::config::Verbosity verbosity)
    {
        RTILogBitmap submodule_mask = ROUTER_SUBMODULE_MASK_ALL;
        ROUTERLog_setBitmaps(
                submodule_mask,
                static_cast<RTILogBitmap>(verbosity.underlying()));
    }

     rti::config::Verbosity service_verbosity()
    {
        RTILogBitmap submodule_mask = ROUTER_SUBMODULE_MASK_ALL;
        RTILogBitmap instrumentation_mask = ROUTER_SUBMODULE_MASK_ALL;
        ROUTERLog_getBitmaps(&submodule_mask, &instrumentation_mask);

        return static_cast<rti::config::Verbosity::type>(instrumentation_mask);
    }    

    virtual ~Logger()
    {
    }

private:

    Logger()
    {
    }
     // Disable copy
    Logger(const Logger&);
    Logger& operator=(const Logger&);
};

}}

#endif // RTI_ROUTING_ROUTING_SERVICE_HPP_