SHM mutation

examples/zenohc/z_queryable_shm.cxx

@@ -54,9 +54,7 @@ int _main(int argc, char **argv) {
 
         const char *payload_type = "";
         if (query_payload.has_value()) {
-            ZResult result;
-            query_payload->get().as_shm(&result);
-            if (result == Z_OK) {
+            if (query_payload->get().as_shm().has_value()) {
                 payload_type = "SHM";
             } else {
                 payload_type = "RAW";

examples/zenohc/z_sub_shm.cxx

@@ -34,7 +34,7 @@ const char *kind_to_str(SampleKind kind) {
     }
 }
 
-void data_handler(const Sample &sample) {
+void data_handler(Sample &sample) {
 // if Zenoh is built without SHM support, the only buffer type it can receive is RAW
 #if !defined(Z_FEATURE_SHARED_MEMORY)
     const char *payload_type = "RAW";
@@ -50,10 +50,12 @@ void data_handler(const Sample &sample) {
 #if defined(Z_FEATURE_SHARED_MEMORY) && defined(Z_FEATURE_UNSTABLE_API)
     const char *payload_type = "RAW";
     {
-        ZResult result;
-        sample.get_payload().as_shm(&result);
-        if (result == Z_OK) {
-            payload_type = "SHM";
+        // try to convert sample payload into SHM buffer. The conversion will succeed
+        // only if payload is carrying underlying SHM buffer
+        auto shm = sample.get_payload().as_shm();
+        if (shm.has_value()) {
+            // try to get mutable access to SHM buffer
+            payload_type = ZShm::try_mutate(shm.value()).has_value() ? "SHM (MUT)" : "SHM (IMMUT)";
         }
     }
 #endif

include/zenoh/api/bytes.hxx

@@ -145,11 +145,21 @@ class Bytes : public Owned<::z_owned_bytes_t> {
 #if (defined(Z_FEATURE_SHARED_MEMORY) && defined(Z_FEATURE_UNSTABLE_API))
     /// @warning This API has been marked as unstable: it works as advertised, but it may be changed in a future
     /// release.
-    ZShm as_shm(ZResult* err = nullptr) const {
-        ZShm shm = interop::detail::null<ZShm>();
-        __ZENOH_RESULT_CHECK(::z_bytes_to_owned_shm(interop::as_loaned_c_ptr(*this), interop::as_owned_c_ptr(shm)), err,
-                             "Failed to deserialize into ZShm!");
-        return shm;
+    std::optional<std::reference_wrapper<const ZShm>> as_shm() const {
+        const z_loaned_shm_t* shm;
+        if (::z_bytes_as_loaned_shm(interop::as_loaned_c_ptr(*this), &shm) != Z_OK) {
+            return std::nullopt;
+        }
+        return std::cref(interop::as_owned_cpp_ref<const ZShm>(shm));
+    }
+    /// @warning This API has been marked as unstable: it works as advertised, but it may be changed in a future
+    /// release.
+    std::optional<std::reference_wrapper<ZShm>> as_shm() {
+        z_loaned_shm_t* shm;
+        if (::z_bytes_as_mut_loaned_shm(interop::as_loaned_c_ptr(*this), &shm) != Z_OK) {
+            return std::nullopt;
+        }
+        return std::ref(interop::as_owned_cpp_ref<ZShm>(shm));
     }
 #endif
 

include/zenoh/api/query.hxx

@@ -61,6 +61,15 @@ class Query : public Owned<::z_owned_query_t> {
         if (payload == nullptr) return {};
         return std::cref(interop::as_owned_cpp_ref<Bytes>(payload));
     }
+#if defined(ZENOHCXX_ZENOHC)
+    /// @brief Get the payload of the query.
+    /// @return payload of the query.
+    std::optional<std::reference_wrapper<Bytes>> get_payload() {
+        auto payload = ::z_query_payload_mut(interop::as_loaned_c_ptr(*this));
+        if (payload == nullptr) return {};
+        return std::ref(interop::as_owned_cpp_ref<Bytes>(payload));
+    }
+#endif
 
     /// @brief Get the encoding of the query.
     /// @return encoding of the query.

include/zenoh/api/reply.hxx

@@ -33,6 +33,13 @@ class ReplyError : public Owned<::z_owned_reply_err_t> {
     const Bytes& get_payload() const {
         return interop::as_owned_cpp_ref<Bytes>(::z_reply_err_payload(interop::as_loaned_c_ptr(*this)));
     }
+#if defined(ZENOHCXX_ZENOHC)
+    /// @brief The payload of this error.
+    /// @return error payload.
+    Bytes& get_payload() {
+        return interop::as_owned_cpp_ref<Bytes>(::z_reply_err_payload_mut(interop::as_loaned_c_ptr(*this)));
+    }
+#endif
 
     /// @brief The encoding of this error.
     /// @return error encoding.

include/zenoh/api/sample.hxx

@@ -48,6 +48,13 @@ class Sample : public Owned<::z_owned_sample_t> {
     const Bytes& get_payload() const {
         return interop::as_owned_cpp_ref<Bytes>(::z_sample_payload(interop::as_loaned_c_ptr(*this)));
     }
+#if defined(ZENOHCXX_ZENOHC)
+    /// @brief Get the data of this sample.
+    /// @return ``Bytes`` object representing the sample payload.
+    Bytes& get_payload() {
+        return interop::as_owned_cpp_ref<Bytes>(::z_sample_payload_mut(interop::as_loaned_c_ptr(*this)));
+    }
+#endif
 
     /// @brief Get the encoding of the data of this sample.
     /// @return ``Encoding`` object.

include/zenoh/api/session.hxx

@@ -433,14 +433,14 @@ class Session : public Owned<::z_owned_session_t> {
                                                       SubscriberOptions&& options = SubscriberOptions::create_default(),
                                                       ZResult* err = nullptr) const {
         static_assert(
-            std::is_invocable_r<void, C, const Sample&>::value,
+            std::is_invocable_r<void, C, Sample&>::value,
             "on_sample should be callable with the following signature: void on_sample(zenoh::Sample& sample)");
         static_assert(std::is_invocable_r<void, D>::value,
                       "on_drop should be callable with the following signature: void on_drop()");
         ::z_owned_closure_sample_t c_closure;
         using Cval = std::remove_reference_t<C>;
         using Dval = std::remove_reference_t<D>;
-        using ClosureType = typename detail::closures::Closure<Cval, Dval, void, const Sample&>;
+        using ClosureType = typename detail::closures::Closure<Cval, Dval, void, Sample&>;
         auto closure = ClosureType::into_context(std::forward<C>(on_sample), std::forward<D>(on_drop));
         ::z_closure(&c_closure, detail::closures::_zenoh_on_sample_call, detail::closures::_zenoh_on_drop, closure);
         ::z_subscriber_options_t opts;

include/zenoh/api/shm/buffer/zshm.hxx

@@ -60,6 +60,16 @@ class ZShm : public Owned<::z_owned_shm_t> {
         }
         return std::nullopt;
     }
+
+    /// @brief Create a new ZShmMut& from ZShm&.
+    /// @param immut immutable buffer, NOTE: the value will not be moved if nullopt returned.
+    /// @return mutable buffer or empty option if buffer mutation is impossible.
+    static std::optional<std::reference_wrapper<ZShmMut>> try_mutate(ZShm& immut) {
+        if (z_loaned_shm_mut_t* shm_mut = ::z_shm_try_reloan_mut(z_loan_mut(immut._0))) {
+            return std::ref(interop::as_owned_cpp_ref<ZShmMut>(shm_mut));
+        }
+        return std::nullopt;
+    }
 };
 
 }  // end of namespace zenoh