Raw pointer API for publisher and subscriber

iceoryx-sys/src/chunk_header.rs

@@ -13,8 +13,9 @@ cpp! {{
 cpp_class!(pub unsafe struct ChunkHeader as "ChunkHeader");
 
 impl ChunkHeader {
-    pub fn from_user_payload<T>(payload: &T) -> Option<&Self> {
-        let payload = payload as *const T as *const c_void;
+    pub(super) unsafe fn from_user_payload_unchecked<'a>(
+        payload: *const c_void,
+    ) -> Option<&'a Self> {
         unsafe {
             let chunk_header = cpp!([payload as "void*"] -> *const c_void as "const void*" {
                 return iox::mepoo::ChunkHeader::fromUserPayload(payload);

iceoryx-sys/src/lib.rs

@@ -25,6 +25,10 @@ pub use queue_policy::QueueFullPolicy;
 mod runtime;
 pub use runtime::Runtime;
 
+mod sample;
+pub use sample::RawSample;
+pub use sample::RawSampleMut;
+
 mod subscriber;
 pub use subscriber::ConditionVariable;
 pub use subscriber::SubscribeState;

iceoryx-sys/src/publisher.rs

@@ -2,9 +2,10 @@
 // SPDX-FileCopyrightText: © Contributors to the iceoryx-rs project
 // SPDX-FileContributor: Mathias Kraus
 
-use crate::PublisherOptions;
+use crate::{PublisherOptions, RawSampleMut};
 
 use std::ffi::{c_void, CString};
+use std::mem::MaybeUninit;
 
 cpp! {{
     #include "iceoryx_posh/internal/popo/ports/publisher_port_user.hpp"
@@ -104,38 +105,33 @@ impl Publisher {
         }
     }
 
-    pub fn try_allocate<T>(&self) -> Option<*mut T> {
+    pub fn try_allocate<T>(&self) -> Option<RawSampleMut<MaybeUninit<T>>> {
         let size = std::mem::size_of::<T>() as u32;
         let align = std::mem::align_of::<T>() as u32;
         unsafe {
-            let payload = self.try_allocate_chunk(size, align);
-
-            if !payload.is_null() {
-                Some(payload as *mut T)
-            } else {
-                None
-            }
+            self.try_allocate_chunk(size, align)
+                .map(|payload| payload.cast::<MaybeUninit<T>>())
         }
     }
 
-    pub fn try_allocate_slice<T>(&self, len: u32, align: u32) -> Option<*mut T> {
+    pub fn try_allocate_slice<T>(
+        &self,
+        len: u32,
+        align: u32,
+    ) -> Option<RawSampleMut<[MaybeUninit<T>]>> {
         unsafe {
             if align < std::mem::align_of::<T>() as u32 {
                 return None;
             }
 
             let size = len * std::mem::size_of::<T>() as u32;
-            let payload = self.try_allocate_chunk(size, align);
-
-            if !payload.is_null() {
-                Some(payload as *mut T)
-            } else {
-                None
-            }
+            self.try_allocate_chunk(size, align).map(|payload| {
+                RawSampleMut::slice_from_raw_parts(payload.cast::<MaybeUninit<T>>(), len as usize)
+            })
         }
     }
 
-    unsafe fn try_allocate_chunk(&self, size: u32, align: u32) -> *mut c_void {
+    unsafe fn try_allocate_chunk(&self, size: u32, align: u32) -> Option<RawSampleMut<c_void>> {
         let payload = cpp!([self as "PublisherPortUser*", size as "uint32_t", align as "uint32_t"] -> *mut std::ffi::c_void as "void*" {
             auto allocResult = self->tryAllocateChunk(size,
                                                       align,
@@ -147,21 +143,26 @@ impl Publisher {
                 return allocResult.value()->userPayload();
             }
         });
-        payload
+
+        if !payload.is_null() {
+            Some(RawSampleMut::new_unchecked(payload))
+        } else {
+            None
+        }
     }
 
-    pub fn release<T: ?Sized>(&self, payload: *mut T) {
+    pub fn release<T: ?Sized>(&self, sample: RawSampleMut<T>) {
         unsafe {
-            let payload = payload as *const c_void;
+            let payload = sample.cast::<c_void>().as_payload_ptr();
             cpp!([self as "PublisherPortUser*", payload as "void*"] {
                 auto header = iox::mepoo::ChunkHeader::fromUserPayload(payload);
                 self->releaseChunk(header);
             });
         }
     }
 
-    pub fn send<T: ?Sized>(&self, payload: *mut T) {
-        let payload = payload as *const c_void;
+    pub fn send<T: ?Sized>(&self, sample: RawSampleMut<T>) {
+        let payload = sample.cast::<c_void>().as_payload_ptr();
         unsafe {
             cpp!([self as "PublisherPortUser*", payload as "void*"] {
                 auto header = iox::mepoo::ChunkHeader::fromUserPayload(payload);

iceoryx-sys/src/sample.rs

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: © Contributors to the iceoryx-rs project
+// SPDX-FileContributor: Mathias Kraus
+
+use crate::ChunkHeader;
+
+use std::ffi::c_void;
+use std::fmt;
+use std::slice;
+
+#[repr(transparent)]
+pub struct RawSample<T: ?Sized> {
+    payload: *const T,
+}
+
+impl<T: ?Sized> RawSample<T> {
+    #[inline]
+    pub unsafe fn new_unchecked(payload: *const T) -> Self {
+        debug_assert!(
+            !payload.is_null(),
+            "RawSample::new_unchecked requires that the payload pointer is non-null"
+        );
+        Self { payload }
+    }
+
+    #[allow(clippy::not_unsafe_ptr_arg_deref)] // false positive
+    #[inline]
+    pub fn new(payload: *const T) -> Option<Self> {
+        if !payload.is_null() {
+            // SAFETY: `payload` pointer is checked to be non-null
+            Some(unsafe { Self::new_unchecked(payload) })
+        } else {
+            None
+        }
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn cast<U>(self) -> RawSample<U> {
+        // SAFETY: `self.as_payload_ptr` returns a non-null ptr
+        unsafe { RawSample::new_unchecked(self.as_payload_ptr().cast::<U>()) }
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn as_payload_ptr(self) -> *const T {
+        self.payload
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn chunk_header(&self) -> &ChunkHeader {
+        unsafe {
+            ChunkHeader::from_user_payload_unchecked(self.as_payload_ptr() as *const c_void)
+                .expect("Valid chunk header from payload!")
+        }
+    }
+}
+
+impl<T> RawSample<[T]> {
+    #[must_use]
+    #[inline]
+    pub fn slice_from_raw_parts(sample: RawSample<T>, len: usize) -> RawSample<[T]> {
+        // SAFETY: `self.as_payload_ptr` returns a non-null ptr
+        unsafe { Self::new_unchecked(slice::from_raw_parts(sample.as_payload_ptr(), len)) }
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn len(self) -> usize {
+        // SAFETY: `self.as_payload_ptr` returns a non-null ptr
+        unsafe { (*self.as_payload_ptr()).len() }
+    }
+}
+
+impl<T: ?Sized> Clone for RawSample<T> {
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: ?Sized> Copy for RawSample<T> {}
+
+impl<T: ?Sized> fmt::Debug for RawSample<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.as_payload_ptr(), f)
+    }
+}
+
+impl<T: ?Sized> fmt::Pointer for RawSample<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.as_payload_ptr(), f)
+    }
+}
+
+#[repr(transparent)]
+pub struct RawSampleMut<T: ?Sized> {
+    payload: *mut T,
+}
+
+impl<T: ?Sized> RawSampleMut<T> {
+    #[inline]
+    pub unsafe fn new_unchecked(payload: *mut T) -> Self {
+        debug_assert!(
+            !payload.is_null(),
+            "RawSampleMut::new_unchecked requires that the payload pointer is non-null"
+        );
+        Self { payload }
+    }
+
+    #[allow(clippy::not_unsafe_ptr_arg_deref)] // false positive
+    #[inline]
+    pub fn new(payload: *mut T) -> Option<Self> {
+        if !payload.is_null() {
+            // SAFETY: `payload` pointer is checked to be non-null
+            Some(unsafe { Self::new_unchecked(payload) })
+        } else {
+            None
+        }
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn cast<U>(self) -> RawSampleMut<U> {
+        // SAFETY: `self.as_payload_mut_ptr` returns a non-null ptr
+        unsafe { RawSampleMut::new_unchecked(self.as_payload_mut_ptr().cast::<U>()) }
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn as_payload_ptr(self) -> *const T {
+        self.as_payload_mut_ptr()
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn as_payload_mut_ptr(self) -> *mut T {
+        self.payload
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn chunk_header(&self) -> &ChunkHeader {
+        unsafe {
+            ChunkHeader::from_user_payload_unchecked(self.as_payload_ptr() as *const c_void)
+                .expect("Valid chunk header from payload!")
+        }
+    }
+}
+
+impl<T> RawSampleMut<[T]> {
+    #[must_use]
+    #[inline]
+    pub fn slice_from_raw_parts(sample: RawSampleMut<T>, len: usize) -> RawSampleMut<[T]> {
+        // SAFETY: `self.as_payload_mut_ptr` returns a non-null ptr
+        unsafe { Self::new_unchecked(slice::from_raw_parts_mut(sample.as_payload_mut_ptr(), len)) }
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn len(self) -> usize {
+        // SAFETY: `self.as_payload_ptr` returns a non-null ptr
+        unsafe { (*self.as_payload_ptr()).len() }
+    }
+}
+
+impl<T: ?Sized> Clone for RawSampleMut<T> {
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: ?Sized> Copy for RawSampleMut<T> {}
+
+impl<T: ?Sized> fmt::Debug for RawSampleMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.as_payload_ptr(), f)
+    }
+}
+
+impl<T: ?Sized> fmt::Pointer for RawSampleMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.as_payload_ptr(), f)
+    }
+}

iceoryx-sys/src/subscriber.rs

@@ -3,7 +3,7 @@
 // SPDX-FileContributor: Mathias Kraus
 // SPDX-FileContributor: Apex.AI
 
-use crate::SubscriberOptions;
+use crate::{RawSample, SubscriberOptions};
 
 use std::ffi::{c_void, CString};
 use std::fmt;
@@ -244,29 +244,55 @@ impl Subscriber {
         }
     }
 
-    pub fn get_chunk<T>(&self) -> Option<*const T> {
+    pub fn try_take<T>(&self) -> Option<RawSample<T>> {
+        unsafe { self.try_get_chunk().map(|payload| payload.cast::<T>()) }
+    }
+
+    pub fn try_take_slice<T>(&self) -> Option<RawSample<[T]>> {
         unsafe {
-            let payload = cpp!([self as "SubscriberPortUser*"] -> *const std::ffi::c_void as "const void*" {
-                auto getChunkResult = self->tryGetChunk();
+            let payload = self.try_get_chunk()?;
 
-                if (getChunkResult.has_error()) {
-                    return nullptr;
-                }
+            let chunk_header = payload.chunk_header();
+            let payload_size = chunk_header.get_user_payload_size();
+            let payload_alignment = chunk_header.get_user_payload_alignment();
+            let len = payload_size as usize / std::mem::size_of::<T>();
 
-                return getChunkResult.value()->userPayload();
-            });
-
-            if !payload.is_null() {
-                Some(payload as *const T)
+            if payload_size as usize % std::mem::size_of::<T>() == 0
+                && payload_alignment as usize >= std::mem::align_of::<T>()
+            {
+                Some(RawSample::slice_from_raw_parts(
+                    payload.cast::<T>(),
+                    len as usize,
+                ))
             } else {
+                // TODO return Result<Option<T>>
+                self.release(payload);
                 None
             }
         }
     }
 
-    pub fn release_chunk<T: ?Sized>(&self, payload: *const T) {
+    unsafe fn try_get_chunk(&self) -> Option<RawSample<c_void>> {
+        let payload = cpp!([self as "SubscriberPortUser*"] -> *const std::ffi::c_void as "const void*" {
+            auto getChunkResult = self->tryGetChunk();
+
+            if (getChunkResult.has_error()) {
+                return nullptr;
+            }
+
+            return getChunkResult.value()->userPayload();
+        });
+
+        if !payload.is_null() {
+            Some(RawSample::new_unchecked(payload))
+        } else {
+            None
+        }
+    }
+
+    pub fn release<T: ?Sized>(&self, sample: RawSample<T>) {
         unsafe {
-            let payload = payload as *const c_void;
+            let payload = sample.cast::<c_void>().as_payload_ptr();
             cpp!([self as "SubscriberPortUser*", payload as "void*"] {
                 auto header = iox::mepoo::ChunkHeader::fromUserPayload(payload);
                 self->releaseChunk(header);

src/lib.rs

@@ -84,6 +84,8 @@ pub mod mt {
 // re-exports from iceoryx-sys
 pub use ffi::ConsumerTooSlowPolicy;
 pub use ffi::QueueFullPolicy;
+pub use ffi::RawSample;
+pub use ffi::RawSampleMut;
 pub use ffi::Runtime;
 pub use ffi::SubscribeState;