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;
struct ScopedPort;

}

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_;
    };


public:

    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_);
    }

    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)
    {
        RTI_RoutingServiceRoute_set_session_period(
                native_route_,
                period.to_millisecs());
    }


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)
    {
    }

    template<typename PORT>
    PORT * get_port_from_native(void *native)
    {
        return static_cast<PORT*>(
                RTI_RoutingServiceRoute_get_stream_port_user_data(
                        native_route_,
                        native));
    }

    Input* get_input_at_index(int32_t index)
    {
        RTI_RoutingServiceStreamReaderExt *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 get_port_from_native<Input>(native_input->stream_reader_data);
    }

    Output* get_output_at_index(int32_t index)
    {
        RTI_RoutingServiceStreamWriterExt *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 get_port_from_native<Output>(
                native_output->stream_writer_data);
    }


    Input* lookup_input(const std::string& name)
    {
        RTI_RoutingServiceStreamReaderExt *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 get_port_from_native<Input>(native_input->stream_reader_data);

    }

    Output* lookup_output(const std::string& name)
    {
       RTI_RoutingServiceStreamWriterExt *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 get_port_from_native<Output>(
                native_output->stream_writer_data);

    }

    RTI_RoutingServiceRoute *native_route_;
    RTI_RoutingServiceEnvironment *native_env_;

};


} } }

#endif // RTI_ROUTING_PROCESSOR_ROUTE_HPP_