- more additions to the API

- C Provider and Client API tests

src/shm/provider/alloc_layout_impl.rs

@@ -18,7 +18,7 @@ use zenoh::prelude::*;
 use zenoh::shm::AllocPolicy;
 
 use crate::{
-    errors::{z_error_t, Z_EINVAL, Z_OK}, transmute::{Inplace, TransmuteFromHandle, TransmuteUninitPtr}, z_owned_buf_alloc_result_t
+    errors::{z_error_t, Z_EINVAL, Z_OK}, transmute::{Inplace, TransmuteCopy, TransmuteFromHandle, TransmuteUninitPtr}, z_owned_buf_alloc_result_t
 };
 
 use super::{alloc_layout::{z_loaned_alloc_layout_t, z_owned_alloc_layout_t, CSHMLayout}, shared_memory_provider::z_loaned_shared_memory_provider_t, types::z_alloc_alignment_t};
@@ -33,7 +33,7 @@ pub(crate) fn alloc_layout_new(
         super::shared_memory_provider::CSHMProvider::Posix(provider) => {
             match provider
                 .alloc(size)
-                .with_alignment(alignment.into())
+                .with_alignment(alignment.transmute_copy())
                 .into_layout()
             {
                 Ok(layout) => CSHMLayout::Posix(layout),
@@ -46,7 +46,7 @@ pub(crate) fn alloc_layout_new(
         super::shared_memory_provider::CSHMProvider::Dynamic(provider) => {
             match provider
                 .alloc(size)
-                .with_alignment(alignment.into())
+                .with_alignment(alignment.transmute_copy())
                 .into_layout()
             {
                 Ok(layout) => CSHMLayout::Dynamic(layout),
@@ -59,7 +59,7 @@ pub(crate) fn alloc_layout_new(
         super::shared_memory_provider::CSHMProvider::DynamicThreadsafe(provider) => {
             match provider
                 .alloc(size)
-                .with_alignment(alignment.into())
+                .with_alignment(alignment.transmute_copy())
                 .into_layout()
             {
                 Ok(layout) => CSHMLayout::DynamicThreadsafe(layout),

src/shm/provider/shared_memory_provider.rs

@@ -38,7 +38,7 @@ use super::{
     shared_memory_provider_backend::{
         zc_shared_memory_provider_backend_callbacks_t, DynamicSharedMemoryProviderBackend,
     },
-    shared_memory_provider_impl::{alloc, alloc_async, defragment, garbage_collect, map},
+    shared_memory_provider_impl::{alloc, alloc_async, available, defragment, garbage_collect, map},
     types::z_alloc_alignment_t,
 };
 
@@ -248,6 +248,13 @@ pub extern "C" fn z_shared_memory_provider_garbage_collect(
     garbage_collect(provider);
 }
 
+#[no_mangle]
+pub extern "C" fn z_shared_memory_provider_available(
+    provider: &z_loaned_shared_memory_provider_t,
+) -> usize {
+    available(provider)
+}
+
 #[no_mangle]
 pub extern "C" fn z_shared_memory_provider_map(
     out_result: *mut MaybeUninit<z_owned_shm_mut_t>,

src/shm/provider/shared_memory_provider_backend.rs

@@ -38,7 +38,6 @@ pub struct zc_shared_memory_provider_backend_callbacks_t {
     defragment_fn: unsafe extern "C" fn(*mut c_void) -> usize,
     available_fn: unsafe extern "C" fn(*mut c_void) -> usize,
     layout_for_fn: unsafe extern "C" fn(*mut c_void, *mut z_owned_memory_layout_t),
-    drop_fn: unsafe extern "C" fn(*mut c_void),
 }
 
 #[derive(Debug)]

src/shm/provider/shared_memory_provider_impl.rs

@@ -20,7 +20,7 @@ use zenoh::shm::{AllocPolicy, AsyncAllocPolicy, SharedMemoryProvider};
 
 use crate::context::{Context, DroppableContext, ThreadsafeContext};
 use crate::errors::{z_error_t, Z_EINVAL, Z_OK};
-use crate::transmute::{Inplace, TransmuteFromHandle, TransmuteUninitPtr};
+use crate::transmute::{Inplace, TransmuteCopy, TransmuteFromHandle, TransmuteUninitPtr};
 use crate::{z_owned_buf_alloc_result_t, z_owned_shm_mut_t};
 
 use super::chunk::z_allocated_chunk_t;
@@ -132,6 +132,20 @@ pub(crate) fn garbage_collect(provider: &z_loaned_shared_memory_provider_t) {
     }
 }
 
+pub(crate) fn available(provider: &z_loaned_shared_memory_provider_t) -> usize {
+    match provider.transmute_ref() {
+        super::shared_memory_provider::CSHMProvider::Posix(provider) => {
+            provider.available()
+        }
+        super::shared_memory_provider::CSHMProvider::Dynamic(provider) => {
+            provider.available()
+        }
+        super::shared_memory_provider::CSHMProvider::DynamicThreadsafe(provider) => {
+            provider.available()
+        }
+    }
+}
+
 #[no_mangle]
 pub(crate) fn map(
     out_result: *mut MaybeUninit<z_owned_shm_mut_t>,
@@ -172,7 +186,7 @@ fn alloc_impl<
 ) -> z_error_t {
     let result = provider
         .alloc(size)
-        .with_alignment(alignment.into())
+        .with_alignment(alignment.transmute_copy())
         .with_policy::<Policy>()
         .wait();
 

src/shm/provider/types.rs

@@ -20,7 +20,7 @@ use zenoh_util::core::zerror;
 use crate::{
     errors::{z_error_t, Z_EINVAL, Z_OK},
     transmute::{
-        unwrap_ref_unchecked, Inplace, TransmuteIntoHandle, TransmuteRef, TransmuteUninitPtr,
+        unwrap_ref_unchecked, Inplace, TransmuteCopy, TransmuteFromHandle, TransmuteIntoHandle, TransmuteRef, TransmuteUninitPtr
     },
     z_loaned_buf_alloc_result_t, z_loaned_chunk_alloc_result_t, z_loaned_memory_layout_t,
     z_owned_buf_alloc_result_t, z_owned_chunk_alloc_result_t, z_owned_memory_layout_t,
@@ -66,15 +66,12 @@ impl From<z_alloc_error_t> for ZAllocError {
 
 // An AllocAlignment.
 #[repr(C)]
+#[derive(Clone, Copy)]
 pub struct z_alloc_alignment_t {
-    pub pow: u8,
+    pow: u8,
 }
 
-impl From<z_alloc_alignment_t> for AllocAlignment {
-    fn from(value: z_alloc_alignment_t) -> Self {
-        Self::new(value.pow)
-    }
-}
+decl_transmute_copy!(AllocAlignment, z_alloc_alignment_t);
 
 decl_transmute_owned!(Option<MemoryLayout>, z_owned_memory_layout_t);
 decl_transmute_handle!(MemoryLayout, z_loaned_memory_layout_t);
@@ -126,6 +123,18 @@ pub extern "C" fn z_memory_layout_drop(this: &mut z_owned_memory_layout_t) {
     let _ = this.transmute_mut().take();
 }
 
+/// Deletes Memory Layout
+#[no_mangle]
+pub extern "C" fn z_memory_layout_get_data(
+    out_size: &mut MaybeUninit<usize>,
+    out_alignment: &mut MaybeUninit<z_alloc_alignment_t>,
+    this: &z_loaned_memory_layout_t,
+) {
+    let layout = this.transmute_ref();
+    out_size.write(layout.size());
+    out_alignment.write(layout.alignment().transmute_copy() );
+}
+
 decl_transmute_owned!(Option<ChunkAllocResult>, z_owned_chunk_alloc_result_t);
 
 decl_transmute_handle!(ChunkAllocResult, z_loaned_chunk_alloc_result_t);