ChainingTransport.hpp

// Copyright 2021 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FASTDDS_RTPS_TRANSPORT__CHAININGTRANSPORT_HPP
#define FASTDDS_RTPS_TRANSPORT__CHAININGTRANSPORT_HPP
 
#include <map>
#include <memory>
 
#include "TransportInterface.hpp"
#include "ChainingTransportDescriptor.hpp"
 
namespace eprosima {
namespace fastdds {
namespace rtps {
 
class ChainingReceiverResource;
 
struct ChainingReceiverResourceDeleter
{
    void operator ()(
            ChainingReceiverResource* p);
};
 
using ChainingReceiverResourceReferenceType =
        std::unique_ptr<ChainingReceiverResource, ChainingReceiverResourceDeleter>;
 
class ChainingTransport : public TransportInterface
{
 
public:
 
    FASTDDS_EXPORTED_API ChainingTransport(
            const ChainingTransportDescriptor& t)
        : TransportInterface(0)
        , low_level_transport_(t.low_level_descriptor->create_transport())
    {
        transport_kind_ = low_level_transport_->kind();
    }
 
    FASTDDS_EXPORTED_API ~ChainingTransport() override = default;
 
    FASTDDS_EXPORTED_API bool init(
            const fastdds::rtps::PropertyPolicy* properties = nullptr,
            const uint32_t& max_msg_size_no_frag = 0) override
    {
        return low_level_transport_->init(properties, max_msg_size_no_frag);
    }
 
    FASTDDS_EXPORTED_API bool IsInputChannelOpen(
            const fastdds::rtps::Locator_t& loc) const override
    {
        return low_level_transport_->IsInputChannelOpen(loc);
    }
 
    FASTDDS_EXPORTED_API bool IsLocatorSupported(
            const fastdds::rtps::Locator_t& loc) const override
    {
        return low_level_transport_->IsLocatorSupported(loc);
    }
 
    FASTDDS_EXPORTED_API fastdds::rtps::Locator_t RemoteToMainLocal(
            const fastdds::rtps::Locator_t& loc) const override
    {
        return low_level_transport_->RemoteToMainLocal(loc);
    }
 
    FASTDDS_EXPORTED_API bool OpenInputChannel(
            const fastdds::rtps::Locator_t& loc,
            TransportReceiverInterface* receiver_interface,
            uint32_t max_message_size) override;
 
    FASTDDS_EXPORTED_API bool OpenOutputChannel(
            SendResourceList& sender_resource_list,
            const fastdds::rtps::Locator_t& loc) override;
 
    FASTDDS_EXPORTED_API bool CloseInputChannel(
            const fastdds::rtps::Locator_t& loc) override
    {
        return low_level_transport_->CloseInputChannel(loc);
    }
 
    FASTDDS_EXPORTED_API fastdds::rtps::LocatorList_t NormalizeLocator(
            const fastdds::rtps::Locator_t& locator) override
    {
        return low_level_transport_->NormalizeLocator(locator);
    }
 
    FASTDDS_EXPORTED_API bool is_local_locator(
            const fastdds::rtps::Locator_t& locator) const override
    {
        return low_level_transport_->is_local_locator(locator);
    }
 
    FASTDDS_EXPORTED_API bool is_localhost_allowed() const override
    {
        return low_level_transport_->is_localhost_allowed();
    }
 
    FASTDDS_EXPORTED_API NetmaskFilterInfo netmask_filter_info() const override
    {
        return low_level_transport_->netmask_filter_info();
    }
 
    FASTDDS_EXPORTED_API bool DoInputLocatorsMatch(
            const fastdds::rtps::Locator_t& locator_1,
            const fastdds::rtps::Locator_t& locator_2) const override
    {
        return low_level_transport_->DoInputLocatorsMatch(locator_1, locator_2);
    }
 
    FASTDDS_EXPORTED_API void select_locators(
            fastdds::rtps::LocatorSelector& selector) const override
    {
        return low_level_transport_->select_locators(selector);
    }
 
    FASTDDS_EXPORTED_API void AddDefaultOutputLocator(
            fastdds::rtps::LocatorList_t& defaultList) override
    {
        return low_level_transport_->AddDefaultOutputLocator(defaultList);
    }
 
    FASTDDS_EXPORTED_API bool getDefaultMetatrafficMulticastLocators(
            fastdds::rtps::LocatorList_t& locators,
            uint32_t metatraffic_multicast_port) const override
    {
        return low_level_transport_->getDefaultMetatrafficMulticastLocators(locators, metatraffic_multicast_port);
    }
 
    FASTDDS_EXPORTED_API bool getDefaultMetatrafficUnicastLocators(
            fastdds::rtps::LocatorList_t& locators,
            uint32_t metatraffic_unicast_port) const override
    {
        return low_level_transport_->getDefaultMetatrafficUnicastLocators(locators, metatraffic_unicast_port);
    }
 
    FASTDDS_EXPORTED_API bool getDefaultUnicastLocators(
            fastdds::rtps::LocatorList_t& locators,
            uint32_t unicast_port) const override
    {
        return low_level_transport_->getDefaultUnicastLocators(locators, unicast_port);
    }
 
    FASTDDS_EXPORTED_API bool fillMetatrafficMulticastLocator(
            fastdds::rtps::Locator_t& locator,
            uint32_t metatraffic_multicast_port) const override
    {
        return low_level_transport_->fillMetatrafficMulticastLocator(locator, metatraffic_multicast_port);
    }
 
    FASTDDS_EXPORTED_API bool fillMetatrafficUnicastLocator(
            fastdds::rtps::Locator_t& locator,
            uint32_t metatraffic_unicast_port) const override
    {
        return low_level_transport_->fillMetatrafficUnicastLocator(locator, metatraffic_unicast_port);
    }
 
    FASTDDS_EXPORTED_API bool configureInitialPeerLocator(
            fastdds::rtps::Locator_t& locator,
            const fastdds::rtps::PortParameters& port_params,
            uint32_t domainId,
            fastdds::rtps::LocatorList_t& list) const override
    {
        return low_level_transport_->configureInitialPeerLocator(locator, port_params, domainId, list);
    }
 
    FASTDDS_EXPORTED_API bool fillUnicastLocator(
            fastdds::rtps::Locator_t& locator,
            uint32_t well_known_port) const override
    {
        return low_level_transport_->fillUnicastLocator(locator, well_known_port);
    }
 
    FASTDDS_EXPORTED_API bool transform_remote_locator(
            const fastdds::rtps::Locator_t& remote_locator,
            fastdds::rtps::Locator_t& result_locator) const override
    {
        return low_level_transport_->transform_remote_locator(remote_locator, result_locator);
    }
 
    FASTDDS_EXPORTED_API uint32_t max_recv_buffer_size() const override
    {
        return low_level_transport_->max_recv_buffer_size();
    }
 
    FASTDDS_EXPORTED_API virtual bool send(
            fastdds::rtps::SenderResource* low_sender_resource,
            const std::vector<NetworkBuffer>& buffers,
            uint32_t total_bytes,
            fastdds::rtps::LocatorsIterator* destination_locators_begin,
            fastdds::rtps::LocatorsIterator* destination_locators_end,
            const std::chrono::steady_clock::time_point& timeout) = 0;
 
    FASTDDS_EXPORTED_API virtual bool send_w_priority(
            fastdds::rtps::SenderResource* low_sender_resource,
            const std::vector<NetworkBuffer>& buffers,
            uint32_t total_bytes,
            fastdds::rtps::LocatorsIterator* destination_locators_begin,
            fastdds::rtps::LocatorsIterator* destination_locators_end,
            const std::chrono::steady_clock::time_point& timeout,
            int32_t transport_priority)
    {
        static_cast<void>(transport_priority);
        return send(low_sender_resource, buffers, total_bytes,
                       destination_locators_begin, destination_locators_end, timeout);
    }
 
    FASTDDS_EXPORTED_API virtual void receive(
            TransportReceiverInterface* next_receiver,
            const fastdds::rtps::octet* receive_buffer,
            uint32_t receive_buffer_size,
            const fastdds::rtps::Locator_t& local_locator,
            const fastdds::rtps::Locator_t& remote_locator) = 0;
 
    FASTDDS_EXPORTED_API void update_network_interfaces() override
    {
        low_level_transport_->update_network_interfaces();
    }
 
    FASTDDS_EXPORTED_API bool transform_remote_locator(
            const fastdds::rtps::Locator_t& remote_locator,
            fastdds::rtps::Locator_t& result_locator,
            bool allowed_remote_localhost,
            bool allowed_local_localhost) const override
    {
        return low_level_transport_->transform_remote_locator(remote_locator, result_locator, allowed_remote_localhost,
                       allowed_local_localhost);
    }
 
    FASTDDS_EXPORTED_API bool is_locator_allowed(
            const fastdds::rtps::Locator_t& locator) const override
    {
        return low_level_transport_->is_locator_allowed(locator);
    }
 
    FASTDDS_EXPORTED_API bool is_locator_reachable(
            const fastdds::rtps::Locator_t& locator) override
    {
        return low_level_transport_->is_locator_reachable(locator);
    }
 
protected:
 
    std::unique_ptr<TransportInterface> low_level_transport_;
 
private:
 
    std::map<fastdds::rtps::Locator_t, ChainingReceiverResourceReferenceType> receiver_resources_;
};
 
} // namespace rtps
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_RTPS_TRANSPORT__CHAININGTRANSPORT_HPP