From 75934a1ae9ec788841eded76a56b819197e06d8f Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Fri, 18 Oct 2024 18:00:02 +0200 Subject: [PATCH 1/7] log, handler doc update --- commons/zenoh-util/src/log.rs | 12 ++++++------ zenoh/src/api/handlers/mod.rs | 10 ++++++++++ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/commons/zenoh-util/src/log.rs b/commons/zenoh-util/src/log.rs index a2e4a32e71..77d780ae90 100644 --- a/commons/zenoh-util/src/log.rs +++ b/commons/zenoh-util/src/log.rs @@ -22,13 +22,13 @@ use tracing_subscriber::{ /// A utility function to enable the tracing formatting subscriber. /// -/// The tracing formatting subscriber is initialized from the `RUST_LOG` environment variable. +/// The [`tracing_subscriber`]` is initialized from the `RUST_LOG` environment variable. /// If `RUST_LOG` is not set, then logging is not enabled. /// /// # Safety /// -/// Calling this function initializes a `lazy_static` in the `tracing` crate -/// such static is not deallocated prior to process existing, thus tools such as `valgrind` +/// Calling this function initializes a `lazy_static` in the [`tracing`] crate. +/// Such static is not deallocated prior to process exiting, thus tools such as `valgrind` /// will report a memory leak. /// Refer to this issue: pub fn try_init_log_from_env() { @@ -39,12 +39,12 @@ pub fn try_init_log_from_env() { /// A utility function to enable the tracing formatting subscriber. /// -/// The tracing formatting subscriber is initialized from the `RUST_LOG` environment variable. +/// The [`tracing_subscriber`] is initialized from the `RUST_LOG` environment variable. /// If `RUST_LOG` is not set, then fallback directives are used. /// /// # Safety -/// Calling this function initializes a `lazy_static` in the `tracing` crate -/// such static is not deallocated prior to process existing, thus tools such as `valgrind` +/// Calling this function initializes a `lazy_static` in the [`tracing`] crate. +/// Such static is not deallocated prior to process existing, thus tools such as `valgrind` /// will report a memory leak. /// Refer to this issue: pub fn init_log_from_env_or(fallback: S) diff --git a/zenoh/src/api/handlers/mod.rs b/zenoh/src/api/handlers/mod.rs index e4a706f172..58710a7a53 100644 --- a/zenoh/src/api/handlers/mod.rs +++ b/zenoh/src/api/handlers/mod.rs @@ -13,6 +13,16 @@ // //! Callback handler trait. +//! +//! The zenoh primitives which receive data (e.g. [`Subscriber`](crate::pubsub::Subscriber), [`Query`](crate::query::Query), etc.) accept in their [`with()`](crate::pubsub::SubscriberBuilder::with) method a handler +//! which processes received message. The handler is actually a pair of a [`Callback`] and a handler. The callback is called on each received message, the handler is an object of arbitrary type, which can be used to access +//! the data received by callback. When the handler is not needed, the handler type can be `()`. This particular case is handled by the [`callback()`](crate::pubsub::SubscriberBuilder::callback) method which directly accepts a `Fn(T)`. +//! +//! The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that implements the [`IntoHandler`] trait which in turn provides a conversion to a pair of [`Callback`] and handler. +//! +//! The channels [`FifoChannel`] and [`RingChannel`] provided by zenoh implements the [`IntoHandler`] trait which returns a pair of [`Callback`] which pushes the data to the channel and the receiving channel's end [`FifoChannelHandler`] or [`RingChannelHandler`] +//! correspondingly. This receiving end is stored in the constructed zenoh object (e.g[`Subscriber`](crate::pubsub::Subscriber)) and its methods can be accessed directly on this object, as it implements the +//! [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut) traits for the handler type. mod callback; mod fifo; mod ring; From 241c4f6960592bf10da2c2a672d6b321425d50b9 Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sat, 19 Oct 2024 17:17:18 +0200 Subject: [PATCH 2/7] bytes mod doc added --- zenoh/src/lib.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index 0443560661..89cf79f8ad 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -216,6 +216,16 @@ pub mod sample { } /// Payload primitives +/// +/// The [`ZBytes`](crate::bytes::ZBytes) type is Zenoh's representation of raw byte data. +/// It provides mechanisms for zero-copy creation (by implementing `From>`) +/// and access ([`ZBytes::slices`](crate::bytes::ZBytes::slices)), as well as methods for sequential +/// reading/writing ([`ZBytes::reader`](crate::bytes::ZBytes::reader), [`ZBytes::writer`](crate::bytes::ZBytes::writer)). +/// +/// There is also basic types serialization provided by the `zenoh_ext` crate: +/// [`z_serialize`](../../zenoh_ext/fn.z_serialize.html) / +/// [`z_deserialize`](../../zenoh_ext/fn.z_deserialize.html). + pub mod bytes { pub use crate::api::{ bytes::{OptionZBytes, ZBytes, ZBytesReader, ZBytesSliceIterator, ZBytesWriter}, From 29172e323b08fd7d0cff22dfe5e0d4d83a0f5bc1 Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sat, 19 Oct 2024 17:20:31 +0200 Subject: [PATCH 3/7] callback doc moved to lib.rs --- zenoh/src/api/handlers/mod.rs | 11 ----------- zenoh/src/lib.rs | 19 +++++++++++++++---- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/zenoh/src/api/handlers/mod.rs b/zenoh/src/api/handlers/mod.rs index 58710a7a53..4ffa895c78 100644 --- a/zenoh/src/api/handlers/mod.rs +++ b/zenoh/src/api/handlers/mod.rs @@ -12,17 +12,6 @@ // ZettaScale Zenoh Team, // -//! Callback handler trait. -//! -//! The zenoh primitives which receive data (e.g. [`Subscriber`](crate::pubsub::Subscriber), [`Query`](crate::query::Query), etc.) accept in their [`with()`](crate::pubsub::SubscriberBuilder::with) method a handler -//! which processes received message. The handler is actually a pair of a [`Callback`] and a handler. The callback is called on each received message, the handler is an object of arbitrary type, which can be used to access -//! the data received by callback. When the handler is not needed, the handler type can be `()`. This particular case is handled by the [`callback()`](crate::pubsub::SubscriberBuilder::callback) method which directly accepts a `Fn(T)`. -//! -//! The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that implements the [`IntoHandler`] trait which in turn provides a conversion to a pair of [`Callback`] and handler. -//! -//! The channels [`FifoChannel`] and [`RingChannel`] provided by zenoh implements the [`IntoHandler`] trait which returns a pair of [`Callback`] which pushes the data to the channel and the receiving channel's end [`FifoChannelHandler`] or [`RingChannelHandler`] -//! correspondingly. This receiving end is stored in the constructed zenoh object (e.g[`Subscriber`](crate::pubsub::Subscriber)) and its methods can be accessed directly on this object, as it implements the -//! [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut) traits for the handler type. mod callback; mod fifo; mod ring; diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index 89cf79f8ad..a00b71330b 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -216,14 +216,14 @@ pub mod sample { } /// Payload primitives -/// +/// /// The [`ZBytes`](crate::bytes::ZBytes) type is Zenoh's representation of raw byte data. /// It provides mechanisms for zero-copy creation (by implementing `From>`) /// and access ([`ZBytes::slices`](crate::bytes::ZBytes::slices)), as well as methods for sequential /// reading/writing ([`ZBytes::reader`](crate::bytes::ZBytes::reader), [`ZBytes::writer`](crate::bytes::ZBytes::writer)). -/// +/// /// There is also basic types serialization provided by the `zenoh_ext` crate: -/// [`z_serialize`](../../zenoh_ext/fn.z_serialize.html) / +/// [`z_serialize`](../../zenoh_ext/fn.z_serialize.html) / /// [`z_deserialize`](../../zenoh_ext/fn.z_deserialize.html). pub mod bytes { @@ -274,7 +274,18 @@ pub mod query { pub use crate::api::{query::ReplyKeyExpr, selector::ZenohParameters}; } -/// Callback handler trait +/// Callback handler trait. +/// +/// The zenoh primitives which receive data (e.g. [`Subscriber`](crate::pubsub::Subscriber), [`Query`](crate::query::Query), etc.) accept in their [`with()`](crate::pubsub::SubscriberBuilder::with) method a handler +/// which processes received message. The handler is actually a pair of a [`Callback`] and a handler. The callback is called on each received message, the handler is an object of arbitrary type, which can be used to access +/// the data received by callback. When the handler is not needed, the handler type can be `()`. This particular case is handled by the [`callback()`](crate::pubsub::SubscriberBuilder::callback) method which directly accepts a `Fn(T)`. +/// +/// The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that implements the [`IntoHandler`] trait which in turn provides a conversion to a pair of [`Callback`] and handler. +/// +/// The channels [`FifoChannel`] and [`RingChannel`] provided by zenoh implements the [`IntoHandler`] trait which returns a pair of [`Callback`] which pushes the data to the channel and the receiving channel's end [`FifoChannelHandler`] or [`RingChannelHandler`] +/// correspondingly. This receiving end is stored in the constructed zenoh object (e.g[`Subscriber`](crate::pubsub::Subscriber)) and its methods can be accessed directly on this object, as it implements the +/// [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut) traits for the handler type. + pub mod handlers { #[zenoh_macros::internal] pub use crate::api::handlers::locked; From 4d3cf992f91cd96f32d96bff2a7a3929d96fbf92 Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sat, 19 Oct 2024 17:25:33 +0200 Subject: [PATCH 4/7] absloute paths added --- zenoh/src/lib.rs | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index a00b71330b..cfc8152d1e 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -276,16 +276,28 @@ pub mod query { /// Callback handler trait. /// -/// The zenoh primitives which receive data (e.g. [`Subscriber`](crate::pubsub::Subscriber), [`Query`](crate::query::Query), etc.) accept in their [`with()`](crate::pubsub::SubscriberBuilder::with) method a handler -/// which processes received message. The handler is actually a pair of a [`Callback`] and a handler. The callback is called on each received message, the handler is an object of arbitrary type, which can be used to access -/// the data received by callback. When the handler is not needed, the handler type can be `()`. This particular case is handled by the [`callback()`](crate::pubsub::SubscriberBuilder::callback) method which directly accepts a `Fn(T)`. +/// Zenoh primitives that receive data (e.g., [`Subscriber`](crate::pubsub::Subscriber), +/// [`Query`](crate::query::Query), etc.) accept a handler in their +/// [`with()`](crate::pubsub::SubscriberBuilder::with) method to process received messages. +/// The handler is a pair of a [`Callback`](crate::handlers::Callback) and an arbitrary type +/// object used to access data received by the callback. When the handler is not needed, +/// the handler type can be `()`. This case is handled by the +/// [`callback()`](crate::pubsub::SubscriberBuilder::callback) method, which directly accepts +/// a `Fn(T)`. /// -/// The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that implements the [`IntoHandler`] trait which in turn provides a conversion to a pair of [`Callback`] and handler. +/// The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that +/// implements the [`IntoHandler`](crate::handlers::IntoHandler) trait, which provides a +/// conversion to a pair of [`Callback`](crate::handlers::Callback) and handler. /// -/// The channels [`FifoChannel`] and [`RingChannel`] provided by zenoh implements the [`IntoHandler`] trait which returns a pair of [`Callback`] which pushes the data to the channel and the receiving channel's end [`FifoChannelHandler`] or [`RingChannelHandler`] -/// correspondingly. This receiving end is stored in the constructed zenoh object (e.g[`Subscriber`](crate::pubsub::Subscriber)) and its methods can be accessed directly on this object, as it implements the +/// The channels [`FifoChannel`](crate::handlers::FifoChannel) and +/// [`RingChannel`](crate::handlers::RingChannel) implement the +/// [`IntoHandler`](crate::handlers::IntoHandler) trait, returning a pair of +/// [`Callback`](crate::handlers::Callback) that pushes data to the channel and the receiving +/// channel's end [`FifoChannelHandler`](crate::handlers::FifoChannelHandler) or +/// [`RingChannelHandler`](crate::handlers::RingChannelHandler). This receiving end is stored +/// in the constructed Zenoh object (e.g., [`Subscriber`](crate::pubsub::Subscriber)), and its +/// methods can be accessed directly on this object, as it implements the /// [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut) traits for the handler type. - pub mod handlers { #[zenoh_macros::internal] pub use crate::api::handlers::locked; From e98e105d5856e5581a3068f756852a37c7173ad7 Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sat, 19 Oct 2024 17:27:59 +0200 Subject: [PATCH 5/7] minor corrections --- zenoh/src/lib.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index cfc8152d1e..57a4147d5a 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -278,14 +278,14 @@ pub mod query { /// /// Zenoh primitives that receive data (e.g., [`Subscriber`](crate::pubsub::Subscriber), /// [`Query`](crate::query::Query), etc.) accept a handler in their -/// [`with()`](crate::pubsub::SubscriberBuilder::with) method to process received messages. +/// [`with`](crate::pubsub::SubscriberBuilder::with) method to process received messages. /// The handler is a pair of a [`Callback`](crate::handlers::Callback) and an arbitrary type /// object used to access data received by the callback. When the handler is not needed, -/// the handler type can be `()`. This case is handled by the -/// [`callback()`](crate::pubsub::SubscriberBuilder::callback) method, which directly accepts +/// the handler type can be `()`. For convenience, this case is specailly handled by the +/// [`callback`](crate::pubsub::SubscriberBuilder::callback) method, which directly accepts /// a `Fn(T)`. /// -/// The [`with()`](crate::pubsub::SubscriberBuilder::with) method accepts any type that +/// The [`with`](crate::pubsub::SubscriberBuilder::with) method accepts any type that /// implements the [`IntoHandler`](crate::handlers::IntoHandler) trait, which provides a /// conversion to a pair of [`Callback`](crate::handlers::Callback) and handler. /// From 6615c5a7843fd7fed1c6c89459652dae192a7253 Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sun, 20 Oct 2024 01:27:07 +0200 Subject: [PATCH 6/7] modules doc update --- zenoh/src/lib.rs | 87 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 63 insertions(+), 24 deletions(-) diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index 57a4147d5a..90a4fdc06a 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -180,6 +180,8 @@ pub mod key_expr { } /// Zenoh [`Session`] and associated types +/// +/// The [`Session`] is the main component of the Zenoh. pub mod session { #[zenoh_macros::unstable] pub use zenoh_config::wrappers::EntityGlobalId; @@ -202,6 +204,9 @@ pub mod session { } /// Sample primitives +/// +/// The [`Sample`](crate::sample::Sample) structure is the data unit received from [`Subscriber`](crate::pubsub::Subscriber) +/// or [`Queryable`](crate::query::Queryable) instances. It contains the payload and all the metadata associated with the data. pub mod sample { #[zenoh_macros::unstable] pub use crate::api::sample::Locality; @@ -218,11 +223,11 @@ pub mod sample { /// Payload primitives /// /// The [`ZBytes`](crate::bytes::ZBytes) type is Zenoh's representation of raw byte data. -/// It provides mechanisms for zero-copy creation (by implementing `From>`) -/// and access ([`ZBytes::slices`](crate::bytes::ZBytes::slices)), as well as methods for sequential +/// It provides mechanisms for zero-copy creation and access (`From>` and +/// [`ZBytes::slices`](crate::bytes::ZBytes::slices)), as well as methods for sequential /// reading/writing ([`ZBytes::reader`](crate::bytes::ZBytes::reader), [`ZBytes::writer`](crate::bytes::ZBytes::writer)). /// -/// There is also basic types serialization provided by the `zenoh_ext` crate: +/// The`zenoh_ext` crate provides serialization and deserialization of basic types and structures for `ZBytes` /// [`z_serialize`](../../zenoh_ext/fn.z_serialize.html) / /// [`z_deserialize`](../../zenoh_ext/fn.z_deserialize.html). @@ -234,6 +239,14 @@ pub mod bytes { } /// Pub/sub primitives +/// +/// The [`Publisher`](crate::pubsub::Publisher) instance is declared by a +/// [`Session::declare_publisher`](crate::Session::declare_publisher) method. +/// +/// The data [`Sample`](crate::sample::Sample)s +/// are received by [`Subscriber`](crate::pubsub::Subscriber)s +/// declared by a [`Session::declare_subscriber`](crate::Session::declare_subscriber) +/// pub mod pubsub { #[zenoh_macros::unstable] pub use crate::api::{ @@ -254,6 +267,12 @@ pub mod pubsub { } /// Query/reply primitives +/// +/// The [`Queryable`](crate::query::Queryable) instance is declared by a +/// [`Session::declare_queryable`](crate::Session::declare_queryable) method. +/// It is requested by a [`Session::get`](crate::Session::get) operation which +/// receives data in [`Reply`](crate::query::Reply) structures. +/// pub mod query { pub use zenoh_protocol::core::Parameters; #[zenoh_macros::unstable] @@ -276,28 +295,33 @@ pub mod query { /// Callback handler trait. /// -/// Zenoh primitives that receive data (e.g., [`Subscriber`](crate::pubsub::Subscriber), -/// [`Query`](crate::query::Query), etc.) accept a handler in their -/// [`with`](crate::pubsub::SubscriberBuilder::with) method to process received messages. -/// The handler is a pair of a [`Callback`](crate::handlers::Callback) and an arbitrary type -/// object used to access data received by the callback. When the handler is not needed, -/// the handler type can be `()`. For convenience, this case is specailly handled by the -/// [`callback`](crate::pubsub::SubscriberBuilder::callback) method, which directly accepts -/// a `Fn(T)`. -/// -/// The [`with`](crate::pubsub::SubscriberBuilder::with) method accepts any type that -/// implements the [`IntoHandler`](crate::handlers::IntoHandler) trait, which provides a +/// Zenoh primitives that receive data (e.g., [`Subscriber`](crate::pubsub::Subscriber), +/// [`Query`](crate::query::Query), etc.) have a +/// [`with`](crate::pubsub::SubscriberBuilder::with) method which accepts a handler for the data. +/// +/// The handler is a pair of a [`Callback`](crate::handlers::Callback) and an arbitrary `Handler` +/// object used to access data received by the callback. When the data is processed by the callback itself +/// the handler type can be `()`. For convenience, the +/// [`callback`](crate::pubsub::SubscriberBuilder::callback) method, which accepts +/// a `Fn(T)` only can be used in this case. +/// +/// The [`with`](crate::pubsub::SubscriberBuilder::with) method accepts any type that +/// implements the [`IntoHandler`](crate::handlers::IntoHandler) trait, which provides a /// conversion to a pair of [`Callback`](crate::handlers::Callback) and handler. /// -/// The channels [`FifoChannel`](crate::handlers::FifoChannel) and -/// [`RingChannel`](crate::handlers::RingChannel) implement the -/// [`IntoHandler`](crate::handlers::IntoHandler) trait, returning a pair of -/// [`Callback`](crate::handlers::Callback) that pushes data to the channel and the receiving -/// channel's end [`FifoChannelHandler`](crate::handlers::FifoChannelHandler) or -/// [`RingChannelHandler`](crate::handlers::RingChannelHandler). This receiving end is stored -/// in the constructed Zenoh object (e.g., [`Subscriber`](crate::pubsub::Subscriber)), and its -/// methods can be accessed directly on this object, as it implements the -/// [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut) traits for the handler type. +/// The `IntoHander` for channels [`FifoChannel`](crate::handlers::FifoChannel) and +/// [`RingChannel`](crate::handlers::RingChannel) +/// return a pair of ([`Callback`](crate::handlers::Callback), channel_handler). +/// +/// The callback pushes data to the channel, the +/// channel handler [`FifoChannelHandler`](crate::handlers::FifoChannelHandler) or +/// [`RingChannelHandler`](crate::handlers::RingChannelHandler) allows to take data +/// from the channel. +/// +/// The channel handler is stored +/// in the Zenoh object (e.g., [`Subscriber`](crate::pubsub::Subscriber)). It can be accessed +/// by [`handler`](crate::pubsub::Subscriber::handler) method or just directly by dereferencing the +/// Zenoh object. pub mod handlers { #[zenoh_macros::internal] pub use crate::api::handlers::locked; @@ -322,6 +346,11 @@ pub mod qos { } /// Scouting primitives +/// +/// Scouting is the prosess of discovering Zenoh nodes in the network. +/// The scouting process depends on the transport layer and on the zenoh configuration. +/// See more details at . +/// pub mod scouting { pub use zenoh_config::wrappers::Hello; @@ -395,7 +424,17 @@ pub mod time { pub use zenoh_protocol::core::{Timestamp, TimestampId, NTP64}; } -/// Configuration to pass to [`open`] and [`scout`] functions and associated constants +/// Configuration to pass to [`open`] and [`scout`] functions and associated constants. +/// +/// The zenoh configurattion is stored in a JSON file. The [`Config`] can be constructed from it using +/// the corresponding `from_...` methods. It's also possible to read or +/// modify individual elements of the [`Config`] with [`Config::insert_json5`](crate::config::Config::insert_json5) +/// and [`Config::get_json`](crate::config::Config::get_json) methods. +/// +/// The example of the configuration file is +/// [available](https://github.com/eclipse-zenoh/zenoh/blob/release/1.0.0/DEFAULT_CONFIG.json5) +/// in the zenoh repository. +/// pub mod config { pub use zenoh_config::{EndPoint, Locator, WhatAmI, WhatAmIMatcher, ZenohId}; From 3486b9496868a010fd95789fa4fa365b68691b3d Mon Sep 17 00:00:00 2001 From: Michael Ilyin Date: Sun, 20 Oct 2024 01:31:32 +0200 Subject: [PATCH 7/7] typo fixes --- zenoh/src/api/handlers/mod.rs | 1 + zenoh/src/lib.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/zenoh/src/api/handlers/mod.rs b/zenoh/src/api/handlers/mod.rs index 4ffa895c78..e4a706f172 100644 --- a/zenoh/src/api/handlers/mod.rs +++ b/zenoh/src/api/handlers/mod.rs @@ -12,6 +12,7 @@ // ZettaScale Zenoh Team, // +//! Callback handler trait. mod callback; mod fifo; mod ring; diff --git a/zenoh/src/lib.rs b/zenoh/src/lib.rs index 90a4fdc06a..701e13fc94 100644 --- a/zenoh/src/lib.rs +++ b/zenoh/src/lib.rs @@ -309,7 +309,7 @@ pub mod query { /// implements the [`IntoHandler`](crate::handlers::IntoHandler) trait, which provides a /// conversion to a pair of [`Callback`](crate::handlers::Callback) and handler. /// -/// The `IntoHander` for channels [`FifoChannel`](crate::handlers::FifoChannel) and +/// The `IntoHandler` for channels [`FifoChannel`](crate::handlers::FifoChannel) and /// [`RingChannel`](crate::handlers::RingChannel) /// return a pair of ([`Callback`](crate::handlers::Callback), channel_handler). /// @@ -347,7 +347,7 @@ pub mod qos { /// Scouting primitives /// -/// Scouting is the prosess of discovering Zenoh nodes in the network. +/// Scouting is the process of discovering Zenoh nodes in the network. /// The scouting process depends on the transport layer and on the zenoh configuration. /// See more details at . ///