Skip to content

Commit 96e903c

Browse files
orxfunorxfun
authored
Merge pull request #52 from orxfun/upgrade-selfref-col-v3.1
Upgrade selfref col v3.1
2 parents bfde3ec + baca6bd commit 96e903c

15 files changed

+75
-65
lines changed

‎Cargo.toml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "orx-linked-list"
3-
version = "4.0.0"
3+
version = "4.1.0"
44
edition = "2024"
55
authors = ["orxfun <[email protected]>"]
66
description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
@@ -16,7 +16,7 @@ orx-pinned-vec = { version = "3.21.0", default-features = false }
1616
orx-fixed-vec = { version = "3.22.0", default-features = false }
1717
orx-split-vec = { version = "3.22.0", default-features = false }
1818
orx-concurrent-iter = { version = "3.3.0", default-features = false }
19-
orx-selfref-col = { version = "3.0.0", default-features = false }
19+
orx-selfref-col = { version = "3.1.0", default-features = false }
2020
orx-parallel = { version = "3.4.0", default-features = false, optional = true }
2121

2222
[dev-dependencies]

‎examples/bench_parallelization.rs‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -33,46 +33,50 @@ fn main() {
3333
let args = Args::parse();
3434

3535
let expected_output = {
36-
let list: DoublyList<_> = (0..args.len as usize).collect();
36+
let list: DoublyList<_> = (0..args.len).collect();
3737

3838
list.iter()
3939
.filter(|x| *x % 3 != 0)
4040
.map(|x| x + fibonacci(x % 1000))
41-
.filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
41+
.filter(|&x| x % 2 == 0)
42+
.map(|x| x.to_string())
4243
.collect::<Vec<_>>()
4344
};
4445

45-
let computations: Vec<(&str, Box<dyn Fn() -> Vec<String>>)> = vec![
46+
type Compute = dyn Fn() -> Vec<String>;
47+
let computations: Vec<(&str, Box<Compute>)> = vec![
4648
(
4749
"Sequential computation over std::collections::LinkedList",
4850
Box::new(move || {
49-
let list: std::collections::LinkedList<_> = (0..args.len as usize).collect();
51+
let list: std::collections::LinkedList<_> = (0..args.len).collect();
5052

5153
list.iter()
5254
.filter(|x| *x % 3 != 0)
5355
.map(|x| x + fibonacci(x % 1000))
54-
.filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
56+
.filter(|&x| x % 2 == 0)
57+
.map(|x| x.to_string())
5558
.collect::<Vec<_>>()
5659
}),
5760
),
5861
#[cfg(feature = "orx-parallel")]
5962
(
6063
"Sequential computation over DoublyList",
6164
Box::new(move || {
62-
let list: DoublyList<_> = (0..args.len as usize).collect();
65+
let list: DoublyList<_> = (0..args.len).collect();
6366

6467
list.iter_x()
6568
.filter(|x| *x % 3 != 0)
6669
.map(|x| x + fibonacci(x % 1000))
67-
.filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
70+
.filter(|&x| x % 2 == 0)
71+
.map(|x| x.to_string())
6872
.collect::<Vec<_>>()
6973
}),
7074
),
7175
#[cfg(feature = "orx-parallel")]
7276
(
7377
"Parallelized over DoublyList using orx_parallel",
7478
Box::new(move || {
75-
let list: DoublyList<_> = (0..args.len as usize).collect();
79+
let list: DoublyList<_> = (0..args.len).collect();
7680

7781
list.par_x() // replace iter_x (into_iter_x) with par_x (into_par_x) to parallelize !
7882
.filter(|x| *x % 3 != 0)

‎examples/tour_mutations.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use clap::Parser;
22
use orx_linked_list::*;
33
use rand::prelude::*;
44
use rand_chacha::ChaCha8Rng;
5-
use std::{fmt::Debug, time::Instant, usize};
5+
use std::{fmt::Debug, time::Instant};
66

77
fn get_cities(num_cities: usize) -> impl Iterator<Item = City> {
88
(0..num_cities).map(|id| City {

‎examples/utils/benchmark_utils.rs‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -35,11 +35,13 @@ where
3535
now.elapsed().unwrap()
3636
}
3737

38+
type Compute<O> = dyn Fn() -> O;
39+
3840
pub fn timed_reduce_all<O>(
3941
benchmark_name: &str,
4042
num_repetitions: usize,
4143
expected_output: Option<O>,
42-
computations: &[(&str, Box<dyn Fn() -> O>)],
44+
computations: &[(&str, Box<Compute<O>>)],
4345
) where
4446
O: PartialEq + Debug + Clone,
4547
{
@@ -80,7 +82,7 @@ pub fn timed_collect_all<Out, O>(
8082
benchmark_name: &str,
8183
num_repetitions: usize,
8284
expected_output: &[O],
83-
computations: &[(&str, Box<dyn Fn() -> Out>)],
85+
computations: &[(&str, Box<Compute<Out>>)],
8486
) where
8587
Out: IntoIterator<Item = O>,
8688
O: PartialEq + Debug,

‎src/tests/doubly.rs‎

Lines changed: 18 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -51,22 +51,22 @@ where
5151
assert_ne!(self.0.ends().get(BACK_IDX), self.0.ends().get(FRONT_IDX));
5252

5353
let mut fwd_pointers = alloc::vec![];
54-
let mut ptr = self.0.ends().get(FRONT_IDX).cloned().unwrap();
55-
fwd_pointers.push(ptr.clone());
56-
while let Some((next_ptr, next)) = self.next(&ptr) {
57-
assert_eq!(next.prev().get(), Some(&ptr));
54+
let mut ptr = self.0.ends().get(FRONT_IDX).unwrap();
55+
fwd_pointers.push(ptr);
56+
while let Some((next_ptr, next)) = self.next(ptr) {
57+
assert_eq!(next.prev().get(), Some(ptr));
5858
ptr = next_ptr;
59-
fwd_pointers.push(ptr.clone());
59+
fwd_pointers.push(ptr);
6060
}
6161
assert_eq!(fwd_pointers.len(), num_active_nodes);
6262

6363
let mut bwd_pointers = alloc::vec![];
64-
let mut ptr = self.0.ends().get(BACK_IDX).cloned().unwrap();
65-
bwd_pointers.push(ptr.clone());
66-
while let Some((prev_ptr, prev)) = self.prev(&ptr) {
67-
assert_eq!(prev.next().get(), Some(&ptr));
64+
let mut ptr = self.0.ends().get(BACK_IDX).unwrap();
65+
bwd_pointers.push(ptr);
66+
while let Some((prev_ptr, prev)) = self.prev(ptr) {
67+
assert_eq!(prev.next().get(), Some(ptr));
6868
ptr = prev_ptr;
69-
bwd_pointers.push(ptr.clone());
69+
bwd_pointers.push(ptr);
7070
}
7171

7272
bwd_pointers.reverse();
@@ -79,14 +79,12 @@ where
7979

8080
assert_eq!(iter.next(), self.front());
8181

82-
let mut maybe_ptr = self.0.ends().get(FRONT_IDX).cloned();
82+
let mut maybe_ptr = self.0.ends().get(FRONT_IDX);
8383
for _ in 1..num_active_nodes {
84-
let ptr = maybe_ptr.clone().unwrap();
85-
maybe_ptr = self.next(&ptr).map(|x| x.0);
84+
let ptr = maybe_ptr.unwrap();
85+
maybe_ptr = self.next(ptr).map(|x| x.0);
8686

87-
let data = maybe_ptr
88-
.clone()
89-
.map(|p| unsafe { self.0.data_unchecked(&p) });
87+
let data = maybe_ptr.map(|p| unsafe { self.0.data_unchecked(p) });
9088
assert_eq!(iter.next(), data);
9189
}
9290
assert!(iter.next().is_none());
@@ -96,14 +94,12 @@ where
9694

9795
assert_eq!(iter.next(), self.back());
9896

99-
let mut maybe_ptr = self.0.ends().get(BACK_IDX).cloned();
97+
let mut maybe_ptr = self.0.ends().get(BACK_IDX);
10098
for _ in 1..num_active_nodes {
101-
let ptr = maybe_ptr.clone().unwrap();
102-
maybe_ptr = self.prev(&ptr).map(|x| x.0);
99+
let ptr = maybe_ptr.unwrap();
100+
maybe_ptr = self.prev(ptr).map(|x| x.0);
103101

104-
let data = maybe_ptr
105-
.clone()
106-
.map(|p| unsafe { self.0.data_unchecked(&p) });
102+
let data = maybe_ptr.map(|p| unsafe { self.0.data_unchecked(p) });
107103
assert_eq!(iter.next(), data);
108104
}
109105
assert!(iter.next().is_none());

‎src/tests/singly.rs‎

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -39,11 +39,11 @@ where
3939
assert!(self.front().is_some());
4040

4141
let mut fwd_pointers = alloc::vec![];
42-
let mut ptr = self.0.ends().get().cloned().unwrap();
43-
fwd_pointers.push(ptr.clone());
44-
while let Some((next_ptr, _)) = self.next(&ptr) {
42+
let mut ptr = self.0.ends().get().unwrap();
43+
fwd_pointers.push(ptr);
44+
while let Some((next_ptr, _)) = self.next(ptr) {
4545
ptr = next_ptr;
46-
fwd_pointers.push(ptr.clone());
46+
fwd_pointers.push(ptr);
4747
}
4848
assert_eq!(fwd_pointers.len(), num_active_nodes);
4949
}
@@ -54,14 +54,12 @@ where
5454

5555
assert_eq!(iter.next(), self.front());
5656

57-
let mut maybe_ptr = self.0.ends().get().cloned();
57+
let mut maybe_ptr = self.0.ends().get();
5858
for _ in 1..num_active_nodes {
59-
let ptr = maybe_ptr.clone().unwrap();
60-
maybe_ptr = self.next(&ptr).map(|x| x.0);
59+
let ptr = maybe_ptr.unwrap();
60+
maybe_ptr = self.next(ptr).map(|x| x.0);
6161

62-
let data = maybe_ptr
63-
.clone()
64-
.map(|p| unsafe { self.0.data_unchecked(&p) });
62+
let data = maybe_ptr.map(|p| unsafe { self.0.data_unchecked(p) });
6563
assert_eq!(iter.next(), data);
6664
}
6765
assert!(iter.next().is_none());

‎src/variant.rs‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,11 @@ pub struct Singly<T> {
1212
p: PhantomData<T>,
1313
}
1414

15+
/// # SAFETY
16+
///
17+
/// List variants do not hold any data, safe to send or sync.
18+
unsafe impl<T> Sync for Singly<T> {}
19+
1520
impl<T> Variant for Singly<T> {
1621
type Item = T;
1722

@@ -32,6 +37,11 @@ pub struct Doubly<T> {
3237
p: PhantomData<T>,
3338
}
3439

40+
/// # SAFETY
41+
///
42+
/// List variants do not hold any data, safe to send or sync.
43+
unsafe impl<T> Sync for Doubly<T> {}
44+
3545
impl<T> Variant for Doubly<T> {
3646
type Item = T;
3747

‎tests/list_move_next_to.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ fn list_move_next_to_front() {
1313
let (mut list, idx) = list_and_indices(n);
1414
list.move_next_to(idx[i], idx[0]);
1515

16-
let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
16+
let mut vec: Vec<_> = (0..n).filter(|x| x != &i).collect();
1717
vec.insert(1, i);
1818

1919
#[cfg(feature = "validation")]
@@ -29,7 +29,7 @@ fn list_move_next_to_back() {
2929
let (mut list, idx) = list_and_indices(n);
3030
list.move_next_to(idx[i], idx[n - 1]);
3131

32-
let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
32+
let mut vec: Vec<_> = (0..n).filter(|x| x != &i).collect();
3333
vec.insert(n - 1, i);
3434

3535
#[cfg(feature = "validation")]

‎tests/list_move_prev_to.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ fn list_move_prev_to_front() {
1313
let (mut list, idx) = list_and_indices(n);
1414
list.move_prev_to(idx[i], idx[0]);
1515

16-
let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
16+
let mut vec: Vec<_> = (0..n).filter(|x| x != &i).collect();
1717
vec.insert(0, i);
1818

1919
#[cfg(feature = "validation")]
@@ -29,7 +29,7 @@ fn list_move_prev_to_back() {
2929
let (mut list, idx) = list_and_indices(n);
3030
list.move_prev_to(idx[i], idx[n - 1]);
3131

32-
let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
32+
let mut vec: Vec<_> = (0..n).filter(|x| x != &i).collect();
3333
match i != n - 1 {
3434
true => vec.insert(n - 2, i),
3535
false => vec.push(i),

‎tests/reverse.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ fn list_reverse() {
1414
#[test]
1515
fn slice_reverse_empty() {
1616
for i in 0..20 {
17-
let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
17+
let mut list = doubly::new_doubly(&mut doubly::rng_with_seed(100 * i as u64), 20, 50);
1818
let expected: Vec<_> = list.iter().cloned().collect();
1919
let idx: Vec<_> = list.indices().collect();
2020

@@ -30,7 +30,7 @@ fn slice_reverse_empty() {
3030
#[test]
3131
fn slice_reverse_single() {
3232
for i in 0..20 {
33-
let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
33+
let mut list = doubly::new_doubly(&mut doubly::rng_with_seed(100 * i as u64), 20, 50);
3434
let expected: Vec<_> = list.iter().cloned().collect();
3535
let idx: Vec<_> = list.indices().collect();
3636

@@ -46,7 +46,7 @@ fn slice_reverse_single() {
4646
#[test]
4747
fn slice_reverse_from_front() {
4848
for i in 0..20 {
49-
let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
49+
let mut list = doubly::new_doubly(&mut doubly::rng_with_seed(100 * i as u64), 20, 50);
5050
let mut expected: Vec<_> = list.iter().cloned().collect();
5151
let idx: Vec<_> = list.indices().collect();
5252

@@ -65,7 +65,7 @@ fn slice_reverse_from_front() {
6565
#[test]
6666
fn slice_reverse_until_back() {
6767
for i in 0..20 {
68-
let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
68+
let mut list = doubly::new_doubly(&mut doubly::rng_with_seed(100 * i as u64), 20, 50);
6969
let mut expected: Vec<_> = list.iter().cloned().collect();
7070
let idx: Vec<_> = list.indices().collect();
7171

@@ -84,7 +84,7 @@ fn slice_reverse_until_back() {
8484
#[test]
8585
fn slice_reverse_middle() {
8686
for i in 0..20 {
87-
let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
87+
let mut list = doubly::new_doubly(&mut doubly::rng_with_seed(100 * i as u64), 20, 50);
8888
let mut expected: Vec<_> = list.iter().cloned().collect();
8989
let idx: Vec<_> = list.indices().collect();
9090

0 commit comments

Comments
 (0)