[#429] Fixed all clippy warnings

Author: elfenpiff

iceoryx2-ffi/ffi/src/api/subscriber.rs

@@ -19,7 +19,7 @@ use crate::api::{
 };
 
 use iceoryx2::port::subscriber::Subscriber;
-use iceoryx2::port::update_connections::{ConnectionFailure, UpdateConnections};
+use iceoryx2::port::update_connections::ConnectionFailure;
 use iceoryx2::port::ReceiveError;
 use iceoryx2::prelude::*;
 use iceoryx2_bb_elementary::static_assert::*;

iceoryx2/src/port/details/sender.rs

@@ -211,19 +211,6 @@ impl<Service: service::Service> Sender<Service> {
         Ok(number_of_recipients)
     }
 
-    pub(crate) fn set_channel_state(
-        &self,
-        channel_id: ChannelId,
-        connection_id: usize,
-        state: u64,
-    ) -> bool {
-        if let Some(ref connection) = self.get(connection_id) {
-            connection.sender.set_channel_state(channel_id, state)
-        } else {
-            false
-        }
-    }
-
     pub(crate) fn has_channel_state(
         &self,
         channel_id: ChannelId,

iceoryx2/src/port/server.rs

@@ -408,37 +408,33 @@ impl<
                         &*(chunk.header as *const service::header::request_response::RequestHeader)
                     };
 
-                    match self
+                    if let Some(connection_id) = self
                         .shared_state
                         .response_sender
                         .get_connection_id_of(header.client_port_id.value())
                     {
-                        Some(connection_id) => {
-                            let active_request = ActiveRequest {
-                                details,
-                                request_id: header.request_id,
-                                channel_id: header.channel_id,
-                                connection_id,
-                                shared_state: self.shared_state.clone(),
-                                ptr: unsafe {
-                                    RawSample::new_unchecked(
-                                        chunk.header.cast(),
-                                        chunk.user_header.cast(),
-                                        chunk.payload.cast::<RequestPayload>(),
-                                    )
-                                },
-                                _response_payload: PhantomData,
-                                _response_header: PhantomData,
-                            };
-
-                            if !self.allow_fire_and_forget && !active_request.is_connected() {
-                                continue;
-                            }
-
-                            return Ok(Some(active_request));
+                        let active_request = ActiveRequest {
+                            details,
+                            request_id: header.request_id,
+                            channel_id: header.channel_id,
+                            connection_id,
+                            shared_state: self.shared_state.clone(),
+                            ptr: unsafe {
+                                RawSample::new_unchecked(
+                                    chunk.header.cast(),
+                                    chunk.user_header.cast(),
+                                    chunk.payload.cast::<RequestPayload>(),
+                                )
+                            },
+                            _response_payload: PhantomData,
+                            _response_header: PhantomData,
+                        };
+
+                        if !self.allow_fire_and_forget && !active_request.is_connected() {
+                            continue;
                         }
 
-                        None => (),
+                        return Ok(Some(active_request));
                     }
                 }
                 None => return Ok(None),

iceoryx2/src/request_mut.rs

@@ -89,9 +89,8 @@ impl<
     > Drop for RequestMut<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>
 {
     fn drop(&mut self) {
-        if unsafe { &mut *self.client_shared_state.available_channel_ids.get() }
+        if !unsafe { &mut *self.client_shared_state.available_channel_ids.get() }
             .push(self.header().channel_id)
-            == false
         {
             fatal_panic!(from self,
                     "This should never happen! The channel id could not be returned.");

iceoryx2/src/response.rs

@@ -10,6 +10,34 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+//! # Example
+//!
+//! ## Typed API
+//!
+//! ```
+//! use iceoryx2::prelude::*;
+//! # fn main() -> Result<(), Box<dyn core::error::Error>> {
+//! # let node = NodeBuilder::new().create::<ipc::Service>()?;
+//! #
+//! # let service = node.service_builder(&"My/Funk/ServiceName".try_into()?)
+//! #     .request_response::<u64, u64>()
+//! #     .open_or_create()?;
+//! #
+//! let client = service.client_builder().create()?;
+//! # let server = service.server_builder().create()?;
+//! let pending_response = client.send_copy(0)?;
+//! # let active_request = server.receive()?.unwrap();
+//! # active_request.send_copy(0)?;
+//!
+//! if let Some(response) = pending_response.receive()? {
+//!     println!("received response: {} from: {}",
+//!         response.payload(), response.header().server_id());
+//! }
+//!
+//! # Ok(())
+//! # }
+//! ```
+
 use core::fmt::Debug;
 use core::ops::Deref;
 
@@ -22,6 +50,10 @@ use crate::port::port_identifiers::UniqueServerId;
 use crate::raw_sample::RawSample;
 use crate::service;
 
+/// It stores the payload and can be received by the
+/// [`PendingResponse`](crate::pending_response::PendingResponse) after a
+/// [`RequestMut`](crate::request_mut::RequestMut) was sent to a
+/// [`Server`](crate::port::server::Server) via the [`Client`](crate::port::client::Client).
 pub struct Response<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug>
 {
     pub(crate) ptr: RawSample<
@@ -85,18 +117,24 @@ impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: D
 impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug>
     Response<Service, ResponsePayload, ResponseHeader>
 {
+    /// Returns a reference to the
+    /// [`ResponseHeader`](service::header::request_response::ResponseHeader).
     pub fn header(&self) -> &service::header::request_response::ResponseHeader {
         self.ptr.as_header_ref()
     }
 
+    /// Returns a reference to the user header of the response.
     pub fn user_header(&self) -> &ResponseHeader {
         self.ptr.as_user_header_ref()
     }
 
+    /// Returns a reference to the payload of the response.
     pub fn payload(&self) -> &ResponsePayload {
         self.ptr.as_payload_ref()
     }
 
+    /// Returns the [`UniqueServerId`] of the [`Server`](crate::port::server::Server) which sent
+    /// the [`Response`].
     pub fn origin(&self) -> UniqueServerId {
         UniqueServerId(UniqueSystemId::from(self.details.origin))
     }

iceoryx2/src/response_mut.rs

@@ -39,12 +39,14 @@
 //! # }
 //! ```
 
+extern crate alloc;
+
+use alloc::sync::Arc;
 use core::{
     fmt::Debug,
     marker::PhantomData,
     ops::{Deref, DerefMut},
 };
-use std::sync::Arc;
 
 use iceoryx2_bb_log::fail;
 use iceoryx2_cal::{shm_allocator::PointerOffset, zero_copy_connection::ChannelId};
@@ -82,7 +84,7 @@ pub struct ResponseMut<Service: service::Service, ResponsePayload: Debug, Respon
 impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug> Debug
     for ResponseMut<Service, ResponsePayload, ResponseHeader>
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "ResponseMut<{}, {}, {}> {{ ptr: {:?}, offset_to_chunk: {:?}, sample_size: {}, channel_id: {} }}",
@@ -127,7 +129,8 @@ impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: D
 impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug>
     ResponseMut<Service, ResponsePayload, ResponseHeader>
 {
-    /// Returns a reference to the header of the response.
+    /// Returns a reference to the
+    /// [`ResponseHeader`](service::header::request_response::ResponseHeader).
     ///
     /// ```
     /// use iceoryx2::prelude::*;

iceoryx2/src/response_mut_uninit.rs

@@ -66,15 +66,16 @@ pub struct ResponseMutUninit<
 impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug> Debug
     for ResponseMutUninit<Service, ResponsePayload, ResponseHeader>
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "ResponseMut {{ response: {:?} }}", self.response)
     }
 }
 
 impl<Service: crate::service::Service, ResponsePayload: Debug, ResponseHeader: Debug>
     ResponseMutUninit<Service, ResponsePayload, ResponseHeader>
 {
-    /// Returns a reference to the header of the response.
+    /// Returns a reference to the
+    /// [`ResponseHeader`](service::header::request_response::ResponseHeader).
     ///
     /// ```
     /// use iceoryx2::prelude::*;