TopicDataType.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__TOPICDATATYPE_HPP
#define FASTDDS_DDS_TOPIC__TOPICDATATYPE_HPP
 
#include <functional>
#include <memory>
#include <string>
 
#include <fastdds/dds/core/policy/QosPolicies.hpp>
#include <fastdds/dds/xtypes/type_representation/detail/dds_xtypes_typeobject.hpp>
#include <fastdds/fastdds_dll.hpp>
#include <fastdds/rtps/common/CdrSerialization.hpp>
#include <fastdds/rtps/common/InstanceHandle.hpp>
#include <fastdds/rtps/common/SerializedPayload.hpp>
#include <fastdds/utils/md5.hpp>
 
// This version of TypeSupport has `is_bounded()`
#define TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
 
// This version of TypeSupport has `is_plain()`
#define TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
 
// This version of TypeSupport has `construct_sample()`
#define TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
 
namespace eprosima {
namespace fastdds {
 
namespace rtps {
struct SerializedPayload_t;
struct InstanceHandle_t;
} // namespace rtps
 
namespace dds {
 
class TypeSupport;

class TopicDataType
{
public:

    struct FASTDDS_EXPORTED_API Context
    {
        virtual ~Context() = default;
    };

    FASTDDS_EXPORTED_API TopicDataType() = default;

    FASTDDS_EXPORTED_API virtual ~TopicDataType() = default;

    FASTDDS_EXPORTED_API virtual bool serialize(
            const void* const data,
            rtps::SerializedPayload_t& payload,
            eprosima::fastdds::dds::DataRepresentationId_t data_representation) = 0;

    FASTDDS_EXPORTED_API virtual bool serialize_ctx(
            const std::shared_ptr<Context>& context,
            const void* const data,
            rtps::SerializedPayload_t& payload,
            eprosima::fastdds::dds::DataRepresentationId_t data_representation)
    {
        static_cast<void>(context);
        return serialize(data, payload, data_representation);
    }

    FASTDDS_EXPORTED_API virtual bool deserialize(
            rtps::SerializedPayload_t& payload,
            void* data) = 0;

    FASTDDS_EXPORTED_API virtual bool deserialize_ctx(
            const std::shared_ptr<Context>& context,
            rtps::SerializedPayload_t& payload,
            void* data)
    {
        static_cast<void>(context);
        return deserialize(payload, data);
    }

    FASTDDS_EXPORTED_API virtual uint32_t calculate_serialized_size(
            const void* const data,
            eprosima::fastdds::dds::DataRepresentationId_t data_representation) = 0;

    FASTDDS_EXPORTED_API virtual uint32_t calculate_serialized_size_ctx(
            const std::shared_ptr<Context>& context,
            const void* const data,
            eprosima::fastdds::dds::DataRepresentationId_t data_representation)
    {
        static_cast<void>(context);
        return calculate_serialized_size(data, data_representation);
    }

    FASTDDS_EXPORTED_API virtual void* create_data() = 0;

    FASTDDS_EXPORTED_API virtual void* create_data_ctx(
            const std::shared_ptr<Context>& context)
    {
        static_cast<void>(context);
        return create_data();
    }

    FASTDDS_EXPORTED_API virtual void delete_data(
            void* data) = 0;

    FASTDDS_EXPORTED_API virtual void delete_data_ctx(
            const std::shared_ptr<Context>& context,
            void* data)
    {
        static_cast<void>(context);
        delete_data(data);
    }

    FASTDDS_EXPORTED_API virtual bool compute_key(
            rtps::SerializedPayload_t& payload,
            rtps::InstanceHandle_t& ihandle,
            bool force_md5 = false) = 0;

    FASTDDS_EXPORTED_API virtual bool compute_key_ctx(
            const std::shared_ptr<Context>& context,
            rtps::SerializedPayload_t& payload,
            rtps::InstanceHandle_t& ihandle,
            bool force_md5 = false)
    {
        static_cast<void>(context);
        return compute_key(payload, ihandle, force_md5);
    }

    FASTDDS_EXPORTED_API virtual bool compute_key(
            const void* const data,
            rtps::InstanceHandle_t& ihandle,
            bool force_md5 = false) = 0;

    FASTDDS_EXPORTED_API virtual bool compute_key_ctx(
            const std::shared_ptr<Context>& context,
            const void* const data,
            rtps::InstanceHandle_t& ihandle,
            bool force_md5 = false)
    {
        static_cast<void>(context);
        return compute_key(data, ihandle, force_md5);
    }

    FASTDDS_EXPORTED_API inline void set_name(
            const std::string& nam)
    {
        topic_data_typename_ = nam;
    }

    FASTDDS_EXPORTED_API inline void set_name(
            std::string&& nam)
    {
        topic_data_typename_ = std::move(nam);
    }

    FASTDDS_EXPORTED_API inline const std::string& get_name() const
    {
        return topic_data_typename_;
    }

    FASTDDS_EXPORTED_API inline const xtypes::TypeIdentifierPair& type_identifiers() const
    {
        return type_identifiers_;
    }

    FASTDDS_EXPORTED_API virtual inline bool is_bounded() const
    {
        return false;
    }

    FASTDDS_EXPORTED_API virtual inline bool is_bounded_ctx(
            const std::shared_ptr<Context>& context) const
    {
        static_cast<void>(context);
        return is_bounded();
    }

    FASTDDS_EXPORTED_API virtual inline bool is_plain(
            DataRepresentationId_t) const
    {
        return false;
    }

    FASTDDS_EXPORTED_API virtual inline bool is_plain_ctx(
            const std::shared_ptr<Context>& context,
            DataRepresentationId_t representation) const
    {
        static_cast<void>(context);
        return is_plain(representation);
    }

    FASTDDS_EXPORTED_API virtual inline bool construct_sample(
            void* memory) const
    {
        static_cast<void>(memory);
        return false;
    }

    FASTDDS_EXPORTED_API virtual inline bool construct_sample_ctx(
            const std::shared_ptr<Context>& context,
            void* memory) const
    {
        static_cast<void>(context);
        return construct_sample(memory);
    }

    FASTDDS_EXPORTED_API virtual inline void register_type_object_representation()
    {
    }

    FASTDDS_EXPORTED_API virtual inline void register_type_object_representation_ctx(
            const std::shared_ptr<Context>& context)
    {
        static_cast<void>(context);
        register_type_object_representation();
    }

    FASTDDS_EXPORTED_API virtual inline uint32_t get_max_serialized_size_ctx(
            const std::shared_ptr<Context>& context)
    {
        static_cast<void>(context);
        return max_serialized_type_size;
    }

    uint32_t max_serialized_type_size {0};

    bool is_compute_key_provided {false};
 
protected:
 
    xtypes::TypeIdentifierPair type_identifiers_;
 
private:

    std::string topic_data_typename_;
 
};
 
} // namespace dds
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_DDS_TOPIC__TOPICDATATYPE_HPP