res() -> wait()

commons/zenoh-core/src/lib.rs

@@ -31,7 +31,7 @@ pub use zresult::{Error, ZResult as Result};
 
 /// A resolvable execution, either sync or async
 pub trait Resolvable {
-    type To: Sized + Send;
+    type To: Sized;
 }
 
 /// Trick used to mark `<Resolve as IntoFuture>::IntoFuture` bound as Send

commons/zenoh-shm/src/api/protocol_implementations/posix/posix_shm_provider_backend.rs

@@ -23,7 +23,7 @@ use std::{
     },
 };
 
-use zenoh_core::zlock;
+use zenoh_core::{zlock, Resolvable, Wait};
 use zenoh_result::ZResult;
 
 use super::posix_shm_segment::PosixShmSegment;
@@ -108,10 +108,14 @@ pub struct LayoutedPosixShmProviderBackendBuilder<Layout: Borrow<MemoryLayout>>
     layout: Layout,
 }
 
-impl<Layout: Borrow<MemoryLayout>> LayoutedPosixShmProviderBackendBuilder<Layout> {
-    /// try to create PosixShmProviderBackend
-    #[zenoh_macros::unstable_doc]
-    pub fn res(self) -> ZResult<PosixShmProviderBackend> {
+#[zenoh_macros::unstable_doc]
+impl<Layout: Borrow<MemoryLayout>> Resolvable for LayoutedPosixShmProviderBackendBuilder<Layout> {
+    type To = ZResult<PosixShmProviderBackend>;
+}
+
+#[zenoh_macros::unstable_doc]
+impl<Layout: Borrow<MemoryLayout>> Wait for LayoutedPosixShmProviderBackendBuilder<Layout> {
+    fn wait(self) -> <Self as Resolvable>::To {
         PosixShmProviderBackend::new(self.layout.borrow())
     }
 }

commons/zenoh-shm/src/api/provider/shm_provider.rs

@@ -719,14 +719,23 @@ where
     backend: Backend,
     id: IDSource,
 }
-impl<IDSource, Backend> ShmProviderBuilderBackendID<IDSource, Backend>
+#[zenoh_macros::unstable_doc]
+impl<IDSource, Backend> Resolvable for ShmProviderBuilderBackendID<IDSource, Backend>
+where
+    IDSource: ProtocolIDSource,
+    Backend: ShmProviderBackend,
+{
+    type To = ShmProvider<IDSource, Backend>;
+}
+
+#[zenoh_macros::unstable_doc]
+impl<IDSource, Backend> Wait for ShmProviderBuilderBackendID<IDSource, Backend>
 where
     IDSource: ProtocolIDSource,
     Backend: ShmProviderBackend,
 {
     /// build ShmProvider
-    #[zenoh_macros::unstable_doc]
-    pub fn res(self) -> ShmProvider<IDSource, Backend> {
+    fn wait(self) -> <Self as Resolvable>::To {
         ShmProvider::new(self.backend, self.id)
     }
 }

commons/zenoh-shm/tests/posix_shm_provider.rs

@@ -12,6 +12,7 @@
 //   ZettaScale Zenoh Team, <[email protected]>
 //
 
+use zenoh_core::Wait;
 use zenoh_shm::api::{
     client::shm_client::ShmClient,
     protocol_implementations::posix::{
@@ -31,7 +32,7 @@ fn posix_shm_provider_create() {
     let _backend = PosixShmProviderBackend::builder()
         .with_size(1024)
         .expect("Error creating Layout!")
-        .res()
+        .wait()
         .expect("Error creating PosixShmProviderBackend!");
 }
 
@@ -40,7 +41,7 @@ fn posix_shm_provider_alloc() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(1024)
         .expect("Error creating Layout!")
-        .res()
+        .wait()
         .expect("Error creating PosixShmProviderBackend!");
 
     let layout = MemoryLayout::new(100, AllocAlignment::default()).unwrap();
@@ -55,7 +56,7 @@ fn posix_shm_provider_open() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(1024)
         .expect("Error creating Layout!")
-        .res()
+        .wait()
         .expect("Error creating PosixShmProviderBackend!");
 
     let layout = MemoryLayout::new(100, AllocAlignment::default()).unwrap();
@@ -76,7 +77,7 @@ fn posix_shm_provider_allocator() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(BUFFER_SIZE * BUFFER_NUM)
         .expect("Error creating Layout!")
-        .res()
+        .wait()
         .expect("Error creating PosixShmProviderBackend!");
 
     let layout = MemoryLayout::new(BUFFER_SIZE, AllocAlignment::default()).unwrap();

examples/examples/z_alloc_shm.rs

@@ -17,7 +17,7 @@ use zenoh::{
         AllocAlignment, BlockOn, Deallocate, Defragment, GarbageCollect, PosixShmProviderBackend,
         ShmProviderBuilder, POSIX_PROTOCOL_ID,
     },
-    Config,
+    Config, Wait,
 };
 
 #[tokio::main]
@@ -33,13 +33,13 @@ async fn run() -> ZResult<()> {
     let backend = PosixShmProviderBackend::builder()
         .with_size(65536)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // There are two API-defined ways of making shm buffer allocations: direct and through the layout...
 

examples/examples/z_bytes_shm.rs

@@ -26,13 +26,13 @@ fn main() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(4096)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // Allocate an SHM buffer
     // NOTE: For allocation API please check z_alloc_shm.rs example

examples/examples/z_get_shm.rs

@@ -20,7 +20,7 @@ use zenoh::{
         zshm, BlockOn, GarbageCollect, PosixShmProviderBackend, ShmProviderBuilder,
         POSIX_PROTOCOL_ID,
     },
-    Config,
+    Config, Wait,
 };
 use zenoh_examples::CommonArgs;
 
@@ -42,13 +42,13 @@ async fn main() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(N * 1024)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // Allocate an SHM buffer
     // NOTE: For allocation API please check z_alloc_shm.rs example

examples/examples/z_ping_shm.rs

@@ -20,7 +20,7 @@ use zenoh::{
     prelude::*,
     qos::CongestionControl,
     shm::{PosixShmProviderBackend, ShmProviderBuilder, POSIX_PROTOCOL_ID},
-    Config,
+    Config, Wait,
 };
 use zenoh_examples::CommonArgs;
 
@@ -52,13 +52,13 @@ fn main() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(size)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // Allocate an SHM buffer
     // NOTE: For allocation API please check z_alloc_shm.rs example

examples/examples/z_posix_shm_provider.rs

@@ -11,8 +11,12 @@
 // Contributors:
 //   ZettaScale Zenoh Team, <[email protected]>
 //
-use zenoh::shm::{
-    AllocAlignment, MemoryLayout, PosixShmProviderBackend, ShmProviderBuilder, POSIX_PROTOCOL_ID,
+use zenoh::{
+    shm::{
+        AllocAlignment, MemoryLayout, PosixShmProviderBackend, ShmProviderBuilder,
+        POSIX_PROTOCOL_ID,
+    },
+    Wait,
 };
 
 fn main() {
@@ -34,13 +38,13 @@ fn main() {
         // Build a provider backend
         PosixShmProviderBackend::builder()
             .with_layout(provider_layout)
-            .res()
+            .wait()
             .unwrap()
     };
 
     // Construct an SHM provider for particular backend and POSIX_PROTOCOL_ID
     let _shm_provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 }

examples/examples/z_pub_shm.rs

@@ -18,7 +18,7 @@ use zenoh::{
     shm::{
         BlockOn, GarbageCollect, PosixShmProviderBackend, ShmProviderBuilder, POSIX_PROTOCOL_ID,
     },
-    Config,
+    Config, Wait,
 };
 use zenoh_examples::CommonArgs;
 
@@ -40,13 +40,13 @@ async fn main() -> Result<(), ZError> {
     let backend = PosixShmProviderBackend::builder()
         .with_size(N * 1024)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     let publisher = session.declare_publisher(&path).await.unwrap();
 

examples/examples/z_pub_shm_thr.rs

@@ -17,7 +17,7 @@ use zenoh::{
     prelude::*,
     qos::CongestionControl,
     shm::{PosixShmProviderBackend, ShmProviderBuilder, POSIX_PROTOCOL_ID},
-    Config,
+    Config, Wait,
 };
 use zenoh_examples::CommonArgs;
 
@@ -34,13 +34,13 @@ async fn main() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(sm_size)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // Allocate an SHM buffer
     // NOTE: For allocation API please check z_alloc_shm.rs example

examples/examples/z_queryable_shm.rs

@@ -20,7 +20,7 @@ use zenoh::{
         zshm, BlockOn, GarbageCollect, PosixShmProviderBackend, ShmProviderBuilder,
         POSIX_PROTOCOL_ID,
     },
-    Config,
+    Config, Wait,
 };
 use zenoh_examples::CommonArgs;
 
@@ -42,13 +42,13 @@ async fn main() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(N * 1024)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     println!("Declaring Queryable on '{key_expr}'...");
     let queryable = session

io/zenoh-transport/tests/unicast_shm.rs

@@ -24,7 +24,7 @@ mod tests {
     };
 
     use zenoh_buffers::buffer::SplitBuffer;
-    use zenoh_core::ztimeout;
+    use zenoh_core::{ztimeout, Wait};
     use zenoh_link::Link;
     use zenoh_protocol::{
         core::{CongestionControl, Encoding, EndPoint, Priority, WhatAmI, ZenohIdProto},
@@ -161,12 +161,12 @@ mod tests {
         let backend = PosixShmProviderBackend::builder()
             .with_size(2 * MSG_SIZE)
             .unwrap()
-            .res()
+            .wait()
             .unwrap();
         let shm01 = ShmProviderBuilder::builder()
             .protocol_id::<POSIX_PROTOCOL_ID>()
             .backend(backend)
-            .res();
+            .wait();
 
         // Create a peer manager with shared-memory authenticator enabled
         let peer_shm01_handler = Arc::new(SHPeer::new(true));

zenoh/src/api/bytes.rs

@@ -3263,8 +3263,6 @@ mod tests {
 
         use rand::Rng;
         use zenoh_buffers::{ZBuf, ZSlice};
-        #[cfg(feature = "shared-memory")]
-        use zenoh_core::Wait;
         use zenoh_protocol::core::Parameters;
         #[cfg(feature = "shared-memory")]
         use zenoh_shm::api::{
@@ -3277,6 +3275,8 @@ mod tests {
 
         use super::ZBytes;
         use crate::bytes::{Deserialize, Serialize, ZSerde};
+        #[cfg(feature = "shared-memory")]
+        use crate::zenoh_core::Wait;
 
         const NUM: usize = 1_000;
 
@@ -3439,13 +3439,13 @@ mod tests {
             let backend = PosixShmProviderBackend::builder()
                 .with_size(4096)
                 .unwrap()
-                .res()
+                .wait()
                 .unwrap();
             // ...and an SHM provider
             let provider = ShmProviderBuilder::builder()
                 .protocol_id::<POSIX_PROTOCOL_ID>()
                 .backend(backend)
-                .res();
+                .wait();
 
             // Prepare a layout for allocations
             let layout = provider.alloc(1024).into_layout().unwrap();

zenoh/tests/bytes.rs

@@ -27,13 +27,13 @@ fn shm_bytes_single_buf() {
     let backend = PosixShmProviderBackend::builder()
         .with_size(4096)
         .unwrap()
-        .res()
+        .wait()
         .unwrap();
     // ...and an SHM provider
     let provider = ShmProviderBuilder::builder()
         .protocol_id::<POSIX_PROTOCOL_ID>()
         .backend(backend)
-        .res();
+        .wait();
 
     // Prepare a layout for allocations
     let layout = provider.alloc(1024).into_layout().unwrap();

zenoh/tests/shm.rs

@@ -137,13 +137,13 @@ async fn test_session_pubsub(peer01: &Session, peer02: &Session, reliability: Re
         let backend = PosixShmProviderBackend::builder()
             .with_size(size * MSG_COUNT / 10)
             .unwrap()
-            .res()
+            .wait()
             .unwrap();
         // ...and SHM provider
         let shm01 = ShmProviderBuilder::builder()
             .protocol_id::<POSIX_PROTOCOL_ID>()
             .backend(backend)
-            .res();
+            .wait();
 
         // remember segment size that was allocated
         let shm_segment_size = shm01.available();