Program Listing for File TypeIdentifierTypes.h

↰ Return to documentation for file (/tmp/ws/src/fastrtps/include/fastrtps/types/TypeIdentifierTypes.h)

// Copyright 2016 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 _TYPEIDENTIFIERTYPES_H_
#define _TYPEIDENTIFIERTYPES_H_

#include <fastrtps/types/TypesBase.h>
#include <fastrtps/types/TypeObjectHashId.h>
#include <stdint.h>
#include <array>
#include <string>
#include <vector>

namespace eprosima {
namespace fastcdr {
class Cdr;
}
}

namespace eprosima {

namespace fastdds {
namespace dds {
class TypeConsistencyEnforcementQosPolicy;
}
}

namespace fastrtps {
namespace types {


// Forward declaration
class TypeIdentifier;
class StringLTypeDefn;

class StringSTypeDefn final
{
public:

    RTPS_DllAPI StringSTypeDefn();

    RTPS_DllAPI ~StringSTypeDefn();

    RTPS_DllAPI StringSTypeDefn(
            const StringSTypeDefn& x);

    RTPS_DllAPI StringSTypeDefn(
            StringSTypeDefn&& x);

    RTPS_DllAPI StringSTypeDefn& operator=(
            const StringSTypeDefn& x);

    RTPS_DllAPI StringSTypeDefn& operator=(
            StringSTypeDefn&& x);

    RTPS_DllAPI inline void bound(
            SBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline SBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline SBound& bound()
    {
        return m_bound;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const StringSTypeDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const StringSTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

    RTPS_DllAPI bool consistent(
            const StringLTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    SBound m_bound;
};
class StringLTypeDefn final
{
public:

    RTPS_DllAPI StringLTypeDefn();

    RTPS_DllAPI ~StringLTypeDefn();

    RTPS_DllAPI StringLTypeDefn(
            const StringLTypeDefn& x);

    RTPS_DllAPI StringLTypeDefn(
            StringLTypeDefn&& x);

    RTPS_DllAPI StringLTypeDefn& operator=(
            const StringLTypeDefn& x);

    RTPS_DllAPI StringLTypeDefn& operator=(
            StringLTypeDefn&& x);

    RTPS_DllAPI inline void bound(
            LBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline LBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline LBound& bound()
    {
        return m_bound;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const StringLTypeDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const StringLTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

    RTPS_DllAPI bool consistent(
            const StringSTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    LBound m_bound;
};
class PlainCollectionHeader final
{
public:

    RTPS_DllAPI PlainCollectionHeader();

    RTPS_DllAPI ~PlainCollectionHeader();

    RTPS_DllAPI PlainCollectionHeader(
            const PlainCollectionHeader& x);

    RTPS_DllAPI PlainCollectionHeader(
            PlainCollectionHeader&& x);

    RTPS_DllAPI PlainCollectionHeader& operator=(
            const PlainCollectionHeader& x);

    RTPS_DllAPI PlainCollectionHeader& operator=(
            PlainCollectionHeader&& x);

    RTPS_DllAPI inline void equiv_kind(
            EquivalenceKind _equiv_kind)
    {
        m_equiv_kind = _equiv_kind;
    }

    RTPS_DllAPI inline EquivalenceKind equiv_kind() const
    {
        return m_equiv_kind;
    }

    RTPS_DllAPI inline EquivalenceKind& equiv_kind()
    {
        return m_equiv_kind;
    }
    RTPS_DllAPI inline void element_flags(
            CollectionElementFlag _element_flags)
    {
        m_element_flags = _element_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag element_flags() const
    {
        return m_element_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag& element_flags()
    {
        return m_element_flags;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainCollectionHeader& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainCollectionHeader& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    EquivalenceKind m_equiv_kind;
    CollectionElementFlag m_element_flags;
};
class PlainSequenceSElemDefn final
{
public:

    RTPS_DllAPI PlainSequenceSElemDefn();

    RTPS_DllAPI ~PlainSequenceSElemDefn();

    RTPS_DllAPI PlainSequenceSElemDefn(
            const PlainSequenceSElemDefn& x);

    RTPS_DllAPI PlainSequenceSElemDefn(
            PlainSequenceSElemDefn&& x);

    RTPS_DllAPI PlainSequenceSElemDefn& operator=(
            const PlainSequenceSElemDefn& x);

    RTPS_DllAPI PlainSequenceSElemDefn& operator=(
            PlainSequenceSElemDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void bound(
            SBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline SBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline SBound& bound()
    {
        return m_bound;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainSequenceSElemDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainSequenceSElemDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    SBound m_bound;
    TypeIdentifier* m_element_identifier;
};
class PlainSequenceLElemDefn final
{
public:

    RTPS_DllAPI PlainSequenceLElemDefn();

    RTPS_DllAPI ~PlainSequenceLElemDefn();

    RTPS_DllAPI PlainSequenceLElemDefn(
            const PlainSequenceLElemDefn& x);

    RTPS_DllAPI PlainSequenceLElemDefn(
            PlainSequenceLElemDefn&& x);

    RTPS_DllAPI PlainSequenceLElemDefn& operator=(
            const PlainSequenceLElemDefn& x);

    RTPS_DllAPI PlainSequenceLElemDefn& operator=(
            PlainSequenceLElemDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void bound(
            LBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline LBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline LBound& bound()
    {
        return m_bound;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainSequenceLElemDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainSequenceLElemDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    LBound m_bound;
    TypeIdentifier* m_element_identifier;
};
class PlainArraySElemDefn final
{
public:

    RTPS_DllAPI PlainArraySElemDefn();

    RTPS_DllAPI ~PlainArraySElemDefn();

    RTPS_DllAPI PlainArraySElemDefn(
            const PlainArraySElemDefn& x);

    RTPS_DllAPI PlainArraySElemDefn(
            PlainArraySElemDefn&& x);

    RTPS_DllAPI PlainArraySElemDefn& operator=(
            const PlainArraySElemDefn& x);

    RTPS_DllAPI PlainArraySElemDefn& operator=(
            PlainArraySElemDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void array_bound_seq(
            const SBoundSeq& _array_bound_seq)
    {
        m_array_bound_seq = _array_bound_seq;
    }

    RTPS_DllAPI inline void array_bound_seq(
            SBoundSeq&& _array_bound_seq)
    {
        m_array_bound_seq = std::move(_array_bound_seq);
    }

    RTPS_DllAPI inline const SBoundSeq& array_bound_seq() const
    {
        return m_array_bound_seq;
    }

    RTPS_DllAPI inline SBoundSeq& array_bound_seq()
    {
        return m_array_bound_seq;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainArraySElemDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainArraySElemDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    SBoundSeq m_array_bound_seq;
    TypeIdentifier* m_element_identifier;
};
class PlainArrayLElemDefn final
{
public:

    RTPS_DllAPI PlainArrayLElemDefn();

    RTPS_DllAPI ~PlainArrayLElemDefn();

    RTPS_DllAPI PlainArrayLElemDefn(
            const PlainArrayLElemDefn& x);

    RTPS_DllAPI PlainArrayLElemDefn(
            PlainArrayLElemDefn&& x);

    RTPS_DllAPI PlainArrayLElemDefn& operator=(
            const PlainArrayLElemDefn& x);

    RTPS_DllAPI PlainArrayLElemDefn& operator=(
            PlainArrayLElemDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void array_bound_seq(
            const LBoundSeq& _array_bound_seq)
    {
        m_array_bound_seq = _array_bound_seq;
    }

    RTPS_DllAPI inline void array_bound_seq(
            LBoundSeq&& _array_bound_seq)
    {
        m_array_bound_seq = std::move(_array_bound_seq);
    }

    RTPS_DllAPI inline const LBoundSeq& array_bound_seq() const
    {
        return m_array_bound_seq;
    }

    RTPS_DllAPI inline LBoundSeq& array_bound_seq()
    {
        return m_array_bound_seq;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainArrayLElemDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainArrayLElemDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    LBoundSeq m_array_bound_seq;
    TypeIdentifier* m_element_identifier;
};
class PlainMapSTypeDefn final
{
public:

    RTPS_DllAPI PlainMapSTypeDefn();

    RTPS_DllAPI ~PlainMapSTypeDefn();

    RTPS_DllAPI PlainMapSTypeDefn(
            const PlainMapSTypeDefn& x);

    RTPS_DllAPI PlainMapSTypeDefn(
            PlainMapSTypeDefn&& x);

    RTPS_DllAPI PlainMapSTypeDefn& operator=(
            const PlainMapSTypeDefn& x);

    RTPS_DllAPI PlainMapSTypeDefn& operator=(
            PlainMapSTypeDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void bound(
            SBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline SBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline SBound& bound()
    {
        return m_bound;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }
    RTPS_DllAPI inline void key_flags(
            CollectionElementFlag _key_flags)
    {
        m_key_flags = _key_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag key_flags() const
    {
        return m_key_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag& key_flags()
    {
        return m_key_flags;
    }
    RTPS_DllAPI void key_identifier(
            const TypeIdentifier* _key_identifier);

    RTPS_DllAPI inline const TypeIdentifier* key_identifier() const
    {
        return m_key_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* key_identifier()
    {
        return m_key_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainMapSTypeDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainMapSTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    SBound m_bound;
    TypeIdentifier* m_element_identifier;
    CollectionElementFlag m_key_flags;
    TypeIdentifier* m_key_identifier;
};
class PlainMapLTypeDefn final
{
public:

    RTPS_DllAPI PlainMapLTypeDefn();

    RTPS_DllAPI ~PlainMapLTypeDefn();

    RTPS_DllAPI PlainMapLTypeDefn(
            const PlainMapLTypeDefn& x);

    RTPS_DllAPI PlainMapLTypeDefn(
            PlainMapLTypeDefn&& x);

    RTPS_DllAPI PlainMapLTypeDefn& operator=(
            const PlainMapLTypeDefn& x);

    RTPS_DllAPI PlainMapLTypeDefn& operator=(
            PlainMapLTypeDefn&& x);

    RTPS_DllAPI inline void header(
            const PlainCollectionHeader& _header)
    {
        m_header = _header;
    }

    RTPS_DllAPI inline void header(
            PlainCollectionHeader&& _header)
    {
        m_header = std::move(_header);
    }

    RTPS_DllAPI inline const PlainCollectionHeader& header() const
    {
        return m_header;
    }

    RTPS_DllAPI inline PlainCollectionHeader& header()
    {
        return m_header;
    }
    RTPS_DllAPI inline void bound(
            LBound _bound)
    {
        m_bound = _bound;
    }

    RTPS_DllAPI inline LBound bound() const
    {
        return m_bound;
    }

    RTPS_DllAPI inline LBound& bound()
    {
        return m_bound;
    }
    RTPS_DllAPI void element_identifier(
            const TypeIdentifier* _element_identifier);

    RTPS_DllAPI inline const TypeIdentifier* element_identifier() const
    {
        return m_element_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* element_identifier()
    {
        return m_element_identifier;
    }
    RTPS_DllAPI inline void key_flags(
            CollectionElementFlag _key_flags)
    {
        m_key_flags = _key_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag key_flags() const
    {
        return m_key_flags;
    }

    RTPS_DllAPI inline CollectionElementFlag& key_flags()
    {
        return m_key_flags;
    }
    RTPS_DllAPI void key_identifier(
            const TypeIdentifier* _key_identifier);

    RTPS_DllAPI inline const TypeIdentifier* key_identifier() const
    {
        return m_key_identifier;
    }

    RTPS_DllAPI inline TypeIdentifier* key_identifier()
    {
        return m_key_identifier;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const PlainMapLTypeDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const PlainMapLTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    PlainCollectionHeader m_header;
    LBound m_bound;
    TypeIdentifier* m_element_identifier;
    CollectionElementFlag m_key_flags;
    TypeIdentifier* m_key_identifier;
};
class StronglyConnectedComponentId final
{
public:

    RTPS_DllAPI StronglyConnectedComponentId();

    RTPS_DllAPI ~StronglyConnectedComponentId();

    RTPS_DllAPI StronglyConnectedComponentId(
            const StronglyConnectedComponentId& x);

    RTPS_DllAPI StronglyConnectedComponentId(
            StronglyConnectedComponentId&& x);

    RTPS_DllAPI StronglyConnectedComponentId& operator=(
            const StronglyConnectedComponentId& x);

    RTPS_DllAPI StronglyConnectedComponentId& operator=(
            StronglyConnectedComponentId&& x);

    RTPS_DllAPI inline void sc_component_id(
            const TypeObjectHashId& _sc_component_id)
    {
        m_sc_component_id = _sc_component_id;
    }

    RTPS_DllAPI inline void sc_component_id(
            TypeObjectHashId&& _sc_component_id)
    {
        m_sc_component_id = std::move(_sc_component_id);
    }

    RTPS_DllAPI inline const TypeObjectHashId& sc_component_id() const
    {
        return m_sc_component_id;
    }

    RTPS_DllAPI inline TypeObjectHashId& sc_component_id()
    {
        return m_sc_component_id;
    }
    RTPS_DllAPI inline void scc_length(
            int32_t _scc_length)
    {
        m_scc_length = _scc_length;
    }

    RTPS_DllAPI inline int32_t scc_length() const
    {
        return m_scc_length;
    }

    RTPS_DllAPI inline int32_t& scc_length()
    {
        return m_scc_length;
    }
    RTPS_DllAPI inline void scc_index(
            int32_t _scc_index)
    {
        m_scc_index = _scc_index;
    }

    RTPS_DllAPI inline int32_t scc_index() const
    {
        return m_scc_index;
    }

    RTPS_DllAPI inline int32_t& scc_index()
    {
        return m_scc_index;
    }

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const StronglyConnectedComponentId& data,
            size_t current_alignment = 0);


    RTPS_DllAPI void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const StronglyConnectedComponentId& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;

private:

    TypeObjectHashId m_sc_component_id;
    int32_t m_scc_length;
    int32_t m_scc_index;
};
class ExtendedTypeDefn final
{
public:

    RTPS_DllAPI ExtendedTypeDefn();

    RTPS_DllAPI virtual ~ExtendedTypeDefn();

    RTPS_DllAPI ExtendedTypeDefn(
            const ExtendedTypeDefn& x);

    RTPS_DllAPI ExtendedTypeDefn(
            ExtendedTypeDefn&& x);

    RTPS_DllAPI virtual ExtendedTypeDefn& operator=(
            const ExtendedTypeDefn& x);

    RTPS_DllAPI virtual ExtendedTypeDefn& operator=(
            ExtendedTypeDefn&& x);

    RTPS_DllAPI static size_t getCdrSerializedSize(
            const ExtendedTypeDefn& data,
            size_t current_alignment = 0);


    RTPS_DllAPI virtual void serialize(
            eprosima::fastcdr::Cdr& cdr) const;

    RTPS_DllAPI virtual void deserialize(
            eprosima::fastcdr::Cdr& cdr);

    RTPS_DllAPI bool consistent(
            const ExtendedTypeDefn& x,
            const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


};

} // namespace types
} // namespace fastrtps
} // namespace eprosima

#endif // _TYPEIDENTIFIERTYPES_H_