Add API to get slice from CxxVector

gen/src/write.rs

@@ -1270,6 +1270,13 @@ fn write_cxx_vector(out: &mut OutFile, vector_ty: &Type, element: &Ident, types:
     );
     writeln!(out, "  return s.size();");
     writeln!(out, "}}");
+    writeln!(
+        out,
+        "const {} *cxxbridge04$std$vector${}$data(const ::std::vector<{}> &s) noexcept {{",
+        inner, instance, inner,
+    );
+    writeln!(out, "  return s.data();");
+    writeln!(out, "}}");
     writeln!(
         out,
         "const {} *cxxbridge04$std$vector${}$get_unchecked(const ::std::vector<{}> &s, size_t pos) noexcept {{",

macro/src/expand.rs

@@ -841,6 +841,7 @@ fn expand_cxx_vector(namespace: &Namespace, elem: &Ident) -> TokenStream {
     let name = elem.to_string();
     let prefix = format!("cxxbridge04$std$vector${}{}$", namespace, elem);
     let link_size = format!("{}size", prefix);
+    let link_data = format!("{}data", prefix);
     let link_get_unchecked = format!("{}get_unchecked", prefix);
     let unique_ptr_prefix = format!("cxxbridge04$unique_ptr$std$vector${}{}$", namespace, elem);
     let link_unique_ptr_null = format!("{}null", unique_ptr_prefix);
@@ -859,6 +860,30 @@ fn expand_cxx_vector(namespace: &Namespace, elem: &Ident) -> TokenStream {
                 }
                 unsafe { __vector_size(v) }
             }
+            fn __vector_slice(v: &::cxx::CxxVector<Self>) -> &[Self] {
+                extern "C" {
+                    #[link_name = #link_size]
+                    fn __vector_size(_: &::cxx::CxxVector<#elem>) -> usize;
+                    #[link_name = #link_data]
+                    fn __vector_data(_: &::cxx::CxxVector<#elem>) -> *const #elem;
+                }
+                let data = unsafe { __vector_data(v) };
+                if (data.is_null())
+                {
+                    // Avoid undefined behaviour in slice::from_raw_parts() as
+                    // std::vector::data() returns nullptr if no capacity().
+                    // Alternative: Use from_raw_parts(NonNull::dangling(), 0)
+                    let ret = <&[Self]>::default(); // empty slice
+                    ret
+                }
+                else
+                {
+                    // std::vector with capacity() has valid data ptr, even if
+                    // size() == 0.
+                    let ret = unsafe { std::slice::from_raw_parts(data, __vector_size(v)) };
+                    ret
+                }
+            }
             unsafe fn __get_unchecked(v: &::cxx::CxxVector<Self>, pos: usize) -> &Self {
                 extern "C" {
                     #[link_name = #link_get_unchecked]

src/cxx.cc

@@ -199,6 +199,10 @@ void cxxbridge04$unique_ptr$std$string$drop(
       const std::vector<CXX_TYPE> &s) noexcept {                               \
     return s.size();                                                           \
   }                                                                            \
+  const CXX_TYPE* cxxbridge04$std$vector$##RUST_TYPE##$data(                   \
+      const std::vector<CXX_TYPE> &s) noexcept {                               \
+    return s.data();                                                           \
+  }                                                                            \
   const CXX_TYPE *cxxbridge04$std$vector$##RUST_TYPE##$get_unchecked(          \
       const std::vector<CXX_TYPE> &s, size_t pos) noexcept {                   \
     return &s[pos];                                                            \

src/cxx_vector.rs

@@ -4,6 +4,8 @@ use core::fmt::{self, Display};
 use core::marker::PhantomData;
 use core::mem;
 use core::ptr;
+use std::slice;
+
 
 /// Binding to C++ `std::vector<T, std::allocator<T>>`.
 ///
@@ -63,6 +65,15 @@ where
     pub unsafe fn get_unchecked(&self, pos: usize) -> &T {
         T::__get_unchecked(self, pos)
     }
+
+    /// Returns a slice to the underlying vector data
+    ///
+    /// An alternative approach would be to base your FFI API directly on a
+    /// rust::Slice<T> instead of a std::vector<T>.
+    pub fn get_slice(&self) -> &[T] {
+        let slice = T::__vector_slice(self);
+        slice
+    }
 }
 
 pub struct Iter<'a, T> {
@@ -122,6 +133,7 @@ where
 pub unsafe trait VectorElement: Sized {
     const __NAME: &'static dyn Display;
     fn __vector_size(v: &CxxVector<Self>) -> usize;
+    fn __vector_slice(v: &CxxVector<Self>) -> &[Self];
     unsafe fn __get_unchecked(v: &CxxVector<Self>, pos: usize) -> &Self;
     fn __unique_ptr_null() -> *mut c_void;
     unsafe fn __unique_ptr_raw(raw: *mut CxxVector<Self>) -> *mut c_void;
@@ -145,6 +157,34 @@ macro_rules! impl_vector_element {
                 }
                 unsafe { __vector_size(v) }
             }
+            fn __vector_slice(v: &CxxVector<$ty>) -> &[$ty] {
+                extern "C" {
+                    attr! {
+                        #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$data")]
+                        fn __vector_data(_: &CxxVector<$ty>) -> &$ty;
+                    }
+                    attr! {
+                        #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$size")]
+                        fn __vector_size(_: &CxxVector<$ty>) -> usize;
+                    }
+                }
+                let data : *const $ty = unsafe { __vector_data(v) };
+                if (data.is_null())
+                {
+                    // Avoid undefined behaviour in slice::from_raw_parts() as
+                    // std::vector::data() returns nullptr if no capacity().
+                    // Alternative: Use from_raw_parts(NonNull::dangling(), 0)
+                    let ret = <&[$ty]>::default(); // empty slice
+                    ret
+                }
+                else
+                {
+                    // std::vector with capacity() has valid data ptr, even if
+                    // size() == 0.
+                    let ret = unsafe { slice::from_raw_parts(data, __vector_size(v)) };
+                    ret
+                }
+            }
             unsafe fn __get_unchecked(v: &CxxVector<$ty>, pos: usize) -> &$ty {
                 extern "C" {
                     attr! {

tests/ffi/lib.rs

@@ -150,6 +150,9 @@ pub mod ffi {
         fn r_take_ref_rust_vec_string(v: &Vec<String>);
         fn r_take_enum(e: Enum);
 
+        fn r_access_vector_u8_as_slice(v: &CxxVector<u8>);
+        fn r_access_vector_u8_as_slice_empty(v: &CxxVector<u8>);
+
         fn r_try_return_void() -> Result<()>;
         fn r_try_return_primitive() -> Result<usize>;
         fn r_try_return_box() -> Result<Box<R>>;
@@ -165,6 +168,8 @@ pub type R = usize;
 
 pub struct R2(usize);
 
+use cxx::CxxVector;
+
 impl R2 {
     fn get(&self) -> usize {
         self.0
@@ -327,6 +332,16 @@ fn r_take_enum(e: ffi::Enum) {
     let _ = e;
 }
 
+fn r_access_vector_u8_as_slice(v: &CxxVector<u8>) {
+    let s = v.get_slice();
+    assert_eq!(s, [86, 75, 30, 9]);
+}
+
+fn r_access_vector_u8_as_slice_empty(v: &CxxVector<u8>) {
+    let s = v.get_slice();
+    assert!(s.is_empty());
+}
+
 fn r_try_return_void() -> Result<(), Error> {
     Ok(())
 }

tests/ffi/tests.cc

@@ -401,6 +401,29 @@ extern "C" const char *cxx_run_test() noexcept {
       std::unique_ptr<std::string>(new std::string("2020")));
   r_take_enum(Enum::AVal);
 
+  // Caller owns data handed into rust APIs
+  {
+    std::vector<std::uint8_t> v{86, 75, 30, 9};
+    r_access_vector_u8_as_slice(v);
+  }
+  {
+    // Empty std::vector has data() == nullptr.
+    // This shall produce an empty slice.
+    std::vector<std::uint8_t> v;
+    ASSERT(v.data() == nullptr);
+    ASSERT(v.size() == 0);
+    r_access_vector_u8_as_slice_empty(v);
+  }
+  {
+    // Empty std::vector with capacity has data() != nullptr and size() == 0.
+    // This shall produce an empty slice.
+    std::vector<std::uint8_t> v;
+    v.reserve(10);
+    ASSERT(v.data() != nullptr);
+    ASSERT(v.size() == 0);
+    r_access_vector_u8_as_slice_empty(v);
+  }
+
   ASSERT(r_try_return_primitive() == 2020);
   try {
     r_fail_return_primitive();