Route.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_PROCESSOR_ROUTE_HPP_
#define RTI_ROUTING_PROCESSOR_ROUTE_HPP_
 
#include <dds/core/Value.hpp>
#include <dds/core/SafeEnumeration.hpp>
#include <rti/core/NativeValueType.hpp>
 
#include "routingservice/routingservice_processor.h"
#include "routingservice/routingservice_processor_impl.h"
 
#include <dds/core/xtypes/DynamicData.hpp>
#include <dds/sub/SampleInfo.hpp>
#include <rti/routing/adapter/AdapterPlugin.hpp>
#include <rti/routing/processor/Input.hpp>
#include <rti/routing/processor/Output.hpp>
#include <rti/routing/processor/LoanedSamples.hpp>
#include <rti/routing/processor/PortIterator.hpp>
 
namespace rti { namespace routing { namespace processor {
 
namespace detail {
 
class ProcessorForwarder;
 
}
 
class Route;
 
template <typename PORT> struct port_list;
 
template <> struct port_list<Input>
{
    static std::vector<Input>& get(Route& route);
};
 
template <> struct port_list<Output>
{
    static std::vector<Output>& get(Route& route);
};
 
class Route {
 
public:
 
    template <typename DataRep, typename InfoRep = dds::sub::SampleInfo>
    struct Inputs {
        typedef PortIterator<Input, DataRep, InfoRep> iterator;
 
        Inputs(RTI_RoutingServiceRoute *native_route)
                : native_route_(native_route)
        {
        }
 
        iterator begin()
        {
            return iterator(native_route_);
        }
 
        iterator end()
        {
            return iterator();
        }
 
    private:
        RTI_RoutingServiceRoute *native_route_;
    };
 
    template <typename DataRep, typename InfoRep = dds::sub::SampleInfo>
    struct Outputs {
        typedef PortIterator<Output, DataRep, InfoRep> iterator;
 
        Outputs(RTI_RoutingServiceRoute *native_route)
                : native_route_(native_route)
        {
        }
 
        iterator begin()
        {
            return iterator(native_route_);
        }
 
        iterator end()
        {
            return iterator();
        }
 
    private:
        RTI_RoutingServiceRoute *native_route_;
    };
 
 
    int32_t input_count() const
    {
        return RTI_RoutingServiceRoute_get_input_count(native_route_);
    }
 
    int32_t output_count() const
    {
        return RTI_RoutingServiceRoute_get_output_count(native_route_);
    }
 
    bool input_enabled(int32_t index) const
    {
        return RTI_RoutingServiceRoute_is_input_enabled(native_route_, index)
                ? true
                : false;
    }
 
    bool output_enabled(int32_t index) const
    {
        return RTI_RoutingServiceRoute_is_output_enabled(native_route_, index)
                ? true
                : false;
    }
 
    Input& input(int32_t index)
    {
        return *(get_input_at_index(index));
    }
 
    Input& input(const std::string& name)
    {
        return *(lookup_input(name));
    }
 
    template <typename DataRep, typename InfoRep>
    TypedInput<DataRep, InfoRep> input(int32_t index)
    {
        return &input(index);
    }
 
    template <typename DataRep>
    TypedInput<DataRep> input(int32_t index)
    {
        return input<DataRep, dds::sub::SampleInfo>(index);
    }
 
    template <typename DataRep, typename InfoRep>
    TypedInput<DataRep, InfoRep> input(const std::string& name)
    {
        return &input(name);
    }
 
    template <typename DataRep>
    TypedInput<DataRep> input(const std::string& name)
    {
        return input<DataRep, dds::sub::SampleInfo>(name);
    }
 
    Output& output(int32_t index)
    {
        return *(get_output_at_index(index));
    }
 
    Output& output(const std::string& name)
    {
        return *(lookup_output(name));
    }
 
    template <typename DataRep, typename InfoRep>
    TypedOutput<DataRep, InfoRep> output(int32_t index)
    {
        return &output(index);
    }
 
    template <typename DataRep>
    TypedOutput<DataRep> output(int32_t index)
    {
        return output<DataRep, dds::sub::SampleInfo>(index);
    }
 
    template <typename DataRep, typename InfoRep>
    TypedOutput<DataRep, InfoRep> output(const std::string& name)
    {
        return &output(name);
    }
 
    template <typename DataRep>
    TypedOutput<DataRep> output(const std::string& name)
    {
        return output<DataRep, dds::sub::SampleInfo>(name);
    }
 
    template <typename DataRep, typename InfoRep>
    Inputs<DataRep, InfoRep> inputs()
    {
        return Inputs<DataRep, InfoRep>(native_route_);
    }
 
    template <typename DataRep>
    Inputs<DataRep> inputs()
    {
        return inputs<DataRep, dds::sub::SampleInfo>();
    }
 
    template <typename DataRep, typename InfoRep>
    Outputs<DataRep, InfoRep> outputs()
    {
        return Outputs<DataRep, InfoRep>(native_route_);
    }
 
    template <typename DataRep>
    Outputs<DataRep> outputs()
    {
        return outputs<DataRep, dds::sub::SampleInfo>();
    }
 
    void period(const dds::core::Duration& period)
    {
        struct DDS_Duration_t native_period;
        rti::core::native_conversions::to_native(native_period, period);
        RTI_RoutingServiceRoute_set_period(
                native_route_,
                &native_period);
    }
 
    dds::core::Duration period() const
    {
        struct DDS_Duration_t native_period;
        RTI_RoutingServiceRoute_get_period(
                native_route_,
                &native_period);
 
        return rti::core::native_conversions::from_native(native_period);
    }
 
    const std::string& full_name() const
    {
        return full_name_;
    }
 
 
private:
    friend class detail::ProcessorForwarder;
    friend class Output;
    friend struct port_list<Input>;
    friend struct port_list<Output>;
 
    typedef std::vector<Input>::iterator private_input_it;
    typedef std::vector<Output>::iterator private_output_it;
 
    Route& operator= (const Route& other);
 
    Route(RTI_RoutingServiceRoute *native_route,
            RTI_RoutingServiceEnvironment *native_env)
        : native_route_(native_route),
          native_env_(native_env)
    {
        const char *native_full_name =
                RTI_RoutingServiceRoute_get_full_name(native_route);
        if (native_full_name == nullptr) {
            throw dds::core::InvalidArgumentError(
                    "Native Route has invalid full name");
        }
        full_name_ = native_full_name;
    }
 
    Input* get_input_at_index(int32_t index)
    {
        RTI_RoutingServiceInput *native_input =
                RTI_RoutingServiceRoute_get_input_at(native_route_, index);
        if (native_input == NULL) {
            throw dds::core::InvalidArgumentError(
                    RTI_RoutingServiceEnvironment_get_error_message(native_env_));
        }
 
        return static_cast<Input*>(RTI_RoutingServiceInput_get_user_data(native_input));
    }
 
    Output* get_output_at_index(int32_t index)
    {
        RTI_RoutingServiceOutput *native_output =
                RTI_RoutingServiceRoute_get_output_at(native_route_, index);
        if (native_output == NULL) {
            throw dds::core::InvalidArgumentError(
                    RTI_RoutingServiceEnvironment_get_error_message(native_env_));
        }
 
        return static_cast<Output*>(RTI_RoutingServiceOutput_get_user_data(native_output));
    }
 
 
    Input* lookup_input(const std::string& name)
    {
        RTI_RoutingServiceInput *native_input =
                RTI_RoutingServiceRoute_lookup_input_by_name(
                        native_route_,
                        name.c_str());
        if (native_input == NULL) {
            throw dds::core::InvalidArgumentError(
                    RTI_RoutingServiceEnvironment_get_error_message(native_env_));
        }
        return static_cast<Input*>(RTI_RoutingServiceInput_get_user_data(native_input));
 
    }
 
    Output* lookup_output(const std::string& name)
    {
       RTI_RoutingServiceOutput *native_output =
                RTI_RoutingServiceRoute_lookup_output_by_name(
                        native_route_,
                        name.c_str());
        if (native_output == NULL) {
            throw dds::core::InvalidArgumentError(
                    RTI_RoutingServiceEnvironment_get_error_message(native_env_));
        }
        return  static_cast<Output*>(RTI_RoutingServiceOutput_get_user_data(native_output));
 
    }
 
private:
    RTI_RoutingServiceRoute *native_route_;
    RTI_RoutingServiceEnvironment *native_env_;
    std::string full_name_;
 
};
 
 
} } }
 
#endif // RTI_ROUTING_PROCESSOR_ROUTE_HPP_