Add conversion provider delegation for container element types

This change allows conversion providers (like StdStringUnicodeConverter)
to work inside containers (like std::vector) by adding a delegation
mechanism.

Changes:
- Add supports_delegation() method to TypeConverterBase (default: False)
- Enable delegation for StdStringUnicodeConverter and
  StdStringUnicodeOutputConverter
- Modify StdVectorConverter to delegate to element converters when
  supports_delegation() returns True
- Add test for UTF-8 string vectors

This fixes the limitation where UTF-8 string converters would not be
picked up when used inside containers. Now, vectors of libcpp_utf8_string
or libcpp_utf8_output_string properly encode/decode UTF-8 strings.

Author: claude

autowrap/ConversionProvider.py

@@ -134,6 +134,17 @@ def output_conversion(
     ) -> Optional[Union[Code, str]]:
         raise NotImplementedError()
 
+    def supports_delegation(self) -> bool:
+        """
+        Return True if this converter should be invoked when the type
+        is an element inside a container (e.g., std::vector).
+
+        By default, Cython handles conversion of standard types inside
+        containers automatically. When this returns True, container
+        converters will delegate to this converter instead.
+        """
+        return False
+
     @staticmethod
     def _code_for_instantiate_object_from_iter(cpp_type: CppType, it: str) -> str:
         """
@@ -1668,6 +1679,16 @@ def _perform_recursion(
         else:
             bottommost_code.content.extend(bottommost_code_callback.content)
 
+    def _has_delegating_converter(self, element_type: CppType) -> bool:
+        """Check if element type has a converter that supports delegation."""
+        if not hasattr(self, "cr"):
+            return False
+        try:
+            converter = self.cr.get(element_type)
+            return converter.supports_delegation()
+        except (NameError, KeyError):
+            return False
+
     def input_conversion(
         self,
         cpp_type: CppType,
@@ -1886,8 +1907,81 @@ def input_conversion(
 
             return code, "deref(%s)" % temp_var, cleanup_code
 
+        elif self._has_delegating_converter(tt):
+            # Case 5: Element type has a converter that supports delegation
+            # Use explicit loop with element converter instead of letting Cython handle it
+            item = "item%s" % arg_num
+            conv_item = "conv_item%s" % arg_num
+            element_converter = self.cr.get(tt)
+
+            # Get element input conversion
+            elem_code, elem_call_as, elem_cleanup = element_converter.input_conversion(
+                tt, item, arg_num
+            )
+
+            code = Code().add(
+                """
+                |cdef libcpp_vector[$inner] * $temp_var = new libcpp_vector[$inner]()
+                """,
+                locals(),
+            )
+
+            # Add element conversion code (may include variable declarations)
+            if hasattr(elem_code, "content") and elem_code.content:
+                # Extract any if-block from elem_code and wrap in loop
+                code.add(
+                    """
+                |for $item in $argument_var:
+                """,
+                    locals(),
+                )
+                code.add(elem_code)
+                code.add(
+                    """
+                |    $temp_var.push_back(<$inner>$item)
+                """,
+                    locals(),
+                )
+            else:
+                code.add(
+                    """
+                |for $item in $argument_var:
+                |    $temp_var.push_back($elem_call_as)
+                """,
+                    locals(),
+                )
+
+            cleanup_code = Code().add("")
+            if cpp_type.topmost_is_ref and not cpp_type.topmost_is_const:
+                it = mangle("it_" + argument_var)
+                out_converter = self.cr.get(tt)
+                elem_out = out_converter.output_conversion(tt, "deref(%s)" % it, conv_item)
+                if elem_out is None:
+                    elem_out_code = "%s = deref(%s)" % (conv_item, it)
+                elif hasattr(elem_out, "render"):
+                    elem_out_code = elem_out.render()
+                else:
+                    elem_out_code = str(elem_out)
+                cleanup_code = Code().add(
+                    """
+                    |replace = []
+                    |cdef libcpp_vector[$inner].iterator $it = $temp_var.begin()
+                    |while $it != $temp_var.end():
+                    |    $elem_out_code
+                    |    replace.append($conv_item)
+                    |    inc($it)
+                    |$argument_var[:] = replace
+                    |del $temp_var
+                    """,
+                    locals(),
+                )
+            else:
+                cleanup_code = Code().add("del %s" % temp_var)
+
+            return code, "deref(%s)" % temp_var, cleanup_code
+
         else:
-            # Case 5: We wrap a regular type
+            # Case 6: We wrap a regular type
             inner = self.converters.cython_type(tt)
             # cython cares for conversion of stl containers with std types:
             code = Code().add(
@@ -1982,6 +2076,35 @@ def output_conversion(self, cpp_type: CppType, input_cpp_var: str, output_py_var
             )
             return code
 
+        elif self._has_delegating_converter(tt):
+            # Element type has a converter that supports delegation
+            # Use explicit loop with element converter
+            it = mangle("it_" + input_cpp_var)
+            item = mangle("item_" + output_py_var)
+            element_converter = self.cr.get(tt)
+
+            # Get element output conversion
+            elem_out = element_converter.output_conversion(tt, "deref(%s)" % it, item)
+            if elem_out is None:
+                elem_out_code = "%s = deref(%s)" % (item, it)
+            elif hasattr(elem_out, "render"):
+                elem_out_code = elem_out.render()
+            else:
+                elem_out_code = str(elem_out)
+
+            code = Code().add(
+                """
+                |$output_py_var = []
+                |cdef libcpp_vector[$inner].iterator $it = $input_cpp_var.begin()
+                |while $it != $input_cpp_var.end():
+                |    $elem_out_code
+                |    $output_py_var.append($item)
+                |    inc($it)
+                """,
+                locals(),
+            )
+            return code
+
         else:
             # cython cares for conversion of stl containers with std types:
             code = Code().add(
@@ -2406,16 +2529,17 @@ def output_conversion(
 class StdStringUnicodeConverter(StdStringConverter):
     """
     This converter deals with functions that expect a C++ std::string.
-    Note that this provider will NOT be picked up if it is located inside
-    a container (e.g. std::vector aka libcpp_vector). Please use the usual
-    StdStringConverter to at least get the typing right.
+    It can be used inside containers when delegation is enabled.
     It can only be used in function parameters (i.e. input).
     It can handle both bytes and unicode strings and converts to bytes internally.
     """
 
     def get_base_types(self) -> List[str]:
         return ["libcpp_utf8_string"]
 
+    def supports_delegation(self) -> bool:
+        return True
+
     def matching_python_type(self, cpp_type: CppType) -> str:
         return ""  # TODO can we use "basestring"?
 
@@ -2446,9 +2570,7 @@ def type_check_expression(self, cpp_type: CppType, argument_var: str) -> str:
 class StdStringUnicodeOutputConverter(StdStringUnicodeConverter):
     """
     This converter deals with functions that return a C++ std::string.
-    Note that this provider will NOT be picked up if it is located inside
-    a container (e.g. std::vector aka libcpp_vector). Please use the usual
-    StdStringConverter to at least get the typing right.
+    It can be used inside containers when delegation is enabled.
     It should only be used in function returns (i.e. output).
     It returns unicode strings to python and therefore expects the C++
     function to return something that is decodable from utf8 (including ascii)
@@ -2457,6 +2579,9 @@ class StdStringUnicodeOutputConverter(StdStringUnicodeConverter):
     def get_base_types(self) -> List[str]:
         return ["libcpp_utf8_output_string"]
 
+    def supports_delegation(self) -> bool:
+        return True
+
     def matching_python_type_full(self, cpp_type: CppType) -> str:
         return "str"  # python3
 

tests/test_code_generator.py

@@ -398,6 +398,57 @@ def test_automatic_output_string_conversion():
     assert msg == expected
 
 
+def test_utf8_string_vector_conversion():
+    """Test that UTF-8 strings in vectors are properly converted via delegation."""
+    target = os.path.join(test_files, "generated", "libcpp_utf8_string_vector_test.pyx")
+    include_dirs = autowrap.parse_and_generate_code(
+        ["libcpp_utf8_string_vector_test.pxd"],
+        root=test_files,
+        target=target,
+        debug=True,
+    )
+
+    wrapped = autowrap.Utils.compile_and_import(
+        "libcpp_utf8_string_vector_wrapped",
+        [
+            target,
+        ],
+        include_dirs,
+    )
+    h = wrapped.Utf8VectorTest()
+
+    # Test output conversion - vector of UTF-8 strings should become list of str
+    greetings = h.get_greetings()
+    assert isinstance(greetings, list)
+    assert len(greetings) == 4
+    # All elements should be unicode strings (str in Python 3)
+    for s in greetings:
+        assert isinstance(s, str), f"Expected str, got {type(s)}"
+    assert "Hello" in greetings
+    assert "World" in greetings
+    assert "Привет" in greetings  # Russian
+    assert "你好" in greetings  # Chinese
+
+    # Test input conversion - list of str/bytes should be accepted
+    input_strings = ["Test", "Тест", "测试"]  # ASCII, Russian, Chinese
+    result = h.echo(input_strings)
+    assert isinstance(result, list)
+    assert len(result) == 3
+    for s in result:
+        assert isinstance(s, str), f"Expected str, got {type(s)}"
+    assert result == input_strings
+
+    # Test with bytes input
+    input_bytes = [b"Hello", b"World"]
+    result = h.echo(input_bytes)
+    assert isinstance(result, list)
+    assert len(result) == 2
+
+    # Test count function (input only)
+    count = h.count_strings(["a", "b", "c"])
+    assert count == 3
+
+
 def test_wrap_ignore_foreign_cimports():
     """
     Test that wrap-ignored classes are not included in foreign cimports.

tests/test_files/libcpp_utf8_string_vector_test.hpp

@@ -0,0 +1,19 @@
+#include <string>
+#include <vector>
+
+class Utf8VectorTest {
+    public:
+        Utf8VectorTest(){}
+
+        std::vector<std::string> get_greetings() const {
+            return {"Hello", "World", "Привет", "你好"};
+        }
+
+        std::vector<std::string> echo(const std::vector<std::string>& input) const {
+            return input;
+        }
+
+        size_t count_strings(const std::vector<std::string>& input) const {
+            return input.size();
+        }
+};

tests/test_files/libcpp_utf8_string_vector_test.pxd

@@ -0,0 +1,11 @@
+# cython: language_level=3
+from libcpp.string cimport string as libcpp_utf8_output_string
+from libcpp.string cimport string as libcpp_utf8_string
+from libcpp.vector cimport vector as libcpp_vector
+
+cdef extern from "libcpp_utf8_string_vector_test.hpp":
+    cdef cppclass Utf8VectorTest:
+        Utf8VectorTest()
+        libcpp_vector[libcpp_utf8_output_string] get_greetings()
+        libcpp_vector[libcpp_utf8_output_string] echo(libcpp_vector[libcpp_utf8_string])
+        size_t count_strings(libcpp_vector[libcpp_utf8_string])