Merge pull request #581 from elBoberido/iox-579-use-core-instead-of-std

[#579] [#581] Use 'core' and 'alloc' instead of 'std'

benchmarks/event/src/main.rs

@@ -93,7 +93,7 @@ fn perform_benchmark<T: Service>(args: &Args) {
     let stop = start.elapsed().expect("failed to measure time");
     println!(
         "{} ::: MaxEventId: {}, Iterations: {}, Time: {} s, Latency: {} ns",
-        std::any::type_name::<T>(),
+        core::any::type_name::<T>(),
         args.max_event_id,
         args.iterations,
         stop.as_secs_f64(),

benchmarks/publish-subscribe/src/main.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use std::mem::MaybeUninit;
+use core::mem::MaybeUninit;
 
 use clap::Parser;
 use iceoryx2::prelude::*;
@@ -138,7 +138,7 @@ fn perform_benchmark<T: Service>(args: &Args) -> Result<(), Box<dyn std::error::
     let stop = start.elapsed().expect("failed to measure time");
     println!(
         "{} ::: Iterations: {}, Time: {} s, Latency: {} ns, Sample Size: {}",
-        std::any::type_name::<T>(),
+        core::any::type_name::<T>(),
         args.iterations,
         stop.as_secs_f64(),
         stop.as_nanos() / (args.iterations as u128 * 2),

clippy.toml

@@ -1,16 +1,16 @@
 disallowed-types = [
-    "std::sync::atomic::AtomicI8",
-    "std::sync::atomic::AtomicI16",
-    "std::sync::atomic::AtomicI32",
-    "std::sync::atomic::AtomicI64",
-    "std::sync::atomic::AtomicU8",
-    "std::sync::atomic::AtomicU16",
-    "std::sync::atomic::AtomicU32",
-    "std::sync::atomic::AtomicU64",
-    "std::sync::atomic::AtomicBool",
-    "std::sync::atomic::AtomicIsize",
-    "std::sync::atomic::AtomicPtr",
-    "std::sync::atomic::AtomicUsize",
+    "core::sync::atomic::AtomicI8",
+    "core::sync::atomic::AtomicI16",
+    "core::sync::atomic::AtomicI32",
+    "core::sync::atomic::AtomicI64",
+    "core::sync::atomic::AtomicU8",
+    "core::sync::atomic::AtomicU16",
+    "core::sync::atomic::AtomicU32",
+    "core::sync::atomic::AtomicU64",
+    "core::sync::atomic::AtomicBool",
+    "core::sync::atomic::AtomicIsize",
+    "core::sync::atomic::AtomicPtr",
+    "core::sync::atomic::AtomicUsize",
     "core::sync::atomic::AtomicI8",
     "core::sync::atomic::AtomicI16",
     "core::sync::atomic::AtomicI32",

doc/release-notes/iceoryx2-unreleased.md

@@ -13,6 +13,10 @@
 
 * Deadline property for event services
     [#573](https://github.com/eclipse-iceoryx/iceoryx2/issues/573)
+* Use 'std_instead_of_core' clippy warning
+    [#579](https://github.com/eclipse-iceoryx/iceoryx2/issues/579)
+* Use 'std_instead_of_alloc' and 'alloc_instead_of_core' clippy warning
+    [#581](https://github.com/eclipse-iceoryx/iceoryx2/issues/581)
 
 ### Bugfixes
 

examples/rust/complex_data_types/complex_data_types.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use std::time::Duration;
+use core::time::Duration;
 
 use iceoryx2::prelude::*;
 use iceoryx2_bb_container::{

examples/rust/event_based_communication/publisher.rs

@@ -10,6 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+use core::time::Duration;
 use examples_common::{PubSubEvent, TransmissionData};
 use iceoryx2::{
     port::{
@@ -18,7 +19,6 @@ use iceoryx2::{
     },
     prelude::*,
 };
-use std::time::Duration;
 
 const CYCLE_TIME: Duration = Duration::from_secs(1);
 const HISTORY_SIZE: usize = 20;

examples/rust/event_based_communication/subscriber.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use std::time::Duration;
+use core::time::Duration;
 
 use examples_common::{PubSubEvent, TransmissionData};
 use iceoryx2::{

iceoryx2-bb/container/src/byte_string.rs

@@ -29,7 +29,7 @@
 //! println!("removed byte {}", some_string.remove(0));
 //! ```
 
-use std::{
+use core::{
     cmp::Ordering,
     fmt::{Debug, Display},
     hash::Hash,
@@ -67,8 +67,8 @@ pub enum FixedSizeByteStringModificationError {
     InsertWouldExceedCapacity,
 }
 
-impl std::fmt::Display for FixedSizeByteStringModificationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for FixedSizeByteStringModificationError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         std::write!(f, "FixedSizeByteStringModificationError::{:?}", self)
     }
 }
@@ -98,7 +98,7 @@ struct FixedSizeByteStringVisitor<const CAPACITY: usize>;
 impl<const CAPACITY: usize> Visitor<'_> for FixedSizeByteStringVisitor<CAPACITY> {
     type Value = FixedSizeByteString<CAPACITY>;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
         formatter.write_str(&format!("a string with a length of at most {}", CAPACITY))
     }
 
@@ -147,7 +147,7 @@ impl<const CAPACITY: usize> Ord for FixedSizeByteString<CAPACITY> {
 }
 
 impl<const CAPACITY: usize> Hash for FixedSizeByteString<CAPACITY> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         state.write(self.as_bytes())
     }
 }
@@ -199,7 +199,7 @@ impl<const CAPACITY: usize, const OTHER_CAPACITY: usize> PartialEq<&[u8; OTHER_C
 }
 
 impl<const CAPACITY: usize> Debug for FixedSizeByteString<CAPACITY> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "FixedSizeByteString<{}> {{ len: {}, data: \"{}\" }}",
@@ -211,7 +211,7 @@ impl<const CAPACITY: usize> Debug for FixedSizeByteString<CAPACITY> {
 }
 
 impl<const CAPACITY: usize> Display for FixedSizeByteString<CAPACITY> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "{}", as_escaped_string(self.as_bytes()))
     }
 }
@@ -304,7 +304,7 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
     /// into the [`FixedSizeByteString`] it will be truncated.
     pub fn from_bytes_truncated(bytes: &[u8]) -> Self {
         let mut new_self = Self::new();
-        new_self.len = std::cmp::min(bytes.len(), CAPACITY);
+        new_self.len = core::cmp::min(bytes.len(), CAPACITY);
         for (i, byte) in bytes.iter().enumerate().take(new_self.len) {
             new_self.data[i].write(*byte);
         }
@@ -332,7 +332,7 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
         }
 
         let mut new_self = Self::new();
-        std::ptr::copy_nonoverlapping(
+        core::ptr::copy_nonoverlapping(
             ptr,
             new_self.as_mut_bytes().as_mut_ptr() as *mut core::ffi::c_char,
             string_length,
@@ -344,12 +344,12 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
 
     /// Returns a slice to the underlying bytes
     pub const fn as_bytes(&self) -> &[u8] {
-        unsafe { std::slice::from_raw_parts(self.data[0].as_ptr(), self.len) }
+        unsafe { core::slice::from_raw_parts(self.data[0].as_ptr(), self.len) }
     }
 
     /// Returns a null-terminated slice to the underlying bytes
     pub const fn as_bytes_with_nul(&self) -> &[u8] {
-        unsafe { std::slice::from_raw_parts(self.data[0].as_ptr(), self.len + 1) }
+        unsafe { core::slice::from_raw_parts(self.data[0].as_ptr(), self.len + 1) }
     }
 
     /// Returns a zero terminated slice of the underlying bytes
@@ -359,7 +359,7 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
 
     /// Returns a mutable slice to the underlying bytes
     pub fn as_mut_bytes(&mut self) -> &mut [u8] {
-        unsafe { std::slice::from_raw_parts_mut(self.data[0].as_mut_ptr(), self.len) }
+        unsafe { core::slice::from_raw_parts_mut(self.data[0].as_mut_ptr(), self.len) }
     }
 
     /// Returns the capacity of the string
@@ -452,7 +452,7 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
     ///
     pub unsafe fn insert_bytes_unchecked(&mut self, idx: usize, bytes: &[u8]) {
         unsafe {
-            std::ptr::copy(
+            core::ptr::copy(
                 self.data[idx].as_ptr(),
                 self.data[idx].as_mut_ptr().add(bytes.len()),
                 self.len - idx,
@@ -528,7 +528,7 @@ impl<const CAPACITY: usize> FixedSizeByteString<CAPACITY> {
 
     fn remove_range_impl(&mut self, idx: usize, len: usize) {
         unsafe {
-            std::ptr::copy(
+            core::ptr::copy(
                 self.data[idx + len].as_ptr(),
                 self.data[idx].as_mut_ptr(),
                 self.len - (idx + len),

iceoryx2-bb/container/src/lib.rs

@@ -10,6 +10,9 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+#![warn(clippy::alloc_instead_of_core)]
+#![warn(clippy::std_instead_of_alloc)]
+#![warn(clippy::std_instead_of_core)]
 #![warn(missing_docs)]
 
 //! # iceoryx2 Building Blocks (BB) Container

iceoryx2-bb/container/src/queue.rs

@@ -89,7 +89,7 @@
 //! use iceoryx2_bb_container::queue::RelocatableQueue;
 //! use iceoryx2_bb_elementary::bump_allocator::BumpAllocator;
 //! use iceoryx2_bb_elementary::relocatable_container::RelocatableContainer;
-//! use std::ptr::NonNull;
+//! use core::ptr::NonNull;
 //!
 //! const QUEUE_CAPACITY:usize = 12;
 //! const MEM_SIZE: usize = RelocatableQueue::<u128>::const_memory_size(QUEUE_CAPACITY);
@@ -101,6 +101,8 @@
 //! unsafe { queue.init(&bump_allocator).expect("queue init failed") };
 //! ```
 //!
+use core::marker::PhantomData;
+use core::{alloc::Layout, fmt::Debug, mem::MaybeUninit};
 use iceoryx2_bb_elementary::allocator::{AllocationError, BaseAllocator};
 use iceoryx2_bb_elementary::bump_allocator::BumpAllocator;
 use iceoryx2_bb_elementary::math::unaligned_mem_size;
@@ -111,8 +113,6 @@ pub use iceoryx2_bb_elementary::relocatable_container::RelocatableContainer;
 use iceoryx2_bb_elementary::relocatable_ptr::{GenericRelocatablePointer, RelocatablePointer};
 use iceoryx2_bb_log::{fail, fatal_panic};
 use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicBool;
-use std::marker::PhantomData;
-use std::{alloc::Layout, fmt::Debug, mem::MaybeUninit};
 
 /// Queue with run-time fixed size capacity. In contrast to its counterpart the
 /// [`RelocatableQueue`] it is movable but is not shared memory compatible.
@@ -232,7 +232,7 @@ pub mod details {
         ) -> Result<(), AllocationError> {
             if self
                 .is_initialized
-                .load(std::sync::atomic::Ordering::Relaxed)
+                .load(core::sync::atomic::Ordering::Relaxed)
             {
                 fatal_panic!(
                     from "Queue::init()",
@@ -242,12 +242,12 @@ pub mod details {
 
             self.data_ptr.init(fail!(from "Queue::init", when allocator
                  .allocate(Layout::from_size_align_unchecked(
-                     std::mem::size_of::<T>() * self.capacity,
-                     std::mem::align_of::<T>(),
+                     core::mem::size_of::<T>() * self.capacity,
+                     core::mem::align_of::<T>(),
                  )), "Failed to initialize queue since the allocation of the data memory failed."
             ));
             self.is_initialized
-                .store(true, std::sync::atomic::Ordering::Relaxed);
+                .store(true, core::sync::atomic::Ordering::Relaxed);
 
             Ok(())
         }
@@ -332,9 +332,9 @@ pub mod details {
         fn verify_init(&self, source: &str) {
             debug_assert!(
                 self.is_initialized
-                    .load(std::sync::atomic::Ordering::Relaxed),
+                    .load(core::sync::atomic::Ordering::Relaxed),
                 "From: MetaQueue<{}>::{}, Undefined behavior - the object was not initialized with 'init' before.",
-                std::any::type_name::<T>(), source
+                core::any::type_name::<T>(), source
             );
         }
 
@@ -395,7 +395,7 @@ pub mod details {
 
             let index = (self.start - self.len) % self.capacity;
             self.len -= 1;
-            let value = std::mem::replace(
+            let value = core::mem::replace(
                 &mut *self.data_ptr.as_mut_ptr().add(index),
                 MaybeUninit::uninit(),
             );
@@ -441,7 +441,7 @@ pub mod details {
         fn drop(&mut self) {
             if self
                 .is_initialized
-                .load(std::sync::atomic::Ordering::Relaxed)
+                .load(core::sync::atomic::Ordering::Relaxed)
             {
                 unsafe { self.clear_impl() }
             }