New pinned vector versions

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-concurrent-vec"
-version = "3.6.0"
+version = "3.7.0"
 edition = "2024"
 authors = ["orxfun <orx.ugur.arikan@gmail.com>"]
 description = "A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations."
@@ -11,10 +11,10 @@ categories = ["data-structures", "concurrency", "rust-patterns", "no-std"]
 
 [dependencies]
 orx-pseudo-default = { version = "2.1.0", default-features = false }
-orx-pinned-vec = "3.16.0"
-orx-fixed-vec = "3.16.0"
-orx-split-vec = "3.16.0"
-orx-pinned-concurrent-col = "2.13.0"
+orx-pinned-vec = { version = "3.17.0", default-features = false }
+orx-fixed-vec = { version = "3.18.0", default-features = false }
+orx-split-vec = { version = "3.18.0", default-features = false }
+orx-pinned-concurrent-col = { version = "2.14.0", default-features = false }
 orx-concurrent-option = "1.5.0"
 serde = { version = "1.0.219", optional = true, default-features = false }
 

benches/collect_with_extend.rs

@@ -1,5 +1,5 @@
 use append_only_vec::AppendOnlyVec;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
 use orx_concurrent_vec::*;
 
 #[allow(dead_code)]

benches/collect_with_push.rs

@@ -1,5 +1,5 @@
 use append_only_vec::AppendOnlyVec;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
 use orx_concurrent_vec::*;
 
 #[allow(dead_code)]

src/common_traits/debug.rs

@@ -4,7 +4,7 @@ use orx_fixed_vec::IntoConcurrentPinnedVec;
 
 impl<T: Debug> Debug for ConcurrentElement<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.map(|x| write!(f, "{:?}", x))
+        self.map(|x| write!(f, "{x:?}"))
     }
 }
 
@@ -37,9 +37,9 @@ where
 {
     write!(f, "[")?;
     if let Some(first) = iter.next() {
-        first.map(|x| write!(f, "{:?}", x))?;
+        first.map(|x| write!(f, "{x:?}"))?;
         for elem in iter {
-            elem.map(|x| write!(f, ", {:?}", x))?;
+            elem.map(|x| write!(f, ", {x:?}"))?;
         }
     }
     write!(f, "]")

src/common_traits/index.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentSlice, ConcurrentVec};
+use crate::{ConcurrentSlice, ConcurrentVec, elem::ConcurrentElement};
 use core::ops::Index;
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 

src/common_traits/serde.rs

@@ -2,7 +2,7 @@ use crate::{ConcurrentElement, ConcurrentVec};
 use core::marker::PhantomData;
 use orx_concurrent_option::ConcurrentOption;
 use orx_fixed_vec::IntoConcurrentPinnedVec;
-use serde::{de::Visitor, ser::SerializeSeq, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::Visitor, ser::SerializeSeq};
 
 impl<T, P> Serialize for ConcurrentVec<T, P>
 where

src/concurrent_slice/iter_shorthands.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentSlice};
+use crate::{ConcurrentSlice, elem::ConcurrentElement};
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 
 impl<'a, T, P> ConcurrentSlice<'a, T, P>

src/concurrent_slice/slice.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, helpers::DefaultPinVec, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement, helpers::DefaultPinVec};
 use core::ops::RangeBounds;
 use orx_fixed_vec::IntoConcurrentPinnedVec;
 

src/concurrent_slice/unsafe_api.rs

@@ -344,6 +344,7 @@ where
     ///
     /// assert_eq!(&vec, &['a', 'x', 'c', 'd']);
     /// ```
+    #[allow(clippy::mut_from_ref)]
     pub unsafe fn get_mut(&self, i: usize) -> Option<&mut T> {
         self.idx(i).and_then(|i| unsafe { self.vec.get_mut(i) })
     }

src/exclusive.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 
 impl<T, P> ConcurrentVec<T, P>

src/grow.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use core::sync::atomic::Ordering;
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 

src/helpers.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use core::sync::atomic::AtomicUsize;
 use orx_concurrent_option::{MutHandle, StateU8};
 use orx_pinned_vec::IntoConcurrentPinnedVec;

src/iter_shorthands.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 
 impl<T, P> ConcurrentVec<T, P>

src/mut_elem.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use orx_concurrent_option::SOME;
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 

src/partial_eq.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 
 impl<T, P> ConcurrentVec<T, P>

src/split.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentSlice, ConcurrentVec};
+use crate::{ConcurrentSlice, ConcurrentVec, elem::ConcurrentElement};
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 
 impl<T, P> ConcurrentVec<T, P>

src/to_vec.rs

@@ -1,4 +1,4 @@
-use crate::{elem::ConcurrentElement, ConcurrentVec};
+use crate::{ConcurrentVec, elem::ConcurrentElement};
 use alloc::vec::Vec;
 use orx_pinned_vec::IntoConcurrentPinnedVec;
 

src/unsafe_api.rs

@@ -360,6 +360,7 @@ where
     ///
     /// assert_eq!(&vec, &['a', 'x', 'c', 'd']);
     /// ```
+    #[allow(clippy::mut_from_ref)]
     pub unsafe fn get_mut(&self, i: usize) -> Option<&mut T> {
         match i < self.reserved_len() {
             true => {

src/vec.rs

@@ -1,5 +1,5 @@
-use crate::elem::ConcurrentElement;
 use crate::ConcurrentSlice;
+use crate::elem::ConcurrentElement;
 use crate::{helpers::DefaultPinVec, state::ConcurrentVecState};
 use core::ops::RangeBounds;
 use core::sync::atomic::Ordering;