orx-split-vec 3.22.0

An efficient dynamic capacity vector with pinned element guarantees.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::{Doubling, Growth, GrowthWithConstantTimeAccess, Linear, Recursive};
use orx_concurrent_iter::implementations::jagged_arrays::{
    AsRawSlice, JaggedIndex, JaggedIndexer, Slices,
};

/// A [`Growth`] that supports parallelization.
///
/// All types implementing both [`Growth`] and [`JaggedIndexer`] implement [`ParGrowth`].
///
/// [`Doubling`], [`Linear`] and [`Recursive`] growth strategies all support parallel growth.
///
/// [`Doubling`]: crate::Doubling
/// [`Linear`]: crate::Linear
/// [`Recursive`]: crate::Recursive
pub trait ParGrowth: Growth + JaggedIndexer {}

impl<G: Growth + JaggedIndexer> ParGrowth for G {}

impl JaggedIndexer for Doubling {
    unsafe fn jagged_index_unchecked<'a, T: 'a>(
        &self,
        _: &impl Slices<'a, T>,
        flat_index: usize,
    ) -> JaggedIndex {
        self.get_fragment_and_inner_indices_unchecked(flat_index)
            .into()
    }

    unsafe fn jagged_index_unchecked_from_slice<'a, T: 'a>(
        &self,
        _: &[impl AsRawSlice<T>],
        flat_index: usize,
    ) -> JaggedIndex {
        self.get_fragment_and_inner_indices_unchecked(flat_index)
            .into()
    }
}

impl JaggedIndexer for Linear {
    unsafe fn jagged_index_unchecked<'a, T: 'a>(
        &self,
        _: &impl Slices<'a, T>,
        flat_index: usize,
    ) -> JaggedIndex {
        self.get_fragment_and_inner_indices_unchecked(flat_index)
            .into()
    }

    unsafe fn jagged_index_unchecked_from_slice<'a, T: 'a>(
        &self,
        _: &[impl AsRawSlice<T>],
        flat_index: usize,
    ) -> JaggedIndex {
        self.get_fragment_and_inner_indices_unchecked(flat_index)
            .into()
    }
}

impl JaggedIndexer for Recursive {
    unsafe fn jagged_index_unchecked<'a, T: 'a>(
        &self,
        arrays: &impl Slices<'a, T>,
        flat_index: usize,
    ) -> JaggedIndex {
        let mut idx = flat_index;
        let [mut f, mut i] = [0, 0];
        let mut current_f = 0;
        while idx > 0 {
            let current_len = unsafe { arrays.slice_at_unchecked(current_f) }.len();
            match current_len > idx {
                true => {
                    i = idx;
                    idx = 0;
                }
                false => {
                    f += 1;
                    idx -= current_len;
                }
            }
            current_f += 1;
        }
        JaggedIndex::new(f, i)
    }

    unsafe fn jagged_index_unchecked_from_slice<'a, T: 'a>(
        &self,
        arrays: &[impl AsRawSlice<T>],
        flat_index: usize,
    ) -> JaggedIndex {
        let mut idx = flat_index;
        let [mut f, mut i] = [0, 0];
        let mut current_f = 0;
        while idx > 0 {
            let current_len = arrays[current_f].length();
            match current_len > idx {
                true => {
                    i = idx;
                    idx = 0;
                }
                false => {
                    f += 1;
                    idx -= current_len;
                }
            }
            current_f += 1;
        }
        JaggedIndex::new(f, i)
    }
}