Simplify array wrappers to use libcpp.vector directly without C++ layer

- Removed C++ wrapper classes (ArrayWrapper.hpp, ArrayWrapper.pxd)
- ArrayWrapper classes now directly hold libcpp_vector
- ArrayView classes now directly hold raw pointer + size + owner
- Added factory functions for creating views from C level
- For value returns: use owning wrapper with swap (no extra copy)
- For reference returns: use views for zero-copy access
- Fixed buffer protocol format string storage
- Updated .pxd with proper attribute declarations

Co-authored-by: jpfeuffer <8102638+jpfeuffer@users.noreply.github.com>

Author: Copilot

autowrap/CodeGenerator.py

@@ -2097,9 +2097,15 @@ def create_default_cimports(self):
                    |cimport numpy as numpy
                    |import numpy as numpy
                    |from ArrayWrappers cimport (
+                   |    ArrayWrapperFloat, ArrayWrapperDouble,
+                   |    ArrayWrapperInt8, ArrayWrapperInt16, ArrayWrapperInt32, ArrayWrapperInt64,
+                   |    ArrayWrapperUInt8, ArrayWrapperUInt16, ArrayWrapperUInt32, ArrayWrapperUInt64,
                    |    ArrayViewFloat, ArrayViewDouble,
                    |    ArrayViewInt8, ArrayViewInt16, ArrayViewInt32, ArrayViewInt64,
-                   |    ArrayViewUInt8, ArrayViewUInt16, ArrayViewUInt32, ArrayViewUInt64
+                   |    ArrayViewUInt8, ArrayViewUInt16, ArrayViewUInt32, ArrayViewUInt64,
+                   |    _create_view_float, _create_view_double,
+                   |    _create_view_int8, _create_view_int16, _create_view_int32, _create_view_int64,
+                   |    _create_view_uint8, _create_view_uint16, _create_view_uint32, _create_view_uint64
                    |)
                    """
             )

autowrap/ConversionProvider.py

@@ -2192,6 +2192,11 @@ def _get_wrapper_class_name(self, cpp_type: CppType) -> str:
         }
         return type_map.get(cpp_type.base_type, "Double")
 
+    def _get_factory_function_name(self, cpp_type: CppType) -> str:
+        """Get the factory function name for creating an ArrayView."""
+        suffix = self._get_wrapper_class_name(cpp_type)
+        return f"_create_view_{suffix.lower()}"
+    
     def output_conversion(
         self, cpp_type: CppType, input_cpp_var: str, output_py_var: str
     ) -> Optional[Code]:
@@ -2200,7 +2205,7 @@ def output_conversion(
         Uses ArrayWrapper/ArrayView classes with buffer protocol:
         - For non-const references: Create zero-copy view (ArrayView with readonly=False)
         - For const references: Create zero-copy view (ArrayView with readonly=True) 
-        - For value returns: Copy data using memcpy (Python owns memory)
+        - For value returns: Use owning wrapper (data is already a copy)
         """
         (tt,) = cpp_type.template_args
 
@@ -2239,17 +2244,20 @@ def output_conversion(
             dtype = self._get_numpy_dtype(tt)
             ctype = self.CTYPE_MAP.get(dtype, "double")
             wrapper_suffix = self._get_wrapper_class_name(tt)
+            factory_func = self._get_factory_function_name(tt)
 
             # Check if this is a reference return (view opportunity)
             if cpp_type.is_ref:
-                # Use ArrayView for zero-copy access
+                # Use ArrayView for zero-copy access via factory function
                 readonly = "True" if cpp_type.is_const else "False"
                 code = Code().add(
                     """
                     |# Convert C++ vector reference to numpy array VIEW (zero-copy)
-                    |cdef ArrayView$wrapper_suffix _view_$output_py_var = ArrayView$wrapper_suffix(
-                    |    $input_cpp_var.data(), 
-                    |    $input_cpp_var.size(), 
+                    |cdef $ctype* _ptr_$output_py_var = $input_cpp_var.data()
+                    |cdef size_t _size_$output_py_var = $input_cpp_var.size()
+                    |cdef ArrayView$wrapper_suffix _view_$output_py_var = $factory_func(
+                    |    _ptr_$output_py_var,
+                    |    _size_$output_py_var,
                     |    owner=self,
                     |    readonly=$readonly
                     |)
@@ -2260,26 +2268,27 @@ def output_conversion(
                         input_cpp_var=input_cpp_var,
                         output_py_var=output_py_var,
                         wrapper_suffix=wrapper_suffix,
+                        factory_func=factory_func,
                         readonly=readonly,
+                        ctype=ctype,
                     ),
                 )
                 return code
             else:
-                # Value return - copy data to Python (simpler and safer)
+                # Value return - use owning wrapper (data is already a copy)
+                # Swap the returned vector into the wrapper to transfer ownership
                 code = Code().add(
                     """
-                    |# Convert C++ vector to numpy array COPY (Python owns data)
-                    |cdef size_t n_$output_py_var = $input_cpp_var.size()
-                    |cdef object $output_py_var = numpy.empty(n_$output_py_var, dtype=numpy.$dtype)
-                    |if n_$output_py_var > 0:
-                    |    memcpy(<void*>numpy.PyArray_DATA($output_py_var), $input_cpp_var.data(), n_$output_py_var * sizeof($ctype))
+                    |# Convert C++ vector to numpy array using owning wrapper (data already copied)
+                    |cdef ArrayWrapper$wrapper_suffix _wrapper_$output_py_var = ArrayWrapper$wrapper_suffix()
+                    |_wrapper_$output_py_var.set_data($input_cpp_var)
+                    |cdef object $output_py_var = numpy.asarray(_wrapper_$output_py_var)
+                    |$output_py_var.base = _wrapper_$output_py_var
                     """,
                     dict(
                         input_cpp_var=input_cpp_var,
                         output_py_var=output_py_var,
-                        inner_type=inner_type,
-                        dtype=dtype,
-                        ctype=ctype,
+                        wrapper_suffix=wrapper_suffix,
                     ),
                 )
                 return code

autowrap/data_files/autowrap/ArrayWrapper.hpp

@@ -1,71 +1,113 @@
 # cython: language_level=3
 """
 Cython declaration file for ArrayWrappers module.
-This allows other Cython modules to import the wrapper classes.
+This allows other Cython modules to import the wrapper classes and factory functions.
 """
 
 from libcpp.vector cimport vector as libcpp_vector
 from libcpp cimport bool as cbool
 from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t
 
-# Owning wrapper classes
+# Owning wrapper classes (hold libcpp_vector directly)
 cdef class ArrayWrapperFloat:
-    pass
+    cdef libcpp_vector[float] vec
 
 cdef class ArrayWrapperDouble:
-    pass
+    cdef libcpp_vector[double] vec
 
 cdef class ArrayWrapperInt8:
-    pass
+    cdef libcpp_vector[int8_t] vec
 
 cdef class ArrayWrapperInt16:
-    pass
+    cdef libcpp_vector[int16_t] vec
 
 cdef class ArrayWrapperInt32:
-    pass
+    cdef libcpp_vector[int32_t] vec
 
 cdef class ArrayWrapperInt64:
-    pass
+    cdef libcpp_vector[int64_t] vec
 
 cdef class ArrayWrapperUInt8:
-    pass
+    cdef libcpp_vector[uint8_t] vec
 
 cdef class ArrayWrapperUInt16:
-    pass
+    cdef libcpp_vector[uint16_t] vec
 
 cdef class ArrayWrapperUInt32:
-    pass
+    cdef libcpp_vector[uint32_t] vec
 
 cdef class ArrayWrapperUInt64:
-    pass
+    cdef libcpp_vector[uint64_t] vec
 
-# Non-owning view classes  
+# Non-owning view classes (hold raw pointer + size + owner)
 cdef class ArrayViewFloat:
-    pass
+    cdef float* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewDouble:
-    pass
+    cdef double* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewInt8:
-    pass
+    cdef int8_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewInt16:
-    pass
+    cdef int16_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewInt32:
-    pass
+    cdef int32_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewInt64:
-    pass
+    cdef int64_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewUInt8:
-    pass
+    cdef uint8_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewUInt16:
-    pass
+    cdef uint16_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewUInt32:
-    pass
+    cdef uint32_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
 
 cdef class ArrayViewUInt64:
-    pass
+    cdef uint64_t* ptr
+    cdef size_t _size
+    cdef object owner
+    cdef cbool readonly
+
+# Factory functions for creating views from C level
+cdef ArrayViewFloat _create_view_float(float* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewDouble _create_view_double(double* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewInt8 _create_view_int8(int8_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewInt16 _create_view_int16(int16_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewInt32 _create_view_int32(int32_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewInt64 _create_view_int64(int64_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewUInt8 _create_view_uint8(uint8_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewUInt16 _create_view_uint16(uint16_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewUInt32 _create_view_uint32(uint32_t* ptr, size_t size, object owner, cbool readonly)
+cdef ArrayViewUInt64 _create_view_uint64(uint64_t* ptr, size_t size, object owner, cbool readonly)