TypeObjectUtils.hpp

// Copyright 2023 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_XTYPES_TYPE_REPRESENTATION__TYPEOBJECTUTILS_HPP
#define FASTDDS_DDS_XTYPES_TYPE_REPRESENTATION__TYPEOBJECTUTILS_HPP
 
#include <string>
 
#include <fastcdr/cdr/fixed_size_string.hpp>
#include <fastcdr/xcdr/optional.hpp>
 
#include <fastdds/dds/core/ReturnCode.hpp>
#include <fastdds/dds/xtypes/common.hpp>
#include <fastdds/dds/xtypes/dynamic_types/Types.hpp>
#include <fastdds/dds/xtypes/exception/Exception.hpp>
#include <fastdds/dds/xtypes/type_representation/TypeObject.hpp>
#include <fastdds/fastdds_dll.hpp>
 
namespace eprosima {
namespace fastdds {
namespace dds {
 
class DynamicTypeBuilderFactoryImpl;
 
namespace xtypes {
 
class TypeObjectRegistry;
 
using ReturnCode_t = eprosima::fastdds::dds::ReturnCode_t;
 
class TypeObjectUtils
{
public:
 
    FASTDDS_EXPORTED_API static const TypeObjectHashId build_type_object_hash_id(
            uint8_t discriminator,
            const EquivalenceHash& hash);
 
    FASTDDS_EXPORTED_API static CollectionElementFlag build_collection_element_flag(
            TryConstructFailAction try_construct_kind,
            bool external);
 
    FASTDDS_EXPORTED_API static StructMemberFlag build_struct_member_flag(
            TryConstructFailAction try_construct_kind,
            bool optional,
            bool must_understand,
            bool key,
            bool external);
 
    FASTDDS_EXPORTED_API static UnionMemberFlag build_union_member_flag(
            TryConstructFailAction try_construct_kind,
            bool default_member,
            bool external);
 
    FASTDDS_EXPORTED_API static UnionDiscriminatorFlag build_union_discriminator_flag(
            TryConstructFailAction try_construct_kind,
            bool key);
 
    FASTDDS_EXPORTED_API static EnumeratedLiteralFlag build_enumerated_literal_flag(
            bool default_literal);
 
    FASTDDS_EXPORTED_API static StructTypeFlag build_struct_type_flag(
            ExtensibilityKind extensibility_kind,
            bool nested,
            bool autoid_hash);
 
    FASTDDS_EXPORTED_API static UnionTypeFlag build_union_type_flag(
            ExtensibilityKind extensibility_kind,
            bool nested,
            bool autoid_hash);
 
    //{{{ Indirect Hash TypeIdentifiers
 
    FASTDDS_EXPORTED_API static const StringSTypeDefn build_string_s_type_defn(
            SBound bound);
 
    FASTDDS_EXPORTED_API static const StringLTypeDefn build_string_l_type_defn(
            LBound bound);
 
    FASTDDS_EXPORTED_API static const PlainCollectionHeader build_plain_collection_header(
            EquivalenceKind equiv_kind,
            CollectionElementFlag element_flags);
 
    FASTDDS_EXPORTED_API static const PlainSequenceSElemDefn build_plain_sequence_s_elem_defn(
            const PlainCollectionHeader& header,
            SBound s_bound,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier);
 
    FASTDDS_EXPORTED_API static const PlainSequenceLElemDefn build_plain_sequence_l_elem_defn(
            const PlainCollectionHeader& header,
            LBound l_bound,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier);
 
    template<typename element>
    static void add_array_dimension(
            std::vector<element>& array_bound_seq,
            element dimension_bound)
    {
        if (dimension_bound == INVALID_LBOUND)
        {
            throw InvalidArgumentError("bound parameter must be greater than 0");
        }
        array_bound_seq.push_back(dimension_bound);
    }
 
    FASTDDS_EXPORTED_API static const PlainArraySElemDefn build_plain_array_s_elem_defn(
            const PlainCollectionHeader& header,
            const SBoundSeq& array_bound_seq,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier);
 
    FASTDDS_EXPORTED_API static const PlainArrayLElemDefn build_plain_array_l_elem_defn(
            const PlainCollectionHeader& header,
            const LBoundSeq& array_bound_seq,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier);
 
    FASTDDS_EXPORTED_API static const PlainMapSTypeDefn build_plain_map_s_type_defn(
            const PlainCollectionHeader& header,
            const SBound bound,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier,
            const CollectionElementFlag key_flags,
            const eprosima::fastcdr::external<TypeIdentifier>& key_identifier);
 
    FASTDDS_EXPORTED_API static const PlainMapLTypeDefn build_plain_map_l_type_defn(
            const PlainCollectionHeader& header,
            const LBound bound,
            const eprosima::fastcdr::external<TypeIdentifier>& element_identifier,
            const CollectionElementFlag key_flags,
            const eprosima::fastcdr::external<TypeIdentifier>& key_identifier);
 
    FASTDDS_EXPORTED_API static const StronglyConnectedComponentId build_strongly_connected_component_id(
            const TypeObjectHashId& sc_component_id,
            int32_t scc_length,
            int32_t scc_index);
 
    FASTDDS_EXPORTED_API static const ExtendedTypeDefn build_extended_type_defn();
 
    //}}}
 
    //{{{ Register Indirect Hash TypeIdentifiers
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_s_string_type_identifier(
            const StringSTypeDefn& string,
            const std::string& type_name,
            TypeIdentifierPair& type_ids,
            bool wstring = false);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_l_string_type_identifier(
            const StringLTypeDefn& string,
            const std::string& type_name,
            TypeIdentifierPair& type_ids,
            bool wstring = false);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_s_sequence_type_identifier(
            const PlainSequenceSElemDefn& plain_seq,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_l_sequence_type_identifier(
            const PlainSequenceLElemDefn& plain_seq,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_s_array_type_identifier(
            const PlainArraySElemDefn& plain_array,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_l_array_type_identifier(
            const PlainArrayLElemDefn& plain_array,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_s_map_type_identifier(
            const PlainMapSTypeDefn& plain_map,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_l_map_type_identifier(
            const PlainMapLTypeDefn& plain_map,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_scc_type_identifier(
            const StronglyConnectedComponentId& scc,
            const std::string& type_name);
    //}}}
 
    //{{{ Annotation usage
    FASTDDS_EXPORTED_API static const ExtendedAnnotationParameterValue build_extended_annotation_parameter_value();
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            bool boolean_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value_byte(
            uint8_t byte_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            int8_t int8_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            uint8_t uint8_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            int16_t int16_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            uint16_t uint16_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            int32_t int32_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            uint32_t uint32_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            int64_t int64_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            uint64_t uint64_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            float float32_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            double float64_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            long double float128_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            char char_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            wchar_t wchar_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value_enum(
            int32_t enumerated_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            const eprosima::fastcdr::fixed_string<128>& string8_value);
 
    FASTDDS_EXPORTED_API static const AnnotationParameterValue build_annotation_parameter_value(
            const std::wstring& string16_value);
 
    FASTDDS_EXPORTED_API static const AppliedAnnotationParameter build_applied_annotation_parameter(
            const NameHash& paramname_hash,
            const AnnotationParameterValue& value);
 
    FASTDDS_EXPORTED_API static void add_applied_annotation_parameter(
            AppliedAnnotationParameterSeq& param_seq,
            const AppliedAnnotationParameter& param);
 
    FASTDDS_EXPORTED_API static const AppliedAnnotation build_applied_annotation(
            const TypeIdentifier& annotation_typeid,
            const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq);
 
    FASTDDS_EXPORTED_API static void add_applied_annotation(
            AppliedAnnotationSeq& ann_custom_seq,
            const AppliedAnnotation& ann_custom);
 
    FASTDDS_EXPORTED_API static const AppliedVerbatimAnnotation build_applied_verbatim_annotation(
            PlacementKind placement,
            const eprosima::fastcdr::fixed_string<32>& language,
            const std::string& text);
    //}}}
 
    //{{{ Aggregate types
    FASTDDS_EXPORTED_API static const AppliedBuiltinMemberAnnotations build_applied_builtin_member_annotations(
            const eprosima::fastcdr::optional<std::string>& unit,
            const eprosima::fastcdr::optional<AnnotationParameterValue>& min,
            const eprosima::fastcdr::optional<AnnotationParameterValue>& max,
            const eprosima::fastcdr::optional<std::string>& hash_id);
 
    FASTDDS_EXPORTED_API static const CommonStructMember build_common_struct_member(
            MemberId member_id,
            StructMemberFlag member_flags,
            const TypeIdentifier& member_type_id);
 
    FASTDDS_EXPORTED_API static const CompleteMemberDetail build_complete_member_detail(
            const MemberName& name,
            const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin,
            const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom);
 
    FASTDDS_EXPORTED_API static const CompleteStructMember build_complete_struct_member(
            const CommonStructMember& common,
            const CompleteMemberDetail& detail);
 
    FASTDDS_EXPORTED_API static void add_complete_struct_member(
            CompleteStructMemberSeq& member_seq,
            const CompleteStructMember& member);
 
    FASTDDS_EXPORTED_API static const AppliedBuiltinTypeAnnotations build_applied_builtin_type_annotations(
            const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim);
 
    FASTDDS_EXPORTED_API static const CompleteTypeDetail build_complete_type_detail(
            const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin,
            const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom,
            const QualifiedTypeName& type_name);
 
    FASTDDS_EXPORTED_API static const CompleteStructHeader build_complete_struct_header(
            const TypeIdentifier& base_type,
            const CompleteTypeDetail& detail);
 
    FASTDDS_EXPORTED_API static const CompleteStructType build_complete_struct_type(
            StructTypeFlag struct_flags,
            const CompleteStructHeader& header,
            const CompleteStructMemberSeq& member_seq);
 
    //}}}
 
    //{{{ Union
 
    FASTDDS_EXPORTED_API static void add_union_case_label(
            UnionCaseLabelSeq& label_seq,
            int32_t label);
 
    FASTDDS_EXPORTED_API static const CommonUnionMember build_common_union_member(
            MemberId member_id,
            UnionMemberFlag member_flags,
            const TypeIdentifier& type_id,
            const UnionCaseLabelSeq& label_seq);
 
    FASTDDS_EXPORTED_API static const CompleteUnionMember build_complete_union_member(
            const CommonUnionMember& common,
            const CompleteMemberDetail& detail);
 
    FASTDDS_EXPORTED_API static void add_complete_union_member(
            CompleteUnionMemberSeq& complete_union_member_seq,
            const CompleteUnionMember& member);
 
    FASTDDS_EXPORTED_API static const CommonDiscriminatorMember build_common_discriminator_member(
            UnionDiscriminatorFlag member_flags,
            const TypeIdentifier& type_id);
 
    FASTDDS_EXPORTED_API static const CompleteDiscriminatorMember build_complete_discriminator_member(
            const CommonDiscriminatorMember& common,
            const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin,
            const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom);
 
    FASTDDS_EXPORTED_API static const CompleteUnionHeader build_complete_union_header(
            const CompleteTypeDetail& detail);
 
    FASTDDS_EXPORTED_API static const CompleteUnionType build_complete_union_type(
            UnionTypeFlag union_flags,
            const CompleteUnionHeader& header,
            const CompleteDiscriminatorMember& discriminator,
            const CompleteUnionMemberSeq& member_seq);
 
    //}}}
 
    //{{{ Annotation
 
    FASTDDS_EXPORTED_API static const CommonAnnotationParameter build_common_annotation_parameter(
            AnnotationParameterFlag member_flags,
            const TypeIdentifier& member_type_id);
 
    FASTDDS_EXPORTED_API static const CompleteAnnotationParameter build_complete_annotation_parameter(
            const CommonAnnotationParameter& common,
            const MemberName& name,
            const AnnotationParameterValue& default_value);
 
    FASTDDS_EXPORTED_API static void add_complete_annotation_parameter(
            CompleteAnnotationParameterSeq& sequence,
            const CompleteAnnotationParameter& param);
 
    FASTDDS_EXPORTED_API static const CompleteAnnotationHeader build_complete_annotation_header(
            const QualifiedTypeName& annotation_name);
 
    FASTDDS_EXPORTED_API static const CompleteAnnotationType build_complete_annotation_type(
            AnnotationTypeFlag annotation_flag,
            const CompleteAnnotationHeader& header,
            const CompleteAnnotationParameterSeq& member_seq);
 
    //}}}
 
    //{{{ Alias
 
    FASTDDS_EXPORTED_API static const CommonAliasBody build_common_alias_body(
            AliasMemberFlag related_flags,
            const TypeIdentifier& related_type);
 
    FASTDDS_EXPORTED_API static const CompleteAliasBody build_complete_alias_body(
            const CommonAliasBody& common,
            const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin,
            const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom);
 
    FASTDDS_EXPORTED_API static const CompleteAliasHeader build_complete_alias_header(
            const CompleteTypeDetail& detail);
 
    FASTDDS_EXPORTED_API static const CompleteAliasType build_complete_alias_type(
            AliasTypeFlag alias_flags,
            const CompleteAliasHeader& header,
            const CompleteAliasBody& body);
 
    //}}}
 
    //{{{ Collections
 
    FASTDDS_EXPORTED_API static const CompleteElementDetail build_complete_element_detail(
            const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin,
            const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom);
 
    FASTDDS_EXPORTED_API static const CommonCollectionElement build_common_collection_element(
            CollectionElementFlag element_flags,
            const TypeIdentifier& type);
 
    FASTDDS_EXPORTED_API static const CompleteCollectionElement build_complete_collection_element(
            const CommonCollectionElement& common,
            const CompleteElementDetail& detail);
 
    FASTDDS_EXPORTED_API static const CommonCollectionHeader build_common_collection_header(
            LBound bound);
 
    FASTDDS_EXPORTED_API static const CompleteCollectionHeader build_complete_collection_header(
            const CommonCollectionHeader& common,
            const eprosima::fastcdr::optional<CompleteTypeDetail>& detail);
 
    //}}}
 
    //{{{ Sequence
 
    FASTDDS_EXPORTED_API static const CompleteSequenceType build_complete_sequence_type(
            CollectionTypeFlag collection_flag,
            const CompleteCollectionHeader& header,
            const CompleteCollectionElement& element);
 
    //}}}
 
    //{{{ Array
 
    FASTDDS_EXPORTED_API static const CommonArrayHeader build_common_array_header(
            const LBoundSeq& bound_seq);
 
    FASTDDS_EXPORTED_API static const CompleteArrayHeader build_complete_array_header(
            const CommonArrayHeader& common,
            const CompleteTypeDetail& detail);
 
    FASTDDS_EXPORTED_API static const CompleteArrayType build_complete_array_type(
            CollectionTypeFlag collection_flag,
            const CompleteArrayHeader& header,
            const CompleteCollectionElement& element);
 
    //}}}
 
    //{{{ Map
 
    FASTDDS_EXPORTED_API static const CompleteMapType build_complete_map_type(
            CollectionTypeFlag collection_flag,
            const CompleteCollectionHeader& header,
            const CompleteCollectionElement& key,
            const CompleteCollectionElement& element);
 
    //}}}
 
    //{{{ Enumeration
 
    FASTDDS_EXPORTED_API static const CommonEnumeratedLiteral build_common_enumerated_literal(
            int32_t value,
            EnumeratedLiteralFlag flags);
 
    FASTDDS_EXPORTED_API static const CompleteEnumeratedLiteral build_complete_enumerated_literal(
            const CommonEnumeratedLiteral& common,
            const CompleteMemberDetail& detail);
 
    FASTDDS_EXPORTED_API static void add_complete_enumerated_literal(
            CompleteEnumeratedLiteralSeq& sequence,
            const CompleteEnumeratedLiteral& enum_literal);
 
    FASTDDS_EXPORTED_API static const CommonEnumeratedHeader build_common_enumerated_header(
            BitBound bit_bound,
            bool bitmask = false);
 
    FASTDDS_EXPORTED_API static const CompleteEnumeratedHeader build_complete_enumerated_header(
            const CommonEnumeratedHeader& common,
            const CompleteTypeDetail& detail,
            bool bitmask = false);
 
    FASTDDS_EXPORTED_API static const CompleteEnumeratedType build_complete_enumerated_type(
            EnumTypeFlag enum_flags,
            const CompleteEnumeratedHeader& header,
            const CompleteEnumeratedLiteralSeq& literal_seq);
 
    //}}}
 
    //{{{ Bitmask
 
    FASTDDS_EXPORTED_API static const CommonBitflag build_common_bitflag(
            uint16_t position,
            BitflagFlag flags);
 
    FASTDDS_EXPORTED_API static const CompleteBitflag build_complete_bitflag(
            const CommonBitflag& common,
            const CompleteMemberDetail& detail);
 
    FASTDDS_EXPORTED_API static void add_complete_bitflag(
            CompleteBitflagSeq& sequence,
            const CompleteBitflag& bitflag);
 
    FASTDDS_EXPORTED_API static const CompleteBitmaskType build_complete_bitmask_type(
            BitmaskTypeFlag bitmask_flags,
            const CompleteBitmaskHeader& header,
            const CompleteBitflagSeq& flag_seq);
    //}}}
 
    //{{{ Bitset
 
    FASTDDS_EXPORTED_API static const CommonBitfield build_common_bitfield(
            uint16_t position,
            BitsetMemberFlag flags,
            uint8_t bitcount,
            TypeKind holder_type);
 
    FASTDDS_EXPORTED_API static const CompleteBitfield build_complete_bitfield(
            const CommonBitfield& common,
            const CompleteMemberDetail& detail);
 
    FASTDDS_EXPORTED_API static void add_complete_bitfield(
            CompleteBitfieldSeq& sequence,
            const CompleteBitfield& bitfield);
 
    FASTDDS_EXPORTED_API static const CompleteBitsetHeader build_complete_bitset_header(
            const CompleteTypeDetail& detail);
 
    FASTDDS_EXPORTED_API static const CompleteBitsetType build_complete_bitset_type(
            BitsetTypeFlag bitset_flags,
            const CompleteBitsetHeader& header,
            const CompleteBitfieldSeq& field_seq);
 
    //}}}
 
    //{{{ Type Object
 
    FASTDDS_EXPORTED_API static const CompleteExtendedType build_complete_extended_type();
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_alias_type_object(
            const CompleteAliasType& alias_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_annotation_type_object(
            const CompleteAnnotationType& annotation_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_struct_type_object(
            const CompleteStructType& struct_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_union_type_object(
            const CompleteUnionType& union_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_bitset_type_object(
            const CompleteBitsetType& bitset_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_sequence_type_object(
            const CompleteSequenceType& sequence_type,
            const std::string& type_name);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_array_type_object(
            const CompleteArrayType& array_type,
            const std::string& type_name);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_map_type_object(
            const CompleteMapType& map_type,
            const std::string& type_name);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_enumerated_type_object(
            const CompleteEnumeratedType& enumerated_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
 
    FASTDDS_EXPORTED_API static ReturnCode_t build_and_register_bitmask_type_object(
            const CompleteBitmaskType& bitmask_type,
            const std::string& type_name,
            TypeIdentifierPair& type_ids);
    //}}}
 
    //{{{ Auxiliary public methods
 
    FASTDDS_EXPORTED_API static const NameHash name_hash(
            const std::string& name);
 
    FASTDDS_EXPORTED_API static void type_object_consistency(
            const TypeObject& type_object);
 
    FASTDDS_EXPORTED_API static const TypeIdentifier& retrieve_minimal_type_identifier(
            const TypeIdentifierPair& type_ids,
            bool& ec);
 
    FASTDDS_EXPORTED_API static const TypeIdentifier& retrieve_complete_type_identifier(
            const TypeIdentifierPair& type_ids,
            bool& ec);
    //}}}
 
private:
 
    friend class TypeObjectRegistry;
    friend class eprosima::fastdds::dds::DynamicTypeBuilderFactoryImpl;
 
    // Class with only static methods
    TypeObjectUtils() = delete;
    ~TypeObjectUtils() = delete;
 
protected:
 
    //{{{ Auxiliary methods
 
    static void set_try_construct_behavior(
            MemberFlag& member_flag,
            TryConstructFailAction try_construct_kind);
 
    static void set_type_flag(
            TypeFlag& type_flag,
            ExtensibilityKind extensibility_kind,
            bool nested,
            bool autoid_hash);
 
    static void set_extensibility_kind(
            TypeFlag& type_flag,
            ExtensibilityKind extensibility_kind);
 
    static bool is_fully_descriptive_type_identifier(
            const TypeIdentifier& type_identifier);
 
    static bool is_direct_hash_type_identifier(
            const TypeIdentifier& type_identifier);
 
    static bool is_indirect_hash_type_identifier(
            const TypeIdentifier& type_identifier);
    //}}}
 
    //{{{ Consistency methods (Debug)
 
    static void l_bound_consistency(
            LBound bound);
 
    template<typename T>
    static void array_bound_seq_consistency(
            const T& array)
    {
        if (array.empty())
        {
            throw InvalidArgumentError("array_bound_seq parameter must not be empty");
        }
        for (auto bound : array)
        {
            if (INVALID_LBOUND == bound)
            {
                throw InvalidArgumentError("bound parameter must be greater than 0");
            }
        }
    }
 
    static void l_bound_seq_consistency(
            const LBoundSeq& bound_seq);
 
    static void collection_element_flag_consistency(
            CollectionElementFlag collection_element_flag);
 
    static void struct_member_flag_consistency(
            StructMemberFlag member_flags);
 
    static void union_member_flag_consistency(
            UnionMemberFlag union_member_flag);
 
    static void union_discriminator_flag_consistency(
            UnionDiscriminatorFlag union_discriminator_flag);
 
    static void enumerated_literal_flag_consistency(
            EnumeratedLiteralFlag enumerated_literal_flag);
 
    static void type_flag_consistency(
            TypeFlag type_flag);
 
    template<typename T>
    static void empty_flags_consistency(
            T flags)
    {
        if (flags != 0)
        {
            throw InvalidArgumentError("Flags should be empty. No flags apply");
        }
    }
 
    static void equivalence_kind_consistency(
            EquivalenceKind equiv_kind);
 
    static void plain_collection_header_consistency(
            const PlainCollectionHeader& header);
 
    static void plain_collection_type_identifier_header_consistency(
            const PlainCollectionHeader& header,
            const TypeIdentifier& element_identifier);
 
    static EquivalenceKind get_map_component_equiv_kind_for_consistency(
            const TypeIdentifier& identifier);
 
    static void plain_map_type_components_consistency(
            const PlainCollectionHeader& header,
            const TypeIdentifier& type_identifier);
 
    static void map_key_type_identifier_consistency(
            const TypeIdentifier& key_identifier);
 
    static void string_ldefn_consistency(
            const StringLTypeDefn& string);
 
    static void seq_sdefn_consistency(
            const PlainSequenceSElemDefn& plain_seq);
 
    static void seq_ldefn_consistency(
            const PlainSequenceLElemDefn& plain_seq);
 
    static void array_sdefn_consistency(
            const PlainArraySElemDefn& plain_array);
 
    static void array_ldefn_consistency(
            const PlainArrayLElemDefn& plain_array);
 
    static void map_sdefn_consistency(
            const PlainMapSTypeDefn& plain_map);
 
    static void map_ldefn_consistency(
            const PlainMapLTypeDefn& plain_map);
 
    static void direct_hash_type_identifier_consistency(
            const TypeIdentifier& type_id);
 
    static void type_identifier_consistency(
            const TypeIdentifier& type_identifier);
 
    static void applied_annotation_parameter_seq_consistency(
            const AppliedAnnotationParameterSeq& applied_annotation_parameter_seq);
 
    static void applied_annotation_type_identifier_consistency(
            const TypeIdentifier& annotation_type_id);
 
    static void applied_annotation_consistency(
            const AppliedAnnotation& applied_annotation);
 
    static void applied_annotation_seq_consistency(
            const AppliedAnnotationSeq& applied_annotation_seq);
 
    static void applied_verbatim_annotation_consistency(
            const AppliedVerbatimAnnotation& applied_verbatim_annotation);
 
    static void common_struct_member_consistency(
            const CommonStructMember& common_struct_member);
 
    static void complete_member_detail_consistency(
            const CompleteMemberDetail& complete_member_detail);
 
    static void common_struct_member_and_complete_member_detail_consistency(
            const CommonStructMember& common_struct_member,
            const CompleteMemberDetail& complete_member_detail);
 
    static void string_member_id_consistency(
            MemberId member_id,
            const std::string& string_value);
 
    static void complete_struct_member_consistency(
            const CompleteStructMember& complete_struct_member);
 
    static void complete_struct_member_seq_consistency(
            const CompleteStructMemberSeq& complete_struct_member_seq);
 
    static void applied_builtin_type_annotations_consistency(
            const AppliedBuiltinTypeAnnotations& applied_builtin_type_annotations);
 
    static void complete_type_detail_consistency(
            const CompleteTypeDetail& complete_type_detail);
 
    static void structure_base_type_consistency(
            const TypeIdentifier& base_type);
 
    static void complete_struct_header_consistency(
            const CompleteStructHeader& complete_struct_header);
 
    static void complete_struct_type_consistency(
            const CompleteStructType& complete_struct_type);
 
    static void minimal_struct_type_consistency(
            const MinimalStructType& minimal_struct_type);
 
    static void union_case_label_seq_consistency(
            const UnionCaseLabelSeq& union_case_label_seq);
 
    static void common_union_member_consistency(
            const CommonUnionMember& common_union_member);
 
    static void common_union_member_complete_member_detail_consistency(
            const CommonUnionMember& common_union_member,
            const CompleteMemberDetail& complete_member_detail);
 
    static void complete_union_member_consistency(
            const CompleteUnionMember& complete_union_member);
 
    static void complete_union_member_seq_consistency(
            const CompleteUnionMemberSeq& complete_union_member_seq);
 
    static void common_discriminator_member_type_identifier_consistency(
            const TypeIdentifier& type_id);
 
    static void common_discriminator_member_consistency(
            const CommonDiscriminatorMember& common_discriminator_member);
 
    static void complete_discriminator_member_consistency(
            const CompleteDiscriminatorMember& complete_discriminator_member);
 
    static void complete_union_header_consistency(
            const CompleteUnionHeader& complete_union_header);
 
    static void complete_union_type_consistency(
            const CompleteUnionType& complete_union_type);
 
    static void minimal_union_type_consistency(
            const MinimalUnionType& minimal_union_type);
 
    static void common_annotation_parameter_type_identifier_default_value_consistency(
            const TypeIdentifier& type_id,
            const AnnotationParameterValue& value);
 
    static void common_annotation_parameter_consistency(
            const CommonAnnotationParameter& common_annotation_parameter);
 
    static void complete_annotation_parameter_consistency(
            const CompleteAnnotationParameter& complete_annotation_parameter);
 
    static void complete_annotation_parameter_seq_consistency(
            const CompleteAnnotationParameterSeq& complete_annotation_parameter_seq);
 
    static void complete_annotation_header_consistency(
            const CompleteAnnotationHeader& complete_annotation_header);
 
    static void complete_annotation_type_consistency(
            const CompleteAnnotationType& complete_annotation_type);
 
    static void minimal_annotation_type_consistency(
            const MinimalAnnotationType& minimal_annotation_type);
 
    static void common_alias_body_consistency(
            const CommonAliasBody& common_alias_body);
 
    static void hashid_builtin_annotation_not_applied_consistency(
            const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin);
 
    static void complete_alias_body_consistency(
            const CompleteAliasBody& complete_alias_body);
 
    static void complete_alias_header_consistency(
            const CompleteAliasHeader& complete_alias_header);
 
    static void complete_alias_type_consistency(
            const CompleteAliasType& complete_alias_type);
 
    static void minimal_alias_type_consistency(
            const MinimalAliasType& minimal_alias_type);
 
    static void complete_element_detail_consistency(
            const CompleteElementDetail& complete_element_detail);
 
    static void common_collection_element_consistency(
            const CommonCollectionElement& common_collection_element);
 
    static void complete_collection_element_consistency(
            const CompleteCollectionElement& complete_collection_element);
 
    static void complete_collection_header_consistency(
            const CompleteCollectionHeader& complete_collection_header);
 
    static void complete_sequence_type_consistency(
            const CompleteSequenceType& complete_sequence_type);
 
    static void minimal_sequence_type_consistency(
            const MinimalSequenceType& minimal_sequence_type);
 
    static void common_array_header_consistency(
            const CommonArrayHeader& common_array_header);
 
    static void complete_array_header_consistency(
            const CompleteArrayHeader& complete_array_header);
 
    static void complete_array_type_consistency(
            const CompleteArrayType& complete_array_type);
 
    static void minimal_array_type_consistency(
            const MinimalArrayType& minimal_array_type);
 
    static void complete_map_type_consistency(
            const CompleteMapType& complete_map_type);
 
    static void minimal_map_type_consistency(
            const MinimalMapType& minimal_map_type);
 
    static void common_enumerated_literal_consistency(
            const CommonEnumeratedLiteral& common_enumerated_literal);
 
    static void complete_enumerated_literal_consistency(
            const CompleteEnumeratedLiteral& complete_enumerated_literal);
 
    static void complete_enumerated_literal_seq_consistency(
            const CompleteEnumeratedLiteralSeq& complete_enumerated_literal_seq);
 
    static void enum_bit_bound_consistency(
            BitBound bit_bound);
 
    static void bitmask_bit_bound_consistency(
            BitBound bit_bound);
 
    static void common_enumerated_header_consistency(
            const CommonEnumeratedHeader& common_enumerated_header,
            bool bitmask = false);
 
    static void complete_enumerated_header_consistency(
            const CompleteEnumeratedHeader& complete_enumerated_header,
            bool bitmask = false);
 
    static void complete_enumerated_type_consistency(
            const CompleteEnumeratedType& complete_enumerated_type);
 
    static void minimal_enumerated_type_consistency(
            const MinimalEnumeratedType& minimal_enumerated_type);
 
    static void bit_position_consistency(
            uint16_t position);
 
    static void common_bitflag_consistency(
            const CommonBitflag& common_bitflag);
 
    static void complete_bitflag_consistency(
            const CompleteBitflag& complete_bitflag);
 
    static void complete_bitflag_seq_consistency(
            const CompleteBitflagSeq& complete_bitflag_seq);
 
    static void complete_bitmask_type_consistency(
            const CompleteBitmaskType& complete_bitmask_type);
 
    static void minimal_bitmask_type_consistency(
            const MinimalBitmaskType& minimal_bitmask_type);
 
    static void bitfield_holder_type_consistency(
            TypeKind holder_type,
            uint8_t bitcount);
 
    static void common_bitfield_consistency(
            const CommonBitfield& common_bitfield);
 
    static void complete_bitfield_consistency(
            const CompleteBitfield& complete_bitfield);
 
    static void complete_bitfield_seq_consistency(
            const CompleteBitfieldSeq& complete_bitfield_seq);
 
    static void complete_bitset_header_consistency(
            const CompleteBitsetHeader& complete_bitset_header);
 
    static void complete_bitset_type_consistency(
            const CompleteBitsetType& complete_bitset_type);
 
    static void minimal_bitset_type_consistency(
            const MinimalBitsetType& minimal_bitset_type);
 
    static void complete_type_object_consistency(
            const CompleteTypeObject& complete_type_object);
 
    static void minimal_type_object_consistency(
            const MinimalTypeObject& minimal_type_object);
    //}}}
};
 
} // xtypes
} // dds
} // fastdds
} // eprosima
 
#endif // FASTDDS_DDS_XTYPES_TYPE_REPRESENTATION__TYPEOBJECTUTILS_HPP