TypeSupport.hpp

// Copyright 2019 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_DDS_TOPIC__TYPESUPPORT_HPP
#define FASTDDS_DDS_TOPIC__TYPESUPPORT_HPP
 
#include <string>
#include <functional>
#include <memory>
 
#include <fastdds/dds/common/InstanceHandle.hpp>
#include <fastdds/dds/core/ReturnCode.hpp>
#include <fastdds/dds/topic/TopicDataType.hpp>
#include <fastdds/dds/xtypes/dynamic_types/DynamicPubSubType.hpp>
#include <fastdds/fastdds_dll.hpp>
 
namespace eprosima {
namespace fastdds {
namespace dds {
 
class DomainParticipant;
 
class TypeSupport : public std::shared_ptr<TopicDataType>
{
public:
 
    using Base = std::shared_ptr<TopicDataType>;
 
    FASTDDS_EXPORTED_API TypeSupport() noexcept = default;
 
    FASTDDS_EXPORTED_API TypeSupport(
            const TypeSupport& type) noexcept = default;
 
    FASTDDS_EXPORTED_API TypeSupport(
            TypeSupport&& type) noexcept = default;
 
    FASTDDS_EXPORTED_API TypeSupport& operator = (
            const TypeSupport& type) noexcept = default;
 
    FASTDDS_EXPORTED_API TypeSupport& operator = (
            TypeSupport&& type) noexcept = default;
 
    FASTDDS_EXPORTED_API explicit TypeSupport(
            TopicDataType* ptr)
        : std::shared_ptr<TopicDataType>(ptr)
    {
    }
 
    FASTDDS_EXPORTED_API virtual ReturnCode_t register_type(
            DomainParticipant* participant) const;
 
    FASTDDS_EXPORTED_API virtual ReturnCode_t register_type(
            DomainParticipant* participant,
            std::string type_name) const;
 
    FASTDDS_EXPORTED_API virtual const std::string& get_type_name() const
    {
        return get()->get_name();
    }
 
    FASTDDS_EXPORTED_API virtual bool serialize(
            const void* const data,
            fastdds::rtps::SerializedPayload_t& payload,
            DataRepresentationId_t data_representation);
 
    FASTDDS_EXPORTED_API virtual bool deserialize(
            fastdds::rtps::SerializedPayload_t& payload,
            void* data);
 
    FASTDDS_EXPORTED_API virtual uint32_t calculate_serialized_size(
            const void* const data,
            DataRepresentationId_t data_representation)
    {
        return get()->calculate_serialized_size(data, data_representation);
    }
 
    FASTDDS_EXPORTED_API virtual void* create_data()
    {
        return get()->create_data();
    }
 
    FASTDDS_EXPORTED_API virtual void delete_data(
            void* data)
    {
        return get()->delete_data(data);
    }
 
    FASTDDS_EXPORTED_API virtual bool compute_key(
            const void* const data,
            InstanceHandle_t& i_handle,
            bool force_md5 = false)
    {
        return get()->compute_key(data, i_handle, force_md5);
    }
 
    FASTDDS_EXPORTED_API virtual bool compute_key(
            fastdds::rtps::SerializedPayload_t& payload,
            InstanceHandle_t& i_handle,
            bool force_md5 = false)
    {
        return get()->compute_key(payload, i_handle, force_md5);
    }
 
    FASTDDS_EXPORTED_API virtual bool operator ==(
            const TypeSupport& type_support)
    {
        return get()->max_serialized_type_size == type_support->max_serialized_type_size
               && get()->is_compute_key_provided == type_support->is_compute_key_provided
               && get()->get_name() == type_support->get_name()
               && get()->type_identifiers() == type_support->type_identifiers();
    }
 
    FASTDDS_EXPORTED_API bool empty() const
    {
        return get() == nullptr;
    }
 
    FASTDDS_EXPORTED_API virtual inline bool is_bounded() const
    {
        return get()->is_bounded();
    }
 
    FASTDDS_EXPORTED_API virtual inline bool is_plain(
            DataRepresentationId_t data_representation) const
    {
        return get()->is_plain(data_representation);
    }
 
    FASTDDS_EXPORTED_API bool operator !=(
            std::nullptr_t) const
    {
        return bool(*this);
    }
 
    FASTDDS_EXPORTED_API bool operator ==(
            std::nullptr_t) const
    {
        return !*this;
    }
 
};
 
} // namespace dds
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_DDS_TOPIC__TYPESUPPORT_HPP