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),
        full_name_(RTI_RoutingServiceRoute_get_full_name(native_route))
    {
    }

    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_