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 fastcdr
} // namespace eprosima
 
namespace eprosima {
 
namespace fastdds {
namespace dds {
class TypeConsistencyEnforcementQosPolicy;
} // namespace dds
} // namespace fastdds
 
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_