Allow creation of built-in content filters with different type name (#5867) (#5874)

* Allow creation of built-in content filters with different type name (#5867)

* Refs #23265. Add unit test.

Signed-off-by: Miguel Company <[email protected]>

* Refs #23265. Add blackbox test.

Signed-off-by: Miguel Company <[email protected]>

* Refs #23265. Use type identifiers when creating DDS filter object.

Signed-off-by: Miguel Company <[email protected]>

* Refs #23265. Refactor for readability.

Signed-off-by: Miguel Company <[email protected]>

* Refs #23265. Apply review suggestion.

Signed-off-by: Miguel Company <[email protected]>

---------

Signed-off-by: Miguel Company <[email protected]>
(cherry picked from commit 92260c2)

# Conflicts:
#	test/blackbox/common/DDSBlackboxTestsContentFilter.cpp

* Fix conflicts

Signed-off-by: Miguel Company <[email protected]>

* Fix linters

Signed-off-by: Miguel Company <[email protected]>

---------

Signed-off-by: Miguel Company <[email protected]>
Co-authored-by: Miguel Company <[email protected]>

Author: mergify[bot]

src/cpp/fastdds/topic/DDSSQLFilter/DDSFilterFactory.cpp

@@ -456,6 +456,42 @@ DDSFilterFactory::~DDSFilterFactory()
     pool.clear();
 }
 
+static std::shared_ptr<xtypes::TypeObject> get_complete_type_object(
+        const char* type_name,
+        const TopicDataType* data_type)
+{
+    ReturnCode_t ret;
+
+    // Try to get the complete TypeObject from the type name
+    std::shared_ptr<xtypes::TypeObjectPair> type_objects = std::make_shared<xtypes::TypeObjectPair>();
+    ret = DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects(
+        type_name, *type_objects);
+    if (RETCODE_OK == ret)
+    {
+        return std::make_shared<xtypes::TypeObject>(type_objects->complete_type_object);
+    }
+
+    // If not found, try to get the complete TypeObject from the type identifier
+    xtypes::TypeObject complete_type_object;
+    if (xtypes::EK_COMPLETE == data_type->type_identifiers().type_identifier1()._d())
+    {
+        ret = DomainParticipantFactory::get_instance()->type_object_registry().get_type_object(
+            data_type->type_identifiers().type_identifier1(), complete_type_object);
+    }
+    else if (xtypes::EK_COMPLETE == data_type->type_identifiers().type_identifier2()._d())
+    {
+        ret = DomainParticipantFactory::get_instance()->type_object_registry().get_type_object(
+            data_type->type_identifiers().type_identifier2(), complete_type_object);
+    }
+
+    if (RETCODE_OK == ret)
+    {
+        return std::make_shared<xtypes::TypeObject>(complete_type_object);
+    }
+
+    return nullptr;
+}
+
 ReturnCode_t DDSFilterFactory::create_content_filter(
         const char* filter_class_name,
         const char* type_name,
@@ -464,8 +500,6 @@ ReturnCode_t DDSFilterFactory::create_content_filter(
         const IContentFilterFactory::ParameterSeq& filter_parameters,
         IContentFilter*& filter_instance)
 {
-    static_cast<void>(data_type);
-
     ReturnCode_t ret = RETCODE_UNSUPPORTED;
 
     if (nullptr == filter_expression)
@@ -522,22 +556,19 @@ ReturnCode_t DDSFilterFactory::create_content_filter(
     }
     else
     {
-        std::shared_ptr<xtypes::TypeObjectPair> type_objects = std::make_shared<xtypes::TypeObjectPair>();
-        ret = DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects(
-            type_name, *type_objects);
-        if (RETCODE_OK != ret)
+        std::shared_ptr<xtypes::TypeObject> type_object = get_complete_type_object(type_name, data_type);
+
+        if (!type_object)
         {
             EPROSIMA_LOG_ERROR(DDSSQLFILTER, "No TypeObject found for type " << type_name);
         }
         else
         {
-            auto node =
-                    parser::parse_filter_expression(filter_expression,
-                            std::make_shared<xtypes::TypeObject>(type_objects->complete_type_object));
+            auto node = parser::parse_filter_expression(filter_expression, type_object);
             if (node)
             {
                 DynamicType::_ref_type dyn_type = DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object(
-                    type_objects->complete_type_object)->build();
+                    *type_object)->build();
                 if (dyn_type)
                 {
                     DDSFilterExpression* expr = get_expression();
@@ -548,8 +579,7 @@ ReturnCode_t DDSFilterFactory::create_content_filter(
                     {
                         expr->parameters.emplace_back();
                     }
-                    ExpressionParsingState state{ std::make_shared<xtypes::TypeObject>(
-                                                      type_objects->complete_type_object),
+                    ExpressionParsingState state{ std::make_shared<xtypes::TypeObject>(*type_object),
                                                   filter_parameters, expr };
                     ret = convert_tree<DDSFilterCondition>(state, expr->root, *(node->children[0]));
                     if (RETCODE_OK == ret)

test/blackbox/common/DDSBlackboxTestsContentFilter.cpp

@@ -282,7 +282,8 @@ class DDSContentFilter : public testing::TestWithParam<communication_type>
                 {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                     reader->get_subscription_matched_status(status);
-                } while (status.current_count < 1);
+                }
+                while (status.current_count < 1);
             }
 
             return reader;
@@ -708,6 +709,36 @@ TEST(DDSContentFilter, OnlyFilterAliveChanges)
     ASSERT_EQ(reader.get_sample_lost_status().total_count, 0);
 }
 
+/*
+ * Regression test for https://eprosima.easyredmine.com/issues/23265
+ *
+ * This test checks that a DDSSQL content filter can be created with a type name that is different from the one
+ * in the generated type support.
+ */
+TEST(DDSContentFilter, filter_other_type_name)
+{
+    using namespace eprosima::fastdds;
+
+    // Create a DomainParticipant
+    DomainParticipant* participant =
+            dds::DomainParticipantFactory::get_instance()->create_participant(0, PARTICIPANT_QOS_DEFAULT);
+    ASSERT_NE(participant, nullptr);
+
+    // Create a ContentFilteredTopic with a different type name
+    dds::TypeSupport type_support(new HelloWorldPubSubType());
+    ASSERT_EQ(type_support.register_type(participant, "CustomType"), RETCODE_OK);
+    dds::Topic* topic = participant->create_topic(
+        "TestTopic", "CustomType", TOPIC_QOS_DEFAULT);
+    ASSERT_NE(topic, nullptr);
+    dds::ContentFilteredTopic* filtered_topic = participant->create_contentfilteredtopic(
+        "FilteredTopic", topic, "index <= %0", { "6" });
+    ASSERT_NE(filtered_topic, nullptr);
+
+    // Delete all entities
+    ASSERT_EQ(participant->delete_contained_entities(), RETCODE_OK);
+    ASSERT_EQ(dds::DomainParticipantFactory::get_instance()->delete_participant(participant), RETCODE_OK);
+}
+
 #ifdef INSTANTIATE_TEST_SUITE_P
 #define GTEST_INSTANTIATE_TEST_MACRO(x, y, z, w) INSTANTIATE_TEST_SUITE_P(x, y, z, w)
 #else

test/unittest/dds/topic/DDSSQLFilter/DDSSQLFilterTests.cpp

@@ -559,6 +559,28 @@ TEST_F(DDSSQLFilterTests, type_compatibility_compare_operand_op_operand)
     }
 }
 
+/*
+ * Regression test for https://eprosima.easyredmine.com/issues/23265
+ *
+ * This test checks that a DDSSQL content filter can be created with a type name that is different from the one
+ * used to register the type object representation.
+ */
+TEST_F(DDSSQLFilterTests, different_type_name)
+{
+    ContentFilterTestTypePubSubType type;
+    type.register_type_object_representation();
+
+    IContentFilter* filter_instance = nullptr;
+    DDSFilterFactory factory;
+    StackAllocatedSequence<const char*, 10> params;
+
+    EXPECT_EQ(factory.create_content_filter("DDSSQL", "MyCustomType", &type,
+            "uint16_field = 3", params, filter_instance), RETCODE_OK);
+
+    EXPECT_EQ(RETCODE_OK,
+            factory.delete_content_filter("DDSSQL", filter_instance));
+}
+
 /**
  * Singleton that holds the serialized payloads to be evaluated
  */