diff --git a/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterExpressionParserImpl/identifiers.hpp b/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterExpressionParserImpl/identifiers.hpp index dd7b3ea1d08..43549845c66 100644 --- a/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterExpressionParserImpl/identifiers.hpp +++ b/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterExpressionParserImpl/identifiers.hpp @@ -48,32 +48,57 @@ struct identifier_processor return process_bound(bound_seq[0]); } + static std::shared_ptr resolve_type( + const xtypes::TypeIdentifier& ti, + const position& pos) + { + if (xtypes::EK_COMPLETE != ti._d()) + { + return std::make_shared(ti); + } + + std::shared_ptr type_object = std::make_shared(); + if (RETCODE_OK == DomainParticipantFactory::get_instance()->type_object_registry().get_type_object( + ti, *type_object) && xtypes::EK_COMPLETE == type_object->_d()) + { + if (xtypes::TK_ALIAS == type_object->complete()._d()) + { + const xtypes::TypeIdentifier& aliased_id = + type_object->complete().alias_type().body().common().related_type(); + return resolve_type(aliased_id, pos); + } + return std::make_shared(ti); + } + throw parse_error("could not find type object definition", pos); + } + static bool type_should_be_indexed( const xtypes::TypeIdentifier& ti, std::shared_ptr& out_type, - size_t& max_size) + size_t& max_size, + const position& pos) { max_size = 0; switch (ti._d()) { case xtypes::TI_PLAIN_ARRAY_SMALL: - out_type = std::make_shared(*ti.array_sdefn().element_identifier()); + out_type = resolve_type(*ti.array_sdefn().element_identifier(), pos); max_size = process_bounds(ti.array_sdefn().array_bound_seq()); return true; case xtypes::TI_PLAIN_ARRAY_LARGE: - out_type = std::make_shared(*ti.array_ldefn().element_identifier()); + out_type = resolve_type(*ti.array_ldefn().element_identifier(), pos); max_size = process_bounds(ti.array_ldefn().array_bound_seq()); return true; case xtypes::TI_PLAIN_SEQUENCE_SMALL: - out_type = std::make_shared(*ti.seq_sdefn().element_identifier()); + out_type = resolve_type(*ti.seq_sdefn().element_identifier(), pos); max_size = process_bound(ti.seq_sdefn().bound()); return true; case xtypes::TI_PLAIN_SEQUENCE_LARGE: - out_type = std::make_shared(*ti.seq_ldefn().element_identifier()); + out_type = resolve_type(*ti.seq_ldefn().element_identifier(), pos); max_size = process_bound(ti.seq_ldefn().bound()); return true; @@ -111,11 +136,11 @@ struct identifier_processor throw parse_error("field not found", name_node.begin()); } - const xtypes::TypeIdentifier& ti = members[member_index].common().member_type_id(); + auto ti = resolve_type(members[member_index].common().member_type_id(), name_node.begin()); bool has_index = n->children.size() > 1; size_t max_size = 0; size_t array_index = std::numeric_limits::max(); - if (type_should_be_indexed(ti, identifier_state.current_type, max_size)) + if (type_should_be_indexed(*ti, identifier_state.current_type, max_size, name_node.begin())) { if (!has_index) { @@ -184,16 +209,11 @@ struct identifier_processor if (RETCODE_OK == DomainParticipantFactory::get_instance()->type_object_registry().get_type_object( ti, *type_object) && xtypes::EK_COMPLETE == type_object->_d()) { + assert(xtypes::TK_ALIAS != type_object->complete()._d()); // should be resolved already at this point if (xtypes::TK_ENUM == type_object->complete()._d()) { return DDSFilterValue::ValueKind::ENUM; } - if (xtypes::TK_ALIAS == type_object->complete()._d()) - { - const xtypes::TypeIdentifier& aliasedId = - type_object->complete().alias_type().body().common().related_type(); - return get_value_kind(aliasedId, pos); - } } } break; @@ -210,6 +230,11 @@ struct identifier_processor { if (n->is()) { + if (!state.current_type) + { + throw parse_error("undefined type identifier", n->begin()); + } + // Set data for fieldname node n->field_kind = get_value_kind(*state.current_type, n->end()); n->field_access_path = state.access_path; @@ -223,6 +248,10 @@ struct identifier_processor { if (!state.current_type) { + if (!state.type_object) + { + throw parse_error("undefined type object", n->begin()); + } add_member_access(n, state, state.type_object->complete()); } else diff --git a/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterField.cpp b/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterField.cpp index b3dc98f6baf..e1d48b65471 100644 --- a/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterField.cpp +++ b/src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterField.cpp @@ -212,11 +212,12 @@ bool DDSFilterField::set_value_using_member_id( case eprosima::fastdds::dds::xtypes::EK_COMPLETE: { + // WARNING: this assumes EK_COMPLETE is always an enumeration, aliases should be resolved when parsing int32_t valueenum {0}; ret = RETCODE_OK == data->get_int32_value(valueenum, member_id); signed_integer_value = valueenum; - break; } + break; default: break; diff --git a/test/unittest/dds/topic/DDSSQLFilter/DDSSQLFilterTests.cpp b/test/unittest/dds/topic/DDSSQLFilter/DDSSQLFilterTests.cpp index ff00a1d9f13..49068375077 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/DDSSQLFilterTests.cpp +++ b/test/unittest/dds/topic/DDSSQLFilter/DDSSQLFilterTests.cpp @@ -40,21 +40,22 @@ namespace dds { // Name of all the primitive fields used along the tests static const std::vector> primitive_fields { - {"char_field", "CHAR"}, - {"uint8_field", "INT"}, - {"int16_field", "INT"}, - {"uint16_field", "INT"}, - {"int32_field", "INT"}, - {"uint32_field", "INT"}, - {"int64_field", "INT"}, - {"uint64_field", "INT"}, - {"float_field", "FLOAT"}, - {"double_field", "FLOAT"}, - {"long_double_field", "FLOAT"}, - {"bool_field", "BOOL"}, - {"string_field", "STRING"}, - {"enum_field", "ENUM"}, - {"enum2_field", "ENUM2"} + {"char_field", "CHAR"}, + {"uint8_field", "INT"}, + {"int16_field", "INT"}, + {"uint16_field", "INT"}, + {"int32_field", "INT"}, + {"uint32_field", "INT"}, + {"int64_field", "INT"}, + {"uint64_field", "INT"}, + {"float_field", "FLOAT"}, + {"double_field", "FLOAT"}, + {"long_double_field", "FLOAT"}, + {"bool_field", "BOOL"}, + {"string_field", "STRING"}, + {"alias_string_field", "STRING"}, + {"enum_field", "ENUM"}, + {"enum2_field", "ENUM2"} }; static const std::map> type_compatibility_matrix @@ -961,13 +962,21 @@ class DDSSQLFilterValueGlobalData for (size_t i = 0; i < values.size(); ++i) { data[i].string_field(values[i]); + data[i].alias_string_field(values[i]); data[i].struct_field().string_field(values[i]); + data[i].struct_field().alias_string_field(values[i]); data[i].array_struct_field()[0].string_field(values[i]); + data[i].array_struct_field()[0].alias_string_field(values[i]); data[i].bounded_sequence_struct_field()[0].string_field(values[i]); + data[i].bounded_sequence_struct_field()[0].alias_string_field(values[i]); data[i].unbounded_sequence_struct_field()[0].string_field(values[i]); + data[i].unbounded_sequence_struct_field()[0].alias_string_field(values[i]); data[i].array_string_field()[0] = values[i]; + data[i].array_alias_string_field()[0] = values[i]; data[i].bounded_sequence_string_field().push_back(values[i]); + data[i].bounded_sequence_alias_string_field().push_back(values[i]); data[i].unbounded_sequence_string_field().push_back(values[i]); + data[i].unbounded_sequence_alias_string_field().push_back(values[i]); } } @@ -1504,6 +1513,112 @@ static std::vector get_test_filtered_value_string_input return inputs; } +static std::vector get_test_filtered_value_alias_string_inputs() +{ + static const std::array, 5> values = + { + std::pair{"''", "minus_2"}, + std::pair{"' '", "minus_1"}, + std::pair{"' AA'", "0"}, + std::pair{"' AZ'", "plus_1"}, + std::pair{"'ZZZ'", "plus_2"} + }; + + // Adding standard tests + std::vector inputs; + inputs = get_test_filtered_value_inputs_given_values_and_results("alias_string_field", values); + + // Adding tests for LIKE operator + DDSSQLFilterValueParams input; + input.test_case_name = "like_any_percent"; + input.expression = "alias_string_field LIKE '%'"; + input.samples_filtered.assign(5, true); + inputs.push_back(input); + + input.test_case_name = "like_any_star"; + input.expression = "alias_string_field LIKE '*'"; + input.samples_filtered.assign(5, true); + inputs.push_back(input); + + input.test_case_name = "like_space_percent"; + input.expression = "alias_string_field LIKE ' %'"; + input.samples_filtered.assign({ false, true, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "like_space_star"; + input.expression = "alias_string_field LIKE ' *'"; + input.samples_filtered.assign({ false, true, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "like_A_question"; + input.expression = "alias_string_field LIKE '?A?'"; + input.samples_filtered.assign({ false, false, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "like_A_underscore"; + input.expression = "alias_string_field LIKE '_A_'"; + input.samples_filtered.assign({ false, false, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "like_exact_empty"; + input.expression = "alias_string_field LIKE ''"; + input.samples_filtered.assign({ true, false, false, false, false }); + inputs.push_back(input); + + input.test_case_name = "like_exact_ZZZ"; + input.expression = "alias_string_field LIKE 'ZZZ'"; + input.samples_filtered.assign({ false, false, false, false, true }); + inputs.push_back(input); + + input.test_case_name = "like_exact_none"; + input.expression = "alias_string_field LIKE 'BBB'"; + input.samples_filtered.assign({ false, false, false, false, false }); + inputs.push_back(input); + + // Adding tests for MATCH operator + input.test_case_name = "match_any"; + input.expression = "alias_string_field match '.*'"; + input.samples_filtered.assign(5, true); + inputs.push_back(input); + + input.test_case_name = "match_space"; + input.expression = "alias_string_field match ' .*'"; + input.samples_filtered.assign({ false, true, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "match_A"; + input.expression = "alias_string_field match '.A.'"; + input.samples_filtered.assign({ false, false, true, true, false }); + inputs.push_back(input); + + input.test_case_name = "match_exact_empty"; + input.expression = "alias_string_field match ''"; + input.samples_filtered.assign({ true, false, false, false, false }); + inputs.push_back(input); + + input.test_case_name = "match_exact_ZZZ"; + input.expression = "alias_string_field match 'ZZZ'"; + input.samples_filtered.assign({ false, false, false, false, true }); + inputs.push_back(input); + + input.test_case_name = "match_exact_none"; + input.expression = "alias_string_field match 'BBB'"; + input.samples_filtered.assign({ false, false, false, false, false }); + inputs.push_back(input); + + input.test_case_name = "match_range"; + input.expression = "alias_string_field match '([A-Z])+'"; + input.samples_filtered.assign({ false, false, false, false, true }); + inputs.push_back(input); + + input.test_case_name = "match_space_and_range"; + input.expression = "alias_string_field match ' ([A-Z])+'"; + input.samples_filtered.assign({ false, false, true, true, false }); + inputs.push_back(input); + + return inputs; +} + static std::vector get_test_filtered_value_boolean_inputs() { static const std::array, 5> values = @@ -2062,6 +2177,12 @@ INSTANTIATE_TEST_SUITE_P( ::testing::ValuesIn(get_test_filtered_value_string_inputs()), DDSSQLFilterValueTests::PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P( + DDSSQLFilterValueTestsAliasString, + DDSSQLFilterValueTests, + ::testing::ValuesIn(get_test_filtered_value_alias_string_inputs()), + DDSSQLFilterValueTests::PrintToStringParamName()); + INSTANTIATE_TEST_SUITE_P( DDSSQLFilterValueTestsBool, DDSSQLFilterValueTests, diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.hpp b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.hpp index 8a69ad98bce..dd81bf91183 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.hpp +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.hpp @@ -78,6 +78,10 @@ enum class Material : int32_t CONCRETE, STONE }; +typedef eprosima::fastcdr::fixed_string<64> string_64; + +typedef string_64 alias_string; + /*! * @brief This class represents the structure StructType defined by the user in the IDL file. * @ingroup ContentFilterTestType @@ -133,6 +137,8 @@ class StructType m_string_field = x.m_string_field; + m_alias_string_field = x.m_alias_string_field; + m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; @@ -159,6 +165,7 @@ class StructType m_long_double_field = x.m_long_double_field; m_bool_field = x.m_bool_field; m_string_field = std::move(x.m_string_field); + m_alias_string_field = std::move(x.m_alias_string_field); m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; } @@ -197,6 +204,8 @@ class StructType m_string_field = x.m_string_field; + m_alias_string_field = x.m_alias_string_field; + m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; @@ -225,6 +234,7 @@ class StructType m_long_double_field = x.m_long_double_field; m_bool_field = x.m_bool_field; m_string_field = std::move(x.m_string_field); + m_alias_string_field = std::move(x.m_alias_string_field); m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; return *this; @@ -250,6 +260,7 @@ class StructType m_long_double_field == x.m_long_double_field && m_bool_field == x.m_bool_field && m_string_field == x.m_string_field && + m_alias_string_field == x.m_alias_string_field && m_enum_field == x.m_enum_field && m_enum2_field == x.m_enum2_field); } @@ -651,6 +662,45 @@ class StructType } + /*! + * @brief This function copies the value in member alias_string_field + * @param _alias_string_field New value to be copied in member alias_string_field + */ + eProsima_user_DllExport void alias_string_field( + const alias_string& _alias_string_field) + { + m_alias_string_field = _alias_string_field; + } + + /*! + * @brief This function moves the value in member alias_string_field + * @param _alias_string_field New value to be moved in member alias_string_field + */ + eProsima_user_DllExport void alias_string_field( + alias_string&& _alias_string_field) + { + m_alias_string_field = std::move(_alias_string_field); + } + + /*! + * @brief This function returns a constant reference to member alias_string_field + * @return Constant reference to member alias_string_field + */ + eProsima_user_DllExport const alias_string& alias_string_field() const + { + return m_alias_string_field; + } + + /*! + * @brief This function returns a reference to member alias_string_field + * @return Reference to member alias_string_field + */ + eProsima_user_DllExport alias_string& alias_string_field() + { + return m_alias_string_field; + } + + /*! * @brief This function sets a value in member enum_field * @param _enum_field New value for member enum_field @@ -725,6 +775,7 @@ class StructType long double m_long_double_field{0.0}; bool m_bool_field{false}; std::string m_string_field; + alias_string m_alias_string_field; Color m_enum_field{Color::RED}; Material m_enum2_field{Material::WOOD}; @@ -786,6 +837,8 @@ class ContentFilterTestType m_string_field = x.m_string_field; + m_alias_string_field = x.m_alias_string_field; + m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; @@ -818,6 +871,8 @@ class ContentFilterTestType m_array_string_field = x.m_array_string_field; + m_array_alias_string_field = x.m_array_alias_string_field; + m_array_enum_field = x.m_array_enum_field; m_array_enum2_field = x.m_array_enum2_field; @@ -850,6 +905,8 @@ class ContentFilterTestType m_bounded_sequence_string_field = x.m_bounded_sequence_string_field; + m_bounded_sequence_alias_string_field = x.m_bounded_sequence_alias_string_field; + m_bounded_sequence_enum_field = x.m_bounded_sequence_enum_field; m_bounded_sequence_enum2_field = x.m_bounded_sequence_enum2_field; @@ -882,6 +939,8 @@ class ContentFilterTestType m_unbounded_sequence_string_field = x.m_unbounded_sequence_string_field; + m_unbounded_sequence_alias_string_field = x.m_unbounded_sequence_alias_string_field; + m_unbounded_sequence_enum_field = x.m_unbounded_sequence_enum_field; m_unbounded_sequence_enum2_field = x.m_unbounded_sequence_enum2_field; @@ -910,6 +969,7 @@ class ContentFilterTestType m_long_double_field = x.m_long_double_field; m_bool_field = x.m_bool_field; m_string_field = std::move(x.m_string_field); + m_alias_string_field = std::move(x.m_alias_string_field); m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; m_struct_field = std::move(x.m_struct_field); @@ -926,6 +986,7 @@ class ContentFilterTestType m_array_long_double_field = std::move(x.m_array_long_double_field); m_array_bool_field = std::move(x.m_array_bool_field); m_array_string_field = std::move(x.m_array_string_field); + m_array_alias_string_field = std::move(x.m_array_alias_string_field); m_array_enum_field = std::move(x.m_array_enum_field); m_array_enum2_field = std::move(x.m_array_enum2_field); m_array_struct_field = std::move(x.m_array_struct_field); @@ -942,6 +1003,7 @@ class ContentFilterTestType m_bounded_sequence_long_double_field = std::move(x.m_bounded_sequence_long_double_field); m_bounded_sequence_bool_field = std::move(x.m_bounded_sequence_bool_field); m_bounded_sequence_string_field = std::move(x.m_bounded_sequence_string_field); + m_bounded_sequence_alias_string_field = std::move(x.m_bounded_sequence_alias_string_field); m_bounded_sequence_enum_field = std::move(x.m_bounded_sequence_enum_field); m_bounded_sequence_enum2_field = std::move(x.m_bounded_sequence_enum2_field); m_bounded_sequence_struct_field = std::move(x.m_bounded_sequence_struct_field); @@ -958,6 +1020,7 @@ class ContentFilterTestType m_unbounded_sequence_long_double_field = std::move(x.m_unbounded_sequence_long_double_field); m_unbounded_sequence_bool_field = std::move(x.m_unbounded_sequence_bool_field); m_unbounded_sequence_string_field = std::move(x.m_unbounded_sequence_string_field); + m_unbounded_sequence_alias_string_field = std::move(x.m_unbounded_sequence_alias_string_field); m_unbounded_sequence_enum_field = std::move(x.m_unbounded_sequence_enum_field); m_unbounded_sequence_enum2_field = std::move(x.m_unbounded_sequence_enum2_field); m_unbounded_sequence_struct_field = std::move(x.m_unbounded_sequence_struct_field); @@ -997,6 +1060,8 @@ class ContentFilterTestType m_string_field = x.m_string_field; + m_alias_string_field = x.m_alias_string_field; + m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; @@ -1029,6 +1094,8 @@ class ContentFilterTestType m_array_string_field = x.m_array_string_field; + m_array_alias_string_field = x.m_array_alias_string_field; + m_array_enum_field = x.m_array_enum_field; m_array_enum2_field = x.m_array_enum2_field; @@ -1061,6 +1128,8 @@ class ContentFilterTestType m_bounded_sequence_string_field = x.m_bounded_sequence_string_field; + m_bounded_sequence_alias_string_field = x.m_bounded_sequence_alias_string_field; + m_bounded_sequence_enum_field = x.m_bounded_sequence_enum_field; m_bounded_sequence_enum2_field = x.m_bounded_sequence_enum2_field; @@ -1093,6 +1162,8 @@ class ContentFilterTestType m_unbounded_sequence_string_field = x.m_unbounded_sequence_string_field; + m_unbounded_sequence_alias_string_field = x.m_unbounded_sequence_alias_string_field; + m_unbounded_sequence_enum_field = x.m_unbounded_sequence_enum_field; m_unbounded_sequence_enum2_field = x.m_unbounded_sequence_enum2_field; @@ -1123,6 +1194,7 @@ class ContentFilterTestType m_long_double_field = x.m_long_double_field; m_bool_field = x.m_bool_field; m_string_field = std::move(x.m_string_field); + m_alias_string_field = std::move(x.m_alias_string_field); m_enum_field = x.m_enum_field; m_enum2_field = x.m_enum2_field; m_struct_field = std::move(x.m_struct_field); @@ -1139,6 +1211,7 @@ class ContentFilterTestType m_array_long_double_field = std::move(x.m_array_long_double_field); m_array_bool_field = std::move(x.m_array_bool_field); m_array_string_field = std::move(x.m_array_string_field); + m_array_alias_string_field = std::move(x.m_array_alias_string_field); m_array_enum_field = std::move(x.m_array_enum_field); m_array_enum2_field = std::move(x.m_array_enum2_field); m_array_struct_field = std::move(x.m_array_struct_field); @@ -1155,6 +1228,7 @@ class ContentFilterTestType m_bounded_sequence_long_double_field = std::move(x.m_bounded_sequence_long_double_field); m_bounded_sequence_bool_field = std::move(x.m_bounded_sequence_bool_field); m_bounded_sequence_string_field = std::move(x.m_bounded_sequence_string_field); + m_bounded_sequence_alias_string_field = std::move(x.m_bounded_sequence_alias_string_field); m_bounded_sequence_enum_field = std::move(x.m_bounded_sequence_enum_field); m_bounded_sequence_enum2_field = std::move(x.m_bounded_sequence_enum2_field); m_bounded_sequence_struct_field = std::move(x.m_bounded_sequence_struct_field); @@ -1171,6 +1245,7 @@ class ContentFilterTestType m_unbounded_sequence_long_double_field = std::move(x.m_unbounded_sequence_long_double_field); m_unbounded_sequence_bool_field = std::move(x.m_unbounded_sequence_bool_field); m_unbounded_sequence_string_field = std::move(x.m_unbounded_sequence_string_field); + m_unbounded_sequence_alias_string_field = std::move(x.m_unbounded_sequence_alias_string_field); m_unbounded_sequence_enum_field = std::move(x.m_unbounded_sequence_enum_field); m_unbounded_sequence_enum2_field = std::move(x.m_unbounded_sequence_enum2_field); m_unbounded_sequence_struct_field = std::move(x.m_unbounded_sequence_struct_field); @@ -1197,6 +1272,7 @@ class ContentFilterTestType m_long_double_field == x.m_long_double_field && m_bool_field == x.m_bool_field && m_string_field == x.m_string_field && + m_alias_string_field == x.m_alias_string_field && m_enum_field == x.m_enum_field && m_enum2_field == x.m_enum2_field && m_struct_field == x.m_struct_field && @@ -1213,6 +1289,7 @@ class ContentFilterTestType m_array_long_double_field == x.m_array_long_double_field && m_array_bool_field == x.m_array_bool_field && m_array_string_field == x.m_array_string_field && + m_array_alias_string_field == x.m_array_alias_string_field && m_array_enum_field == x.m_array_enum_field && m_array_enum2_field == x.m_array_enum2_field && m_array_struct_field == x.m_array_struct_field && @@ -1229,6 +1306,7 @@ class ContentFilterTestType m_bounded_sequence_long_double_field == x.m_bounded_sequence_long_double_field && m_bounded_sequence_bool_field == x.m_bounded_sequence_bool_field && m_bounded_sequence_string_field == x.m_bounded_sequence_string_field && + m_bounded_sequence_alias_string_field == x.m_bounded_sequence_alias_string_field && m_bounded_sequence_enum_field == x.m_bounded_sequence_enum_field && m_bounded_sequence_enum2_field == x.m_bounded_sequence_enum2_field && m_bounded_sequence_struct_field == x.m_bounded_sequence_struct_field && @@ -1245,6 +1323,7 @@ class ContentFilterTestType m_unbounded_sequence_long_double_field == x.m_unbounded_sequence_long_double_field && m_unbounded_sequence_bool_field == x.m_unbounded_sequence_bool_field && m_unbounded_sequence_string_field == x.m_unbounded_sequence_string_field && + m_unbounded_sequence_alias_string_field == x.m_unbounded_sequence_alias_string_field && m_unbounded_sequence_enum_field == x.m_unbounded_sequence_enum_field && m_unbounded_sequence_enum2_field == x.m_unbounded_sequence_enum2_field && m_unbounded_sequence_struct_field == x.m_unbounded_sequence_struct_field); @@ -1647,6 +1726,45 @@ class ContentFilterTestType } + /*! + * @brief This function copies the value in member alias_string_field + * @param _alias_string_field New value to be copied in member alias_string_field + */ + eProsima_user_DllExport void alias_string_field( + const alias_string& _alias_string_field) + { + m_alias_string_field = _alias_string_field; + } + + /*! + * @brief This function moves the value in member alias_string_field + * @param _alias_string_field New value to be moved in member alias_string_field + */ + eProsima_user_DllExport void alias_string_field( + alias_string&& _alias_string_field) + { + m_alias_string_field = std::move(_alias_string_field); + } + + /*! + * @brief This function returns a constant reference to member alias_string_field + * @return Constant reference to member alias_string_field + */ + eProsima_user_DllExport const alias_string& alias_string_field() const + { + return m_alias_string_field; + } + + /*! + * @brief This function returns a reference to member alias_string_field + * @return Reference to member alias_string_field + */ + eProsima_user_DllExport alias_string& alias_string_field() + { + return m_alias_string_field; + } + + /*! * @brief This function sets a value in member enum_field * @param _enum_field New value for member enum_field @@ -2251,6 +2369,45 @@ class ContentFilterTestType } + /*! + * @brief This function copies the value in member array_alias_string_field + * @param _array_alias_string_field New value to be copied in member array_alias_string_field + */ + eProsima_user_DllExport void array_alias_string_field( + const std::array& _array_alias_string_field) + { + m_array_alias_string_field = _array_alias_string_field; + } + + /*! + * @brief This function moves the value in member array_alias_string_field + * @param _array_alias_string_field New value to be moved in member array_alias_string_field + */ + eProsima_user_DllExport void array_alias_string_field( + std::array&& _array_alias_string_field) + { + m_array_alias_string_field = std::move(_array_alias_string_field); + } + + /*! + * @brief This function returns a constant reference to member array_alias_string_field + * @return Constant reference to member array_alias_string_field + */ + eProsima_user_DllExport const std::array& array_alias_string_field() const + { + return m_array_alias_string_field; + } + + /*! + * @brief This function returns a reference to member array_alias_string_field + * @return Reference to member array_alias_string_field + */ + eProsima_user_DllExport std::array& array_alias_string_field() + { + return m_array_alias_string_field; + } + + /*! * @brief This function copies the value in member array_enum_field * @param _array_enum_field New value to be copied in member array_enum_field @@ -2875,6 +3032,45 @@ class ContentFilterTestType } + /*! + * @brief This function copies the value in member bounded_sequence_alias_string_field + * @param _bounded_sequence_alias_string_field New value to be copied in member bounded_sequence_alias_string_field + */ + eProsima_user_DllExport void bounded_sequence_alias_string_field( + const std::vector& _bounded_sequence_alias_string_field) + { + m_bounded_sequence_alias_string_field = _bounded_sequence_alias_string_field; + } + + /*! + * @brief This function moves the value in member bounded_sequence_alias_string_field + * @param _bounded_sequence_alias_string_field New value to be moved in member bounded_sequence_alias_string_field + */ + eProsima_user_DllExport void bounded_sequence_alias_string_field( + std::vector&& _bounded_sequence_alias_string_field) + { + m_bounded_sequence_alias_string_field = std::move(_bounded_sequence_alias_string_field); + } + + /*! + * @brief This function returns a constant reference to member bounded_sequence_alias_string_field + * @return Constant reference to member bounded_sequence_alias_string_field + */ + eProsima_user_DllExport const std::vector& bounded_sequence_alias_string_field() const + { + return m_bounded_sequence_alias_string_field; + } + + /*! + * @brief This function returns a reference to member bounded_sequence_alias_string_field + * @return Reference to member bounded_sequence_alias_string_field + */ + eProsima_user_DllExport std::vector& bounded_sequence_alias_string_field() + { + return m_bounded_sequence_alias_string_field; + } + + /*! * @brief This function copies the value in member bounded_sequence_enum_field * @param _bounded_sequence_enum_field New value to be copied in member bounded_sequence_enum_field @@ -3499,6 +3695,45 @@ class ContentFilterTestType } + /*! + * @brief This function copies the value in member unbounded_sequence_alias_string_field + * @param _unbounded_sequence_alias_string_field New value to be copied in member unbounded_sequence_alias_string_field + */ + eProsima_user_DllExport void unbounded_sequence_alias_string_field( + const std::vector& _unbounded_sequence_alias_string_field) + { + m_unbounded_sequence_alias_string_field = _unbounded_sequence_alias_string_field; + } + + /*! + * @brief This function moves the value in member unbounded_sequence_alias_string_field + * @param _unbounded_sequence_alias_string_field New value to be moved in member unbounded_sequence_alias_string_field + */ + eProsima_user_DllExport void unbounded_sequence_alias_string_field( + std::vector&& _unbounded_sequence_alias_string_field) + { + m_unbounded_sequence_alias_string_field = std::move(_unbounded_sequence_alias_string_field); + } + + /*! + * @brief This function returns a constant reference to member unbounded_sequence_alias_string_field + * @return Constant reference to member unbounded_sequence_alias_string_field + */ + eProsima_user_DllExport const std::vector& unbounded_sequence_alias_string_field() const + { + return m_unbounded_sequence_alias_string_field; + } + + /*! + * @brief This function returns a reference to member unbounded_sequence_alias_string_field + * @return Reference to member unbounded_sequence_alias_string_field + */ + eProsima_user_DllExport std::vector& unbounded_sequence_alias_string_field() + { + return m_unbounded_sequence_alias_string_field; + } + + /*! * @brief This function copies the value in member unbounded_sequence_enum_field * @param _unbounded_sequence_enum_field New value to be copied in member unbounded_sequence_enum_field @@ -3632,6 +3867,7 @@ class ContentFilterTestType long double m_long_double_field{0.0}; bool m_bool_field{false}; std::string m_string_field; + alias_string m_alias_string_field; Color m_enum_field{Color::RED}; Material m_enum2_field{Material::WOOD}; StructType m_struct_field; @@ -3648,6 +3884,7 @@ class ContentFilterTestType std::array m_array_long_double_field{0.0}; std::array m_array_bool_field{false}; std::array m_array_string_field; + std::array m_array_alias_string_field; std::array m_array_enum_field{Color::RED}; std::array m_array_enum2_field{Material::WOOD}; std::array m_array_struct_field; @@ -3664,6 +3901,7 @@ class ContentFilterTestType std::vector m_bounded_sequence_long_double_field; std::vector m_bounded_sequence_bool_field; std::vector m_bounded_sequence_string_field; + std::vector m_bounded_sequence_alias_string_field; std::vector m_bounded_sequence_enum_field; std::vector m_bounded_sequence_enum2_field; std::vector m_bounded_sequence_struct_field; @@ -3680,6 +3918,7 @@ class ContentFilterTestType std::vector m_unbounded_sequence_long_double_field; std::vector m_unbounded_sequence_bool_field; std::vector m_unbounded_sequence_string_field; + std::vector m_unbounded_sequence_alias_string_field; std::vector m_unbounded_sequence_enum_field; std::vector m_unbounded_sequence_enum2_field; std::vector m_unbounded_sequence_struct_field; diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.idl b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.idl index 75098262466..22441290216 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.idl +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestType.idl @@ -16,6 +16,9 @@ enum Material STONE }; +typedef string<64> string_64; +typedef string_64 alias_string; + @nested struct StructType { @@ -32,6 +35,7 @@ struct StructType long double long_double_field; boolean bool_field; string string_field; + alias_string alias_string_field; Color enum_field; Material enum2_field; }; @@ -55,6 +59,7 @@ struct ContentFilterTestType long double long_double_field; boolean bool_field; string string_field; + alias_string alias_string_field; Color enum_field; Material enum2_field; StructType struct_field; @@ -73,6 +78,7 @@ struct ContentFilterTestType long double array_long_double_field[max_array_size]; boolean array_bool_field[max_array_size]; string array_string_field[max_array_size]; + alias_string array_alias_string_field[max_array_size]; Color array_enum_field[max_array_size]; Material array_enum2_field[max_array_size]; StructType array_struct_field[max_array_size]; @@ -91,6 +97,7 @@ struct ContentFilterTestType sequence bounded_sequence_long_double_field; sequence bounded_sequence_bool_field; sequence bounded_sequence_string_field; + sequence bounded_sequence_alias_string_field; sequence bounded_sequence_enum_field; sequence bounded_sequence_enum2_field; sequence bounded_sequence_struct_field; @@ -109,6 +116,7 @@ struct ContentFilterTestType sequence unbounded_sequence_long_double_field; sequence unbounded_sequence_bool_field; sequence unbounded_sequence_string_field; + sequence unbounded_sequence_alias_string_field; sequence unbounded_sequence_enum_field; sequence unbounded_sequence_enum2_field; sequence unbounded_sequence_struct_field; diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.hpp b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.hpp index aeeb8ab1b76..d42471a234a 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.hpp +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.hpp @@ -23,15 +23,17 @@ #define FAST_DDS_GENERATED__CONTENTFILTERTESTTYPECDRAUX_HPP #include "ContentFilterTestType.hpp" -constexpr uint32_t StructType_max_cdr_typesize {344UL}; +constexpr uint32_t StructType_max_cdr_typesize {416UL}; constexpr uint32_t StructType_max_key_cdr_typesize {0UL}; -constexpr uint32_t ContentFilterTestType_max_cdr_typesize {6248UL}; + +constexpr uint32_t ContentFilterTestType_max_cdr_typesize {7560UL}; constexpr uint32_t ContentFilterTestType_max_key_cdr_typesize {0UL}; + namespace eprosima { namespace fastcdr { diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.ipp b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.ipp index 4a7ac4abfb9..a3b01ad9a25 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.ipp +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeCdrAux.ipp @@ -90,9 +90,12 @@ eProsima_user_DllExport size_t calculate_serialized_size( data.string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(13), - data.enum_field(), current_alignment); + data.alias_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(14), + data.enum_field(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(15), data.enum2_field(), current_alignment); @@ -126,8 +129,9 @@ eProsima_user_DllExport void serialize( << eprosima::fastcdr::MemberId(10) << data.long_double_field() << eprosima::fastcdr::MemberId(11) << data.bool_field() << eprosima::fastcdr::MemberId(12) << data.string_field() - << eprosima::fastcdr::MemberId(13) << data.enum_field() - << eprosima::fastcdr::MemberId(14) << data.enum2_field() + << eprosima::fastcdr::MemberId(13) << data.alias_string_field() + << eprosima::fastcdr::MemberId(14) << data.enum_field() + << eprosima::fastcdr::MemberId(15) << data.enum2_field() ; scdr.end_serialize_type(current_state); } @@ -198,10 +202,14 @@ eProsima_user_DllExport void deserialize( break; case 13: - dcdr >> data.enum_field(); + dcdr >> data.alias_string_field(); break; case 14: + dcdr >> data.enum_field(); + break; + + case 15: dcdr >> data.enum2_field(); break; @@ -246,6 +254,8 @@ void serialize_key( scdr << data.string_field(); + scdr << data.alias_string_field(); + scdr << data.enum_field(); scdr << data.enum2_field(); @@ -309,156 +319,168 @@ eProsima_user_DllExport size_t calculate_serialized_size( data.string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(13), - data.enum_field(), current_alignment); + data.alias_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(14), - data.enum2_field(), current_alignment); + data.enum_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(15), - data.struct_field(), current_alignment); + data.enum2_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(16), - data.array_char_field(), current_alignment); + data.struct_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(17), - data.array_uint8_field(), current_alignment); + data.array_char_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(18), - data.array_int16_field(), current_alignment); + data.array_uint8_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(19), - data.array_uint16_field(), current_alignment); + data.array_int16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(20), - data.array_int32_field(), current_alignment); + data.array_uint16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(21), - data.array_uint32_field(), current_alignment); + data.array_int32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(22), - data.array_int64_field(), current_alignment); + data.array_uint32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(23), - data.array_uint64_field(), current_alignment); + data.array_int64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(24), - data.array_float_field(), current_alignment); + data.array_uint64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(25), - data.array_double_field(), current_alignment); + data.array_float_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(26), - data.array_long_double_field(), current_alignment); + data.array_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(27), - data.array_bool_field(), current_alignment); + data.array_long_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(28), - data.array_string_field(), current_alignment); + data.array_bool_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(29), - data.array_enum_field(), current_alignment); + data.array_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(30), - data.array_enum2_field(), current_alignment); + data.array_alias_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(31), - data.array_struct_field(), current_alignment); + data.array_enum_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(32), - data.bounded_sequence_char_field(), current_alignment); + data.array_enum2_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(33), - data.bounded_sequence_uint8_field(), current_alignment); + data.array_struct_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(34), - data.bounded_sequence_int16_field(), current_alignment); + data.bounded_sequence_char_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(35), - data.bounded_sequence_uint16_field(), current_alignment); + data.bounded_sequence_uint8_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(36), - data.bounded_sequence_int32_field(), current_alignment); + data.bounded_sequence_int16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(37), - data.bounded_sequence_uint32_field(), current_alignment); + data.bounded_sequence_uint16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(38), - data.bounded_sequence_int64_field(), current_alignment); + data.bounded_sequence_int32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(39), - data.bounded_sequence_uint64_field(), current_alignment); + data.bounded_sequence_uint32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(40), - data.bounded_sequence_float_field(), current_alignment); + data.bounded_sequence_int64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(41), - data.bounded_sequence_double_field(), current_alignment); + data.bounded_sequence_uint64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(42), - data.bounded_sequence_long_double_field(), current_alignment); + data.bounded_sequence_float_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(43), - data.bounded_sequence_bool_field(), current_alignment); + data.bounded_sequence_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(44), - data.bounded_sequence_string_field(), current_alignment); + data.bounded_sequence_long_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(45), - data.bounded_sequence_enum_field(), current_alignment); + data.bounded_sequence_bool_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(46), - data.bounded_sequence_enum2_field(), current_alignment); + data.bounded_sequence_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(47), - data.bounded_sequence_struct_field(), current_alignment); + data.bounded_sequence_alias_string_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(48), - data.unbounded_sequence_char_field(), current_alignment); + data.bounded_sequence_enum_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(49), - data.unbounded_sequence_uint8_field(), current_alignment); + data.bounded_sequence_enum2_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(50), - data.unbounded_sequence_int16_field(), current_alignment); + data.bounded_sequence_struct_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(51), - data.unbounded_sequence_uint16_field(), current_alignment); + data.unbounded_sequence_char_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(52), - data.unbounded_sequence_int32_field(), current_alignment); + data.unbounded_sequence_uint8_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(53), - data.unbounded_sequence_uint32_field(), current_alignment); + data.unbounded_sequence_int16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(54), - data.unbounded_sequence_int64_field(), current_alignment); + data.unbounded_sequence_uint16_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(55), - data.unbounded_sequence_uint64_field(), current_alignment); + data.unbounded_sequence_int32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(56), - data.unbounded_sequence_float_field(), current_alignment); + data.unbounded_sequence_uint32_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(57), - data.unbounded_sequence_double_field(), current_alignment); + data.unbounded_sequence_int64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(58), - data.unbounded_sequence_long_double_field(), current_alignment); + data.unbounded_sequence_uint64_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(59), - data.unbounded_sequence_bool_field(), current_alignment); + data.unbounded_sequence_float_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(60), - data.unbounded_sequence_string_field(), current_alignment); + data.unbounded_sequence_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(61), - data.unbounded_sequence_enum_field(), current_alignment); + data.unbounded_sequence_long_double_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(62), - data.unbounded_sequence_enum2_field(), current_alignment); + data.unbounded_sequence_bool_field(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(63), + data.unbounded_sequence_string_field(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(64), + data.unbounded_sequence_alias_string_field(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(65), + data.unbounded_sequence_enum_field(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(66), + data.unbounded_sequence_enum2_field(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(67), data.unbounded_sequence_struct_field(), current_alignment); @@ -492,57 +514,61 @@ eProsima_user_DllExport void serialize( << eprosima::fastcdr::MemberId(10) << data.long_double_field() << eprosima::fastcdr::MemberId(11) << data.bool_field() << eprosima::fastcdr::MemberId(12) << data.string_field() - << eprosima::fastcdr::MemberId(13) << data.enum_field() - << eprosima::fastcdr::MemberId(14) << data.enum2_field() - << eprosima::fastcdr::MemberId(15) << data.struct_field() - << eprosima::fastcdr::MemberId(16) << data.array_char_field() - << eprosima::fastcdr::MemberId(17) << data.array_uint8_field() - << eprosima::fastcdr::MemberId(18) << data.array_int16_field() - << eprosima::fastcdr::MemberId(19) << data.array_uint16_field() - << eprosima::fastcdr::MemberId(20) << data.array_int32_field() - << eprosima::fastcdr::MemberId(21) << data.array_uint32_field() - << eprosima::fastcdr::MemberId(22) << data.array_int64_field() - << eprosima::fastcdr::MemberId(23) << data.array_uint64_field() - << eprosima::fastcdr::MemberId(24) << data.array_float_field() - << eprosima::fastcdr::MemberId(25) << data.array_double_field() - << eprosima::fastcdr::MemberId(26) << data.array_long_double_field() - << eprosima::fastcdr::MemberId(27) << data.array_bool_field() - << eprosima::fastcdr::MemberId(28) << data.array_string_field() - << eprosima::fastcdr::MemberId(29) << data.array_enum_field() - << eprosima::fastcdr::MemberId(30) << data.array_enum2_field() - << eprosima::fastcdr::MemberId(31) << data.array_struct_field() - << eprosima::fastcdr::MemberId(32) << data.bounded_sequence_char_field() - << eprosima::fastcdr::MemberId(33) << data.bounded_sequence_uint8_field() - << eprosima::fastcdr::MemberId(34) << data.bounded_sequence_int16_field() - << eprosima::fastcdr::MemberId(35) << data.bounded_sequence_uint16_field() - << eprosima::fastcdr::MemberId(36) << data.bounded_sequence_int32_field() - << eprosima::fastcdr::MemberId(37) << data.bounded_sequence_uint32_field() - << eprosima::fastcdr::MemberId(38) << data.bounded_sequence_int64_field() - << eprosima::fastcdr::MemberId(39) << data.bounded_sequence_uint64_field() - << eprosima::fastcdr::MemberId(40) << data.bounded_sequence_float_field() - << eprosima::fastcdr::MemberId(41) << data.bounded_sequence_double_field() - << eprosima::fastcdr::MemberId(42) << data.bounded_sequence_long_double_field() - << eprosima::fastcdr::MemberId(43) << data.bounded_sequence_bool_field() - << eprosima::fastcdr::MemberId(44) << data.bounded_sequence_string_field() - << eprosima::fastcdr::MemberId(45) << data.bounded_sequence_enum_field() - << eprosima::fastcdr::MemberId(46) << data.bounded_sequence_enum2_field() - << eprosima::fastcdr::MemberId(47) << data.bounded_sequence_struct_field() - << eprosima::fastcdr::MemberId(48) << data.unbounded_sequence_char_field() - << eprosima::fastcdr::MemberId(49) << data.unbounded_sequence_uint8_field() - << eprosima::fastcdr::MemberId(50) << data.unbounded_sequence_int16_field() - << eprosima::fastcdr::MemberId(51) << data.unbounded_sequence_uint16_field() - << eprosima::fastcdr::MemberId(52) << data.unbounded_sequence_int32_field() - << eprosima::fastcdr::MemberId(53) << data.unbounded_sequence_uint32_field() - << eprosima::fastcdr::MemberId(54) << data.unbounded_sequence_int64_field() - << eprosima::fastcdr::MemberId(55) << data.unbounded_sequence_uint64_field() - << eprosima::fastcdr::MemberId(56) << data.unbounded_sequence_float_field() - << eprosima::fastcdr::MemberId(57) << data.unbounded_sequence_double_field() - << eprosima::fastcdr::MemberId(58) << data.unbounded_sequence_long_double_field() - << eprosima::fastcdr::MemberId(59) << data.unbounded_sequence_bool_field() - << eprosima::fastcdr::MemberId(60) << data.unbounded_sequence_string_field() - << eprosima::fastcdr::MemberId(61) << data.unbounded_sequence_enum_field() - << eprosima::fastcdr::MemberId(62) << data.unbounded_sequence_enum2_field() - << eprosima::fastcdr::MemberId(63) << data.unbounded_sequence_struct_field() + << eprosima::fastcdr::MemberId(13) << data.alias_string_field() + << eprosima::fastcdr::MemberId(14) << data.enum_field() + << eprosima::fastcdr::MemberId(15) << data.enum2_field() + << eprosima::fastcdr::MemberId(16) << data.struct_field() + << eprosima::fastcdr::MemberId(17) << data.array_char_field() + << eprosima::fastcdr::MemberId(18) << data.array_uint8_field() + << eprosima::fastcdr::MemberId(19) << data.array_int16_field() + << eprosima::fastcdr::MemberId(20) << data.array_uint16_field() + << eprosima::fastcdr::MemberId(21) << data.array_int32_field() + << eprosima::fastcdr::MemberId(22) << data.array_uint32_field() + << eprosima::fastcdr::MemberId(23) << data.array_int64_field() + << eprosima::fastcdr::MemberId(24) << data.array_uint64_field() + << eprosima::fastcdr::MemberId(25) << data.array_float_field() + << eprosima::fastcdr::MemberId(26) << data.array_double_field() + << eprosima::fastcdr::MemberId(27) << data.array_long_double_field() + << eprosima::fastcdr::MemberId(28) << data.array_bool_field() + << eprosima::fastcdr::MemberId(29) << data.array_string_field() + << eprosima::fastcdr::MemberId(30) << data.array_alias_string_field() + << eprosima::fastcdr::MemberId(31) << data.array_enum_field() + << eprosima::fastcdr::MemberId(32) << data.array_enum2_field() + << eprosima::fastcdr::MemberId(33) << data.array_struct_field() + << eprosima::fastcdr::MemberId(34) << data.bounded_sequence_char_field() + << eprosima::fastcdr::MemberId(35) << data.bounded_sequence_uint8_field() + << eprosima::fastcdr::MemberId(36) << data.bounded_sequence_int16_field() + << eprosima::fastcdr::MemberId(37) << data.bounded_sequence_uint16_field() + << eprosima::fastcdr::MemberId(38) << data.bounded_sequence_int32_field() + << eprosima::fastcdr::MemberId(39) << data.bounded_sequence_uint32_field() + << eprosima::fastcdr::MemberId(40) << data.bounded_sequence_int64_field() + << eprosima::fastcdr::MemberId(41) << data.bounded_sequence_uint64_field() + << eprosima::fastcdr::MemberId(42) << data.bounded_sequence_float_field() + << eprosima::fastcdr::MemberId(43) << data.bounded_sequence_double_field() + << eprosima::fastcdr::MemberId(44) << data.bounded_sequence_long_double_field() + << eprosima::fastcdr::MemberId(45) << data.bounded_sequence_bool_field() + << eprosima::fastcdr::MemberId(46) << data.bounded_sequence_string_field() + << eprosima::fastcdr::MemberId(47) << data.bounded_sequence_alias_string_field() + << eprosima::fastcdr::MemberId(48) << data.bounded_sequence_enum_field() + << eprosima::fastcdr::MemberId(49) << data.bounded_sequence_enum2_field() + << eprosima::fastcdr::MemberId(50) << data.bounded_sequence_struct_field() + << eprosima::fastcdr::MemberId(51) << data.unbounded_sequence_char_field() + << eprosima::fastcdr::MemberId(52) << data.unbounded_sequence_uint8_field() + << eprosima::fastcdr::MemberId(53) << data.unbounded_sequence_int16_field() + << eprosima::fastcdr::MemberId(54) << data.unbounded_sequence_uint16_field() + << eprosima::fastcdr::MemberId(55) << data.unbounded_sequence_int32_field() + << eprosima::fastcdr::MemberId(56) << data.unbounded_sequence_uint32_field() + << eprosima::fastcdr::MemberId(57) << data.unbounded_sequence_int64_field() + << eprosima::fastcdr::MemberId(58) << data.unbounded_sequence_uint64_field() + << eprosima::fastcdr::MemberId(59) << data.unbounded_sequence_float_field() + << eprosima::fastcdr::MemberId(60) << data.unbounded_sequence_double_field() + << eprosima::fastcdr::MemberId(61) << data.unbounded_sequence_long_double_field() + << eprosima::fastcdr::MemberId(62) << data.unbounded_sequence_bool_field() + << eprosima::fastcdr::MemberId(63) << data.unbounded_sequence_string_field() + << eprosima::fastcdr::MemberId(64) << data.unbounded_sequence_alias_string_field() + << eprosima::fastcdr::MemberId(65) << data.unbounded_sequence_enum_field() + << eprosima::fastcdr::MemberId(66) << data.unbounded_sequence_enum2_field() + << eprosima::fastcdr::MemberId(67) << data.unbounded_sequence_struct_field() ; scdr.end_serialize_type(current_state); } @@ -613,206 +639,222 @@ eProsima_user_DllExport void deserialize( break; case 13: - dcdr >> data.enum_field(); + dcdr >> data.alias_string_field(); break; case 14: - dcdr >> data.enum2_field(); + dcdr >> data.enum_field(); break; case 15: - dcdr >> data.struct_field(); + dcdr >> data.enum2_field(); break; case 16: - dcdr >> data.array_char_field(); + dcdr >> data.struct_field(); break; case 17: - dcdr >> data.array_uint8_field(); + dcdr >> data.array_char_field(); break; case 18: - dcdr >> data.array_int16_field(); + dcdr >> data.array_uint8_field(); break; case 19: - dcdr >> data.array_uint16_field(); + dcdr >> data.array_int16_field(); break; case 20: - dcdr >> data.array_int32_field(); + dcdr >> data.array_uint16_field(); break; case 21: - dcdr >> data.array_uint32_field(); + dcdr >> data.array_int32_field(); break; case 22: - dcdr >> data.array_int64_field(); + dcdr >> data.array_uint32_field(); break; case 23: - dcdr >> data.array_uint64_field(); + dcdr >> data.array_int64_field(); break; case 24: - dcdr >> data.array_float_field(); + dcdr >> data.array_uint64_field(); break; case 25: - dcdr >> data.array_double_field(); + dcdr >> data.array_float_field(); break; case 26: - dcdr >> data.array_long_double_field(); + dcdr >> data.array_double_field(); break; case 27: - dcdr >> data.array_bool_field(); + dcdr >> data.array_long_double_field(); break; case 28: - dcdr >> data.array_string_field(); + dcdr >> data.array_bool_field(); break; case 29: - dcdr >> data.array_enum_field(); + dcdr >> data.array_string_field(); break; case 30: - dcdr >> data.array_enum2_field(); + dcdr >> data.array_alias_string_field(); break; case 31: - dcdr >> data.array_struct_field(); + dcdr >> data.array_enum_field(); break; case 32: - dcdr >> data.bounded_sequence_char_field(); + dcdr >> data.array_enum2_field(); break; case 33: - dcdr >> data.bounded_sequence_uint8_field(); + dcdr >> data.array_struct_field(); break; case 34: - dcdr >> data.bounded_sequence_int16_field(); + dcdr >> data.bounded_sequence_char_field(); break; case 35: - dcdr >> data.bounded_sequence_uint16_field(); + dcdr >> data.bounded_sequence_uint8_field(); break; case 36: - dcdr >> data.bounded_sequence_int32_field(); + dcdr >> data.bounded_sequence_int16_field(); break; case 37: - dcdr >> data.bounded_sequence_uint32_field(); + dcdr >> data.bounded_sequence_uint16_field(); break; case 38: - dcdr >> data.bounded_sequence_int64_field(); + dcdr >> data.bounded_sequence_int32_field(); break; case 39: - dcdr >> data.bounded_sequence_uint64_field(); + dcdr >> data.bounded_sequence_uint32_field(); break; case 40: - dcdr >> data.bounded_sequence_float_field(); + dcdr >> data.bounded_sequence_int64_field(); break; case 41: - dcdr >> data.bounded_sequence_double_field(); + dcdr >> data.bounded_sequence_uint64_field(); break; case 42: - dcdr >> data.bounded_sequence_long_double_field(); + dcdr >> data.bounded_sequence_float_field(); break; case 43: - dcdr >> data.bounded_sequence_bool_field(); + dcdr >> data.bounded_sequence_double_field(); break; case 44: - dcdr >> data.bounded_sequence_string_field(); + dcdr >> data.bounded_sequence_long_double_field(); break; case 45: - dcdr >> data.bounded_sequence_enum_field(); + dcdr >> data.bounded_sequence_bool_field(); break; case 46: - dcdr >> data.bounded_sequence_enum2_field(); + dcdr >> data.bounded_sequence_string_field(); break; case 47: - dcdr >> data.bounded_sequence_struct_field(); + dcdr >> data.bounded_sequence_alias_string_field(); break; case 48: - dcdr >> data.unbounded_sequence_char_field(); + dcdr >> data.bounded_sequence_enum_field(); break; case 49: - dcdr >> data.unbounded_sequence_uint8_field(); + dcdr >> data.bounded_sequence_enum2_field(); break; case 50: - dcdr >> data.unbounded_sequence_int16_field(); + dcdr >> data.bounded_sequence_struct_field(); break; case 51: - dcdr >> data.unbounded_sequence_uint16_field(); + dcdr >> data.unbounded_sequence_char_field(); break; case 52: - dcdr >> data.unbounded_sequence_int32_field(); + dcdr >> data.unbounded_sequence_uint8_field(); break; case 53: - dcdr >> data.unbounded_sequence_uint32_field(); + dcdr >> data.unbounded_sequence_int16_field(); break; case 54: - dcdr >> data.unbounded_sequence_int64_field(); + dcdr >> data.unbounded_sequence_uint16_field(); break; case 55: - dcdr >> data.unbounded_sequence_uint64_field(); + dcdr >> data.unbounded_sequence_int32_field(); break; case 56: - dcdr >> data.unbounded_sequence_float_field(); + dcdr >> data.unbounded_sequence_uint32_field(); break; case 57: - dcdr >> data.unbounded_sequence_double_field(); + dcdr >> data.unbounded_sequence_int64_field(); break; case 58: - dcdr >> data.unbounded_sequence_long_double_field(); + dcdr >> data.unbounded_sequence_uint64_field(); break; case 59: - dcdr >> data.unbounded_sequence_bool_field(); + dcdr >> data.unbounded_sequence_float_field(); break; case 60: - dcdr >> data.unbounded_sequence_string_field(); + dcdr >> data.unbounded_sequence_double_field(); break; case 61: - dcdr >> data.unbounded_sequence_enum_field(); + dcdr >> data.unbounded_sequence_long_double_field(); break; case 62: - dcdr >> data.unbounded_sequence_enum2_field(); + dcdr >> data.unbounded_sequence_bool_field(); break; case 63: + dcdr >> data.unbounded_sequence_string_field(); + break; + + case 64: + dcdr >> data.unbounded_sequence_alias_string_field(); + break; + + case 65: + dcdr >> data.unbounded_sequence_enum_field(); + break; + + case 66: + dcdr >> data.unbounded_sequence_enum2_field(); + break; + + case 67: dcdr >> data.unbounded_sequence_struct_field(); break; @@ -877,6 +919,9 @@ void serialize_key( + + + @@ -909,6 +954,8 @@ void serialize_key( scdr << data.string_field(); + scdr << data.alias_string_field(); + scdr << data.enum_field(); scdr << data.enum2_field(); @@ -941,6 +988,8 @@ void serialize_key( scdr << data.array_string_field(); + scdr << data.array_alias_string_field(); + scdr << data.array_enum_field(); scdr << data.array_enum2_field(); @@ -973,6 +1022,8 @@ void serialize_key( scdr << data.bounded_sequence_string_field(); + scdr << data.bounded_sequence_alias_string_field(); + scdr << data.bounded_sequence_enum_field(); scdr << data.bounded_sequence_enum2_field(); @@ -1005,6 +1056,8 @@ void serialize_key( scdr << data.unbounded_sequence_string_field(); + scdr << data.unbounded_sequence_alias_string_field(); + scdr << data.unbounded_sequence_enum_field(); scdr << data.unbounded_sequence_enum2_field(); diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypePubSubTypes.hpp b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypePubSubTypes.hpp index 457ddf82978..e2ae17e7418 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypePubSubTypes.hpp +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypePubSubTypes.hpp @@ -37,6 +37,8 @@ Generated ContentFilterTestType is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // FASTDDS_GEN_API_VER +typedef eprosima::fastcdr::fixed_string<64> string_64; +typedef string_64 alias_string; /*! * @brief This class represents the TopicDataType of the type ContentFilterTestType defined by the user in the IDL file. diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.cxx b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.cxx index 5f02bb2810c..fc81ba549e6 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.cxx +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.cxx @@ -191,7 +191,113 @@ void register_Color_type_identifier( "Material already registered in TypeObjectRegistry for a different type."); } } -}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +}void register_string_64_type_identifier( + TypeIdentifierPair& type_ids_string_64) +{ + ReturnCode_t return_code_string_64 {eprosima::fastdds::dds::RETCODE_OK}; + return_code_string_64 = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "string_64", type_ids_string_64); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_string_64) + { + AliasTypeFlag alias_flags_string_64 = 0; + QualifiedTypeName type_name_string_64 = "string_64"; + eprosima::fastcdr::optional type_ann_builtin_string_64; + eprosima::fastcdr::optional ann_custom_string_64; + CompleteTypeDetail detail_string_64 = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_string_64, ann_custom_string_64, type_name_string_64.to_string()); + CompleteAliasHeader header_string_64 = TypeObjectUtils::build_complete_alias_header(detail_string_64); + AliasMemberFlag related_flags_string_64 = 0; + return_code_string_64 = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_64", type_ids_string_64); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_string_64) + { + { + SBound bound = static_cast(64); + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_64", type_ids_string_64)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_64 already registered in TypeObjectRegistry for a different type."); + } + } + } + bool common_string_64_ec {false}; + CommonAliasBody common_string_64 {TypeObjectUtils::build_common_alias_body(related_flags_string_64, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_string_64, common_string_64_ec))}; + if (!common_string_64_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "string_64 related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_string_64; + ann_custom_string_64.reset(); + CompleteAliasBody body_string_64 = TypeObjectUtils::build_complete_alias_body(common_string_64, + member_ann_builtin_string_64, ann_custom_string_64); + CompleteAliasType alias_type_string_64 = TypeObjectUtils::build_complete_alias_type(alias_flags_string_64, + header_string_64, body_string_64); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_string_64, + type_name_string_64.to_string(), type_ids_string_64)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "string_64 already registered in TypeObjectRegistry for a different type."); + } + } +} + +void register_alias_string_type_identifier( + TypeIdentifierPair& type_ids_alias_string) +{ + ReturnCode_t return_code_alias_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_alias_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_alias_string); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_string) + { + AliasTypeFlag alias_flags_alias_string = 0; + QualifiedTypeName type_name_alias_string = "alias_string"; + eprosima::fastcdr::optional type_ann_builtin_alias_string; + eprosima::fastcdr::optional ann_custom_alias_string; + CompleteTypeDetail detail_alias_string = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_alias_string, ann_custom_alias_string, type_name_alias_string.to_string()); + CompleteAliasHeader header_alias_string = TypeObjectUtils::build_complete_alias_header(detail_alias_string); + AliasMemberFlag related_flags_alias_string = 0; + return_code_alias_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "string_64", type_ids_alias_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_string) + { + ::register_string_64_type_identifier(type_ids_alias_string); + } + bool common_alias_string_ec {false}; + CommonAliasBody common_alias_string {TypeObjectUtils::build_common_alias_body(related_flags_alias_string, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_alias_string, common_alias_string_ec))}; + if (!common_alias_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "alias_string related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_alias_string; + ann_custom_alias_string.reset(); + CompleteAliasBody body_alias_string = TypeObjectUtils::build_complete_alias_body(common_alias_string, + member_ann_builtin_alias_string, ann_custom_alias_string); + CompleteAliasType alias_type_alias_string = TypeObjectUtils::build_complete_alias_type(alias_flags_alias_string, + header_alias_string, body_alias_string); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_alias_string, + type_name_alias_string.to_string(), type_ids_alias_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "alias_string already registered in TypeObjectRegistry for a different type."); + } + } +} + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method void register_StructType_type_identifier( TypeIdentifierPair& type_ids_StructType) { @@ -616,6 +722,34 @@ void register_StructType_type_identifier( CompleteStructMember member_string_field = TypeObjectUtils::build_complete_struct_member(common_string_field, detail_string_field); TypeObjectUtils::add_complete_struct_member(member_seq_StructType, member_string_field); } + { + TypeIdentifierPair type_ids_alias_string_field; + ReturnCode_t return_code_alias_string_field {eprosima::fastdds::dds::RETCODE_OK}; + return_code_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_string_field) + { + ::register_alias_string_type_identifier(type_ids_alias_string_field); + } + StructMemberFlag member_flags_alias_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_alias_string_field = 0x0000000d; + bool common_alias_string_field_ec {false}; + CommonStructMember common_alias_string_field {TypeObjectUtils::build_common_struct_member(member_id_alias_string_field, member_flags_alias_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_alias_string_field, common_alias_string_field_ec))}; + if (!common_alias_string_field_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure alias_string_field member TypeIdentifier inconsistent."); + return; + } + MemberName name_alias_string_field = "alias_string_field"; + eprosima::fastcdr::optional member_ann_builtin_alias_string_field; + ann_custom_StructType.reset(); + CompleteMemberDetail detail_alias_string_field = TypeObjectUtils::build_complete_member_detail(name_alias_string_field, member_ann_builtin_alias_string_field, ann_custom_StructType); + CompleteStructMember member_alias_string_field = TypeObjectUtils::build_complete_struct_member(common_alias_string_field, detail_alias_string_field); + TypeObjectUtils::add_complete_struct_member(member_seq_StructType, member_alias_string_field); + } { TypeIdentifierPair type_ids_enum_field; ReturnCode_t return_code_enum_field {eprosima::fastdds::dds::RETCODE_OK}; @@ -629,7 +763,7 @@ void register_StructType_type_identifier( } StructMemberFlag member_flags_enum_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_enum_field = 0x0000000d; + MemberId member_id_enum_field = 0x0000000e; bool common_enum_field_ec {false}; CommonStructMember common_enum_field {TypeObjectUtils::build_common_struct_member(member_id_enum_field, member_flags_enum_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum_field, common_enum_field_ec))}; if (!common_enum_field_ec) @@ -657,7 +791,7 @@ void register_StructType_type_identifier( } StructMemberFlag member_flags_enum2_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_enum2_field = 0x0000000e; + MemberId member_id_enum2_field = 0x0000000f; bool common_enum2_field_ec {false}; CommonStructMember common_enum2_field {TypeObjectUtils::build_common_struct_member(member_id_enum2_field, member_flags_enum2_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum2_field, common_enum2_field_ec))}; if (!common_enum2_field_ec) @@ -1098,6 +1232,34 @@ void register_ContentFilterTestType_type_identifier( CompleteStructMember member_string_field = TypeObjectUtils::build_complete_struct_member(common_string_field, detail_string_field); TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_string_field); } + { + TypeIdentifierPair type_ids_alias_string_field; + ReturnCode_t return_code_alias_string_field {eprosima::fastdds::dds::RETCODE_OK}; + return_code_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_string_field) + { + ::register_alias_string_type_identifier(type_ids_alias_string_field); + } + StructMemberFlag member_flags_alias_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_alias_string_field = 0x0000000d; + bool common_alias_string_field_ec {false}; + CommonStructMember common_alias_string_field {TypeObjectUtils::build_common_struct_member(member_id_alias_string_field, member_flags_alias_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_alias_string_field, common_alias_string_field_ec))}; + if (!common_alias_string_field_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure alias_string_field member TypeIdentifier inconsistent."); + return; + } + MemberName name_alias_string_field = "alias_string_field"; + eprosima::fastcdr::optional member_ann_builtin_alias_string_field; + ann_custom_ContentFilterTestType.reset(); + CompleteMemberDetail detail_alias_string_field = TypeObjectUtils::build_complete_member_detail(name_alias_string_field, member_ann_builtin_alias_string_field, ann_custom_ContentFilterTestType); + CompleteStructMember member_alias_string_field = TypeObjectUtils::build_complete_struct_member(common_alias_string_field, detail_alias_string_field); + TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_alias_string_field); + } { TypeIdentifierPair type_ids_enum_field; ReturnCode_t return_code_enum_field {eprosima::fastdds::dds::RETCODE_OK}; @@ -1111,7 +1273,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_enum_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_enum_field = 0x0000000d; + MemberId member_id_enum_field = 0x0000000e; bool common_enum_field_ec {false}; CommonStructMember common_enum_field {TypeObjectUtils::build_common_struct_member(member_id_enum_field, member_flags_enum_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum_field, common_enum_field_ec))}; if (!common_enum_field_ec) @@ -1139,7 +1301,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_enum2_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_enum2_field = 0x0000000e; + MemberId member_id_enum2_field = 0x0000000f; bool common_enum2_field_ec {false}; CommonStructMember common_enum2_field {TypeObjectUtils::build_common_struct_member(member_id_enum2_field, member_flags_enum2_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum2_field, common_enum2_field_ec))}; if (!common_enum2_field_ec) @@ -1167,7 +1329,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_struct_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_struct_field = 0x0000000f; + MemberId member_id_struct_field = 0x00000010; bool common_struct_field_ec {false}; CommonStructMember common_struct_field {TypeObjectUtils::build_common_struct_member(member_id_struct_field, member_flags_struct_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_struct_field, common_struct_field_ec))}; if (!common_struct_field_ec) @@ -1231,7 +1393,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_char_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_char_field = 0x00000010; + MemberId member_id_array_char_field = 0x00000011; bool common_array_char_field_ec {false}; CommonStructMember common_array_char_field {TypeObjectUtils::build_common_struct_member(member_id_array_char_field, member_flags_array_char_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_char_field, common_array_char_field_ec))}; if (!common_array_char_field_ec) @@ -1295,7 +1457,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_uint8_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_uint8_field = 0x00000011; + MemberId member_id_array_uint8_field = 0x00000012; bool common_array_uint8_field_ec {false}; CommonStructMember common_array_uint8_field {TypeObjectUtils::build_common_struct_member(member_id_array_uint8_field, member_flags_array_uint8_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_uint8_field, common_array_uint8_field_ec))}; if (!common_array_uint8_field_ec) @@ -1359,7 +1521,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_int16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_int16_field = 0x00000012; + MemberId member_id_array_int16_field = 0x00000013; bool common_array_int16_field_ec {false}; CommonStructMember common_array_int16_field {TypeObjectUtils::build_common_struct_member(member_id_array_int16_field, member_flags_array_int16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_int16_field, common_array_int16_field_ec))}; if (!common_array_int16_field_ec) @@ -1423,7 +1585,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_uint16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_uint16_field = 0x00000013; + MemberId member_id_array_uint16_field = 0x00000014; bool common_array_uint16_field_ec {false}; CommonStructMember common_array_uint16_field {TypeObjectUtils::build_common_struct_member(member_id_array_uint16_field, member_flags_array_uint16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_uint16_field, common_array_uint16_field_ec))}; if (!common_array_uint16_field_ec) @@ -1487,7 +1649,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_int32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_int32_field = 0x00000014; + MemberId member_id_array_int32_field = 0x00000015; bool common_array_int32_field_ec {false}; CommonStructMember common_array_int32_field {TypeObjectUtils::build_common_struct_member(member_id_array_int32_field, member_flags_array_int32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_int32_field, common_array_int32_field_ec))}; if (!common_array_int32_field_ec) @@ -1551,7 +1713,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_uint32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_uint32_field = 0x00000015; + MemberId member_id_array_uint32_field = 0x00000016; bool common_array_uint32_field_ec {false}; CommonStructMember common_array_uint32_field {TypeObjectUtils::build_common_struct_member(member_id_array_uint32_field, member_flags_array_uint32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_uint32_field, common_array_uint32_field_ec))}; if (!common_array_uint32_field_ec) @@ -1615,7 +1777,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_int64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_int64_field = 0x00000016; + MemberId member_id_array_int64_field = 0x00000017; bool common_array_int64_field_ec {false}; CommonStructMember common_array_int64_field {TypeObjectUtils::build_common_struct_member(member_id_array_int64_field, member_flags_array_int64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_int64_field, common_array_int64_field_ec))}; if (!common_array_int64_field_ec) @@ -1679,7 +1841,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_uint64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_uint64_field = 0x00000017; + MemberId member_id_array_uint64_field = 0x00000018; bool common_array_uint64_field_ec {false}; CommonStructMember common_array_uint64_field {TypeObjectUtils::build_common_struct_member(member_id_array_uint64_field, member_flags_array_uint64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_uint64_field, common_array_uint64_field_ec))}; if (!common_array_uint64_field_ec) @@ -1743,7 +1905,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_float_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_float_field = 0x00000018; + MemberId member_id_array_float_field = 0x00000019; bool common_array_float_field_ec {false}; CommonStructMember common_array_float_field {TypeObjectUtils::build_common_struct_member(member_id_array_float_field, member_flags_array_float_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_float_field, common_array_float_field_ec))}; if (!common_array_float_field_ec) @@ -1807,7 +1969,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_double_field = 0x00000019; + MemberId member_id_array_double_field = 0x0000001a; bool common_array_double_field_ec {false}; CommonStructMember common_array_double_field {TypeObjectUtils::build_common_struct_member(member_id_array_double_field, member_flags_array_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_double_field, common_array_double_field_ec))}; if (!common_array_double_field_ec) @@ -1871,7 +2033,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_long_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_long_double_field = 0x0000001a; + MemberId member_id_array_long_double_field = 0x0000001b; bool common_array_long_double_field_ec {false}; CommonStructMember common_array_long_double_field {TypeObjectUtils::build_common_struct_member(member_id_array_long_double_field, member_flags_array_long_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_long_double_field, common_array_long_double_field_ec))}; if (!common_array_long_double_field_ec) @@ -1935,7 +2097,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_bool_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_bool_field = 0x0000001b; + MemberId member_id_array_bool_field = 0x0000001c; bool common_array_bool_field_ec {false}; CommonStructMember common_array_bool_field {TypeObjectUtils::build_common_struct_member(member_id_array_bool_field, member_flags_array_bool_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_bool_field, common_array_bool_field_ec))}; if (!common_array_bool_field_ec) @@ -2007,7 +2169,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_string_field = 0x0000001c; + MemberId member_id_array_string_field = 0x0000001d; bool common_array_string_field_ec {false}; CommonStructMember common_array_string_field {TypeObjectUtils::build_common_struct_member(member_id_array_string_field, member_flags_array_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_string_field, common_array_string_field_ec))}; if (!common_array_string_field_ec) @@ -2022,6 +2184,68 @@ void register_ContentFilterTestType_type_identifier( CompleteStructMember member_array_string_field = TypeObjectUtils::build_complete_struct_member(common_array_string_field, detail_array_string_field); TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_array_string_field); } + { + TypeIdentifierPair type_ids_array_alias_string_field; + ReturnCode_t return_code_array_alias_string_field {eprosima::fastdds::dds::RETCODE_OK}; + return_code_array_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_anonymous_string_64_3", type_ids_array_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_alias_string_field) + { + return_code_array_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_array_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_alias_string_field) + { + ::register_alias_string_type_identifier(type_ids_array_alias_string_field); + } + bool element_identifier_anonymous_array_anonymous_string_64_3_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_anonymous_string_64_3 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_alias_string_field, element_identifier_anonymous_array_anonymous_string_64_3_ec))}; + if (!element_identifier_anonymous_array_anonymous_string_64_3_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_anonymous_string_64_3 = EK_COMPLETE; + if (TK_NONE == type_ids_array_alias_string_field.type_identifier2()._d()) + { + equiv_kind_anonymous_array_anonymous_string_64_3 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_anonymous_string_64_3 = 0; + PlainCollectionHeader header_anonymous_array_anonymous_string_64_3 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_anonymous_string_64_3, element_flags_anonymous_array_anonymous_string_64_3); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(3)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_anonymous_string_64_3, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_anonymous_string_64_3)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_anonymous_string_64_3", type_ids_array_alias_string_field)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_anonymous_string_64_3 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_array_alias_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_array_alias_string_field = 0x0000001e; + bool common_array_alias_string_field_ec {false}; + CommonStructMember common_array_alias_string_field {TypeObjectUtils::build_common_struct_member(member_id_array_alias_string_field, member_flags_array_alias_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_alias_string_field, common_array_alias_string_field_ec))}; + if (!common_array_alias_string_field_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure array_alias_string_field member TypeIdentifier inconsistent."); + return; + } + MemberName name_array_alias_string_field = "array_alias_string_field"; + eprosima::fastcdr::optional member_ann_builtin_array_alias_string_field; + ann_custom_ContentFilterTestType.reset(); + CompleteMemberDetail detail_array_alias_string_field = TypeObjectUtils::build_complete_member_detail(name_array_alias_string_field, member_ann_builtin_array_alias_string_field, ann_custom_ContentFilterTestType); + CompleteStructMember member_array_alias_string_field = TypeObjectUtils::build_complete_struct_member(common_array_alias_string_field, detail_array_alias_string_field); + TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_array_alias_string_field); + } { TypeIdentifierPair type_ids_array_enum_field; ReturnCode_t return_code_array_enum_field {eprosima::fastdds::dds::RETCODE_OK}; @@ -2069,7 +2293,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_enum_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_enum_field = 0x0000001d; + MemberId member_id_array_enum_field = 0x0000001f; bool common_array_enum_field_ec {false}; CommonStructMember common_array_enum_field {TypeObjectUtils::build_common_struct_member(member_id_array_enum_field, member_flags_array_enum_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_enum_field, common_array_enum_field_ec))}; if (!common_array_enum_field_ec) @@ -2131,7 +2355,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_enum2_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_enum2_field = 0x0000001e; + MemberId member_id_array_enum2_field = 0x00000020; bool common_array_enum2_field_ec {false}; CommonStructMember common_array_enum2_field {TypeObjectUtils::build_common_struct_member(member_id_array_enum2_field, member_flags_array_enum2_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_enum2_field, common_array_enum2_field_ec))}; if (!common_array_enum2_field_ec) @@ -2193,7 +2417,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_array_struct_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_array_struct_field = 0x0000001f; + MemberId member_id_array_struct_field = 0x00000021; bool common_array_struct_field_ec {false}; CommonStructMember common_array_struct_field {TypeObjectUtils::build_common_struct_member(member_id_array_struct_field, member_flags_array_struct_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_struct_field, common_array_struct_field_ec))}; if (!common_array_struct_field_ec) @@ -2255,7 +2479,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_char_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_char_field = 0x00000020; + MemberId member_id_bounded_sequence_char_field = 0x00000022; bool common_bounded_sequence_char_field_ec {false}; CommonStructMember common_bounded_sequence_char_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_char_field, member_flags_bounded_sequence_char_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_char_field, common_bounded_sequence_char_field_ec))}; if (!common_bounded_sequence_char_field_ec) @@ -2317,7 +2541,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_uint8_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_uint8_field = 0x00000021; + MemberId member_id_bounded_sequence_uint8_field = 0x00000023; bool common_bounded_sequence_uint8_field_ec {false}; CommonStructMember common_bounded_sequence_uint8_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_uint8_field, member_flags_bounded_sequence_uint8_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_uint8_field, common_bounded_sequence_uint8_field_ec))}; if (!common_bounded_sequence_uint8_field_ec) @@ -2379,7 +2603,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_int16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_int16_field = 0x00000022; + MemberId member_id_bounded_sequence_int16_field = 0x00000024; bool common_bounded_sequence_int16_field_ec {false}; CommonStructMember common_bounded_sequence_int16_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_int16_field, member_flags_bounded_sequence_int16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_int16_field, common_bounded_sequence_int16_field_ec))}; if (!common_bounded_sequence_int16_field_ec) @@ -2441,7 +2665,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_uint16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_uint16_field = 0x00000023; + MemberId member_id_bounded_sequence_uint16_field = 0x00000025; bool common_bounded_sequence_uint16_field_ec {false}; CommonStructMember common_bounded_sequence_uint16_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_uint16_field, member_flags_bounded_sequence_uint16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_uint16_field, common_bounded_sequence_uint16_field_ec))}; if (!common_bounded_sequence_uint16_field_ec) @@ -2503,7 +2727,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_int32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_int32_field = 0x00000024; + MemberId member_id_bounded_sequence_int32_field = 0x00000026; bool common_bounded_sequence_int32_field_ec {false}; CommonStructMember common_bounded_sequence_int32_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_int32_field, member_flags_bounded_sequence_int32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_int32_field, common_bounded_sequence_int32_field_ec))}; if (!common_bounded_sequence_int32_field_ec) @@ -2565,7 +2789,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_uint32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_uint32_field = 0x00000025; + MemberId member_id_bounded_sequence_uint32_field = 0x00000027; bool common_bounded_sequence_uint32_field_ec {false}; CommonStructMember common_bounded_sequence_uint32_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_uint32_field, member_flags_bounded_sequence_uint32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_uint32_field, common_bounded_sequence_uint32_field_ec))}; if (!common_bounded_sequence_uint32_field_ec) @@ -2627,7 +2851,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_int64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_int64_field = 0x00000026; + MemberId member_id_bounded_sequence_int64_field = 0x00000028; bool common_bounded_sequence_int64_field_ec {false}; CommonStructMember common_bounded_sequence_int64_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_int64_field, member_flags_bounded_sequence_int64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_int64_field, common_bounded_sequence_int64_field_ec))}; if (!common_bounded_sequence_int64_field_ec) @@ -2689,7 +2913,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_uint64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_uint64_field = 0x00000027; + MemberId member_id_bounded_sequence_uint64_field = 0x00000029; bool common_bounded_sequence_uint64_field_ec {false}; CommonStructMember common_bounded_sequence_uint64_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_uint64_field, member_flags_bounded_sequence_uint64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_uint64_field, common_bounded_sequence_uint64_field_ec))}; if (!common_bounded_sequence_uint64_field_ec) @@ -2751,7 +2975,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_float_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_float_field = 0x00000028; + MemberId member_id_bounded_sequence_float_field = 0x0000002a; bool common_bounded_sequence_float_field_ec {false}; CommonStructMember common_bounded_sequence_float_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_float_field, member_flags_bounded_sequence_float_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_float_field, common_bounded_sequence_float_field_ec))}; if (!common_bounded_sequence_float_field_ec) @@ -2813,7 +3037,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_double_field = 0x00000029; + MemberId member_id_bounded_sequence_double_field = 0x0000002b; bool common_bounded_sequence_double_field_ec {false}; CommonStructMember common_bounded_sequence_double_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_double_field, member_flags_bounded_sequence_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_double_field, common_bounded_sequence_double_field_ec))}; if (!common_bounded_sequence_double_field_ec) @@ -2875,7 +3099,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_long_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_long_double_field = 0x0000002a; + MemberId member_id_bounded_sequence_long_double_field = 0x0000002c; bool common_bounded_sequence_long_double_field_ec {false}; CommonStructMember common_bounded_sequence_long_double_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_long_double_field, member_flags_bounded_sequence_long_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_long_double_field, common_bounded_sequence_long_double_field_ec))}; if (!common_bounded_sequence_long_double_field_ec) @@ -2937,7 +3161,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_bool_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_bool_field = 0x0000002b; + MemberId member_id_bounded_sequence_bool_field = 0x0000002d; bool common_bounded_sequence_bool_field_ec {false}; CommonStructMember common_bounded_sequence_bool_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_bool_field, member_flags_bounded_sequence_bool_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_bool_field, common_bounded_sequence_bool_field_ec))}; if (!common_bounded_sequence_bool_field_ec) @@ -3007,7 +3231,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_string_field = 0x0000002c; + MemberId member_id_bounded_sequence_string_field = 0x0000002e; bool common_bounded_sequence_string_field_ec {false}; CommonStructMember common_bounded_sequence_string_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_string_field, member_flags_bounded_sequence_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_string_field, common_bounded_sequence_string_field_ec))}; if (!common_bounded_sequence_string_field_ec) @@ -3022,6 +3246,66 @@ void register_ContentFilterTestType_type_identifier( CompleteStructMember member_bounded_sequence_string_field = TypeObjectUtils::build_complete_struct_member(common_bounded_sequence_string_field, detail_bounded_sequence_string_field); TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_bounded_sequence_string_field); } + { + TypeIdentifierPair type_ids_bounded_sequence_alias_string_field; + ReturnCode_t return_code_bounded_sequence_alias_string_field {eprosima::fastdds::dds::RETCODE_OK}; + return_code_bounded_sequence_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_anonymous_string_64_5", type_ids_bounded_sequence_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_bounded_sequence_alias_string_field) + { + return_code_bounded_sequence_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_bounded_sequence_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_bounded_sequence_alias_string_field) + { + ::register_alias_string_type_identifier(type_ids_bounded_sequence_alias_string_field); + } + bool element_identifier_anonymous_sequence_anonymous_string_64_5_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_anonymous_string_64_5 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_alias_string_field, element_identifier_anonymous_sequence_anonymous_string_64_5_ec))}; + if (!element_identifier_anonymous_sequence_anonymous_string_64_5_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_anonymous_string_64_5 = EK_COMPLETE; + if (TK_NONE == type_ids_bounded_sequence_alias_string_field.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_anonymous_string_64_5 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_anonymous_string_64_5 = 0; + PlainCollectionHeader header_anonymous_sequence_anonymous_string_64_5 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_anonymous_string_64_5, element_flags_anonymous_sequence_anonymous_string_64_5); + { + SBound bound = static_cast(5); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_anonymous_string_64_5, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_anonymous_string_64_5)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_anonymous_string_64_5", type_ids_bounded_sequence_alias_string_field)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_anonymous_string_64_5 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_bounded_sequence_alias_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_bounded_sequence_alias_string_field = 0x0000002f; + bool common_bounded_sequence_alias_string_field_ec {false}; + CommonStructMember common_bounded_sequence_alias_string_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_alias_string_field, member_flags_bounded_sequence_alias_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_alias_string_field, common_bounded_sequence_alias_string_field_ec))}; + if (!common_bounded_sequence_alias_string_field_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure bounded_sequence_alias_string_field member TypeIdentifier inconsistent."); + return; + } + MemberName name_bounded_sequence_alias_string_field = "bounded_sequence_alias_string_field"; + eprosima::fastcdr::optional member_ann_builtin_bounded_sequence_alias_string_field; + ann_custom_ContentFilterTestType.reset(); + CompleteMemberDetail detail_bounded_sequence_alias_string_field = TypeObjectUtils::build_complete_member_detail(name_bounded_sequence_alias_string_field, member_ann_builtin_bounded_sequence_alias_string_field, ann_custom_ContentFilterTestType); + CompleteStructMember member_bounded_sequence_alias_string_field = TypeObjectUtils::build_complete_struct_member(common_bounded_sequence_alias_string_field, detail_bounded_sequence_alias_string_field); + TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_bounded_sequence_alias_string_field); + } { TypeIdentifierPair type_ids_bounded_sequence_enum_field; ReturnCode_t return_code_bounded_sequence_enum_field {eprosima::fastdds::dds::RETCODE_OK}; @@ -3067,7 +3351,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_enum_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_enum_field = 0x0000002d; + MemberId member_id_bounded_sequence_enum_field = 0x00000030; bool common_bounded_sequence_enum_field_ec {false}; CommonStructMember common_bounded_sequence_enum_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_enum_field, member_flags_bounded_sequence_enum_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_enum_field, common_bounded_sequence_enum_field_ec))}; if (!common_bounded_sequence_enum_field_ec) @@ -3127,7 +3411,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_enum2_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_enum2_field = 0x0000002e; + MemberId member_id_bounded_sequence_enum2_field = 0x00000031; bool common_bounded_sequence_enum2_field_ec {false}; CommonStructMember common_bounded_sequence_enum2_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_enum2_field, member_flags_bounded_sequence_enum2_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_enum2_field, common_bounded_sequence_enum2_field_ec))}; if (!common_bounded_sequence_enum2_field_ec) @@ -3187,7 +3471,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_bounded_sequence_struct_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_bounded_sequence_struct_field = 0x0000002f; + MemberId member_id_bounded_sequence_struct_field = 0x00000032; bool common_bounded_sequence_struct_field_ec {false}; CommonStructMember common_bounded_sequence_struct_field {TypeObjectUtils::build_common_struct_member(member_id_bounded_sequence_struct_field, member_flags_bounded_sequence_struct_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bounded_sequence_struct_field, common_bounded_sequence_struct_field_ec))}; if (!common_bounded_sequence_struct_field_ec) @@ -3249,7 +3533,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_char_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_char_field = 0x00000030; + MemberId member_id_unbounded_sequence_char_field = 0x00000033; bool common_unbounded_sequence_char_field_ec {false}; CommonStructMember common_unbounded_sequence_char_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_char_field, member_flags_unbounded_sequence_char_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_char_field, common_unbounded_sequence_char_field_ec))}; if (!common_unbounded_sequence_char_field_ec) @@ -3311,7 +3595,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_uint8_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_uint8_field = 0x00000031; + MemberId member_id_unbounded_sequence_uint8_field = 0x00000034; bool common_unbounded_sequence_uint8_field_ec {false}; CommonStructMember common_unbounded_sequence_uint8_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_uint8_field, member_flags_unbounded_sequence_uint8_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_uint8_field, common_unbounded_sequence_uint8_field_ec))}; if (!common_unbounded_sequence_uint8_field_ec) @@ -3373,7 +3657,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_int16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_int16_field = 0x00000032; + MemberId member_id_unbounded_sequence_int16_field = 0x00000035; bool common_unbounded_sequence_int16_field_ec {false}; CommonStructMember common_unbounded_sequence_int16_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_int16_field, member_flags_unbounded_sequence_int16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_int16_field, common_unbounded_sequence_int16_field_ec))}; if (!common_unbounded_sequence_int16_field_ec) @@ -3435,7 +3719,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_uint16_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_uint16_field = 0x00000033; + MemberId member_id_unbounded_sequence_uint16_field = 0x00000036; bool common_unbounded_sequence_uint16_field_ec {false}; CommonStructMember common_unbounded_sequence_uint16_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_uint16_field, member_flags_unbounded_sequence_uint16_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_uint16_field, common_unbounded_sequence_uint16_field_ec))}; if (!common_unbounded_sequence_uint16_field_ec) @@ -3497,7 +3781,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_int32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_int32_field = 0x00000034; + MemberId member_id_unbounded_sequence_int32_field = 0x00000037; bool common_unbounded_sequence_int32_field_ec {false}; CommonStructMember common_unbounded_sequence_int32_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_int32_field, member_flags_unbounded_sequence_int32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_int32_field, common_unbounded_sequence_int32_field_ec))}; if (!common_unbounded_sequence_int32_field_ec) @@ -3559,7 +3843,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_uint32_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_uint32_field = 0x00000035; + MemberId member_id_unbounded_sequence_uint32_field = 0x00000038; bool common_unbounded_sequence_uint32_field_ec {false}; CommonStructMember common_unbounded_sequence_uint32_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_uint32_field, member_flags_unbounded_sequence_uint32_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_uint32_field, common_unbounded_sequence_uint32_field_ec))}; if (!common_unbounded_sequence_uint32_field_ec) @@ -3621,7 +3905,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_int64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_int64_field = 0x00000036; + MemberId member_id_unbounded_sequence_int64_field = 0x00000039; bool common_unbounded_sequence_int64_field_ec {false}; CommonStructMember common_unbounded_sequence_int64_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_int64_field, member_flags_unbounded_sequence_int64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_int64_field, common_unbounded_sequence_int64_field_ec))}; if (!common_unbounded_sequence_int64_field_ec) @@ -3683,7 +3967,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_uint64_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_uint64_field = 0x00000037; + MemberId member_id_unbounded_sequence_uint64_field = 0x0000003a; bool common_unbounded_sequence_uint64_field_ec {false}; CommonStructMember common_unbounded_sequence_uint64_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_uint64_field, member_flags_unbounded_sequence_uint64_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_uint64_field, common_unbounded_sequence_uint64_field_ec))}; if (!common_unbounded_sequence_uint64_field_ec) @@ -3745,7 +4029,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_float_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_float_field = 0x00000038; + MemberId member_id_unbounded_sequence_float_field = 0x0000003b; bool common_unbounded_sequence_float_field_ec {false}; CommonStructMember common_unbounded_sequence_float_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_float_field, member_flags_unbounded_sequence_float_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_float_field, common_unbounded_sequence_float_field_ec))}; if (!common_unbounded_sequence_float_field_ec) @@ -3807,7 +4091,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_double_field = 0x00000039; + MemberId member_id_unbounded_sequence_double_field = 0x0000003c; bool common_unbounded_sequence_double_field_ec {false}; CommonStructMember common_unbounded_sequence_double_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_double_field, member_flags_unbounded_sequence_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_double_field, common_unbounded_sequence_double_field_ec))}; if (!common_unbounded_sequence_double_field_ec) @@ -3869,7 +4153,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_long_double_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_long_double_field = 0x0000003a; + MemberId member_id_unbounded_sequence_long_double_field = 0x0000003d; bool common_unbounded_sequence_long_double_field_ec {false}; CommonStructMember common_unbounded_sequence_long_double_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_long_double_field, member_flags_unbounded_sequence_long_double_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_long_double_field, common_unbounded_sequence_long_double_field_ec))}; if (!common_unbounded_sequence_long_double_field_ec) @@ -3931,7 +4215,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_bool_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_bool_field = 0x0000003b; + MemberId member_id_unbounded_sequence_bool_field = 0x0000003e; bool common_unbounded_sequence_bool_field_ec {false}; CommonStructMember common_unbounded_sequence_bool_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_bool_field, member_flags_unbounded_sequence_bool_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_bool_field, common_unbounded_sequence_bool_field_ec))}; if (!common_unbounded_sequence_bool_field_ec) @@ -4001,7 +4285,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_string_field = 0x0000003c; + MemberId member_id_unbounded_sequence_string_field = 0x0000003f; bool common_unbounded_sequence_string_field_ec {false}; CommonStructMember common_unbounded_sequence_string_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_string_field, member_flags_unbounded_sequence_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_string_field, common_unbounded_sequence_string_field_ec))}; if (!common_unbounded_sequence_string_field_ec) @@ -4016,6 +4300,66 @@ void register_ContentFilterTestType_type_identifier( CompleteStructMember member_unbounded_sequence_string_field = TypeObjectUtils::build_complete_struct_member(common_unbounded_sequence_string_field, detail_unbounded_sequence_string_field); TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_unbounded_sequence_string_field); } + { + TypeIdentifierPair type_ids_unbounded_sequence_alias_string_field; + ReturnCode_t return_code_unbounded_sequence_alias_string_field {eprosima::fastdds::dds::RETCODE_OK}; + return_code_unbounded_sequence_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_anonymous_string_64_unbounded", type_ids_unbounded_sequence_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_unbounded_sequence_alias_string_field) + { + return_code_unbounded_sequence_alias_string_field = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_string", type_ids_unbounded_sequence_alias_string_field); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_unbounded_sequence_alias_string_field) + { + ::register_alias_string_type_identifier(type_ids_unbounded_sequence_alias_string_field); + } + bool element_identifier_anonymous_sequence_anonymous_string_64_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_anonymous_string_64_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_alias_string_field, element_identifier_anonymous_sequence_anonymous_string_64_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_anonymous_string_64_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_anonymous_string_64_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_unbounded_sequence_alias_string_field.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_anonymous_string_64_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_anonymous_string_64_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_anonymous_string_64_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_anonymous_string_64_unbounded, element_flags_anonymous_sequence_anonymous_string_64_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_anonymous_string_64_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_anonymous_string_64_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_anonymous_string_64_unbounded", type_ids_unbounded_sequence_alias_string_field)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_anonymous_string_64_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_unbounded_sequence_alias_string_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_unbounded_sequence_alias_string_field = 0x00000040; + bool common_unbounded_sequence_alias_string_field_ec {false}; + CommonStructMember common_unbounded_sequence_alias_string_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_alias_string_field, member_flags_unbounded_sequence_alias_string_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_alias_string_field, common_unbounded_sequence_alias_string_field_ec))}; + if (!common_unbounded_sequence_alias_string_field_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unbounded_sequence_alias_string_field member TypeIdentifier inconsistent."); + return; + } + MemberName name_unbounded_sequence_alias_string_field = "unbounded_sequence_alias_string_field"; + eprosima::fastcdr::optional member_ann_builtin_unbounded_sequence_alias_string_field; + ann_custom_ContentFilterTestType.reset(); + CompleteMemberDetail detail_unbounded_sequence_alias_string_field = TypeObjectUtils::build_complete_member_detail(name_unbounded_sequence_alias_string_field, member_ann_builtin_unbounded_sequence_alias_string_field, ann_custom_ContentFilterTestType); + CompleteStructMember member_unbounded_sequence_alias_string_field = TypeObjectUtils::build_complete_struct_member(common_unbounded_sequence_alias_string_field, detail_unbounded_sequence_alias_string_field); + TypeObjectUtils::add_complete_struct_member(member_seq_ContentFilterTestType, member_unbounded_sequence_alias_string_field); + } { TypeIdentifierPair type_ids_unbounded_sequence_enum_field; ReturnCode_t return_code_unbounded_sequence_enum_field {eprosima::fastdds::dds::RETCODE_OK}; @@ -4061,7 +4405,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_enum_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_enum_field = 0x0000003d; + MemberId member_id_unbounded_sequence_enum_field = 0x00000041; bool common_unbounded_sequence_enum_field_ec {false}; CommonStructMember common_unbounded_sequence_enum_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_enum_field, member_flags_unbounded_sequence_enum_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_enum_field, common_unbounded_sequence_enum_field_ec))}; if (!common_unbounded_sequence_enum_field_ec) @@ -4121,7 +4465,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_enum2_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_enum2_field = 0x0000003e; + MemberId member_id_unbounded_sequence_enum2_field = 0x00000042; bool common_unbounded_sequence_enum2_field_ec {false}; CommonStructMember common_unbounded_sequence_enum2_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_enum2_field, member_flags_unbounded_sequence_enum2_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_enum2_field, common_unbounded_sequence_enum2_field_ec))}; if (!common_unbounded_sequence_enum2_field_ec) @@ -4181,7 +4525,7 @@ void register_ContentFilterTestType_type_identifier( } StructMemberFlag member_flags_unbounded_sequence_struct_field = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_unbounded_sequence_struct_field = 0x0000003f; + MemberId member_id_unbounded_sequence_struct_field = 0x00000043; bool common_unbounded_sequence_struct_field_ec {false}; CommonStructMember common_unbounded_sequence_struct_field {TypeObjectUtils::build_common_struct_member(member_id_unbounded_sequence_struct_field, member_flags_unbounded_sequence_struct_field, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unbounded_sequence_struct_field, common_unbounded_sequence_struct_field_ec))}; if (!common_unbounded_sequence_struct_field_ec) diff --git a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.hpp b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.hpp index 0afd2e3bcff..f9fc3ea5b38 100644 --- a/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.hpp +++ b/test/unittest/dds/topic/DDSSQLFilter/data_types/ContentFilterTestTypeTypeObjectSupport.hpp @@ -61,6 +61,34 @@ eProsima_user_DllExport void register_Color_type_identifier( */ eProsima_user_DllExport void register_Material_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register string_64 related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] type_ids TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_string_64_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +/** + * @brief Register alias_string related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] type_ids TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_alias_string_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + /** * @brief Register StructType related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. diff --git a/versions.md b/versions.md index 97362ac511d..441c8fca45c 100644 --- a/versions.md +++ b/versions.md @@ -12,6 +12,7 @@ Forthcoming * __Fast DDS Pro__ features: * Added Ethernet transport (Linux only). * Mapping transport priority to DSCP, interface and source port in UDP transport. +* Support aliases in Content Filtered Topic. Version v3.3.0 --------------