orx-split-vec 3.8.0

An efficient constant access time vector with dynamic capacity and pinned elements.
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

use crate::Fragment;
use core::slice::Iter;

type Outer<'a, T> = Iter<'a, Fragment<T>>;
type Inner<'a, T> = Iter<'a, T>;

pub fn all<'a, T, F>(outer: &mut Outer<'a, T>, inner: &mut Inner<'a, T>, mut f: F) -> bool
where
    F: FnMut(&'a T) -> bool,
{
    if !inner.all(&mut f) {
        false
    } else {
        for fragment in outer {
            if !fragment.iter().all(&mut f) {
                return false;
            }
        }
        true
    }
}

pub fn any<'a, T, F>(outer: &mut Outer<'a, T>, inner: &mut Inner<'a, T>, mut f: F) -> bool
where
    F: FnMut(&'a T) -> bool,
{
    if inner.any(&mut f) {
        true
    } else {
        for fragment in outer {
            if fragment.iter().any(&mut f) {
                return true;
            }
        }
        false
    }
}

pub fn fold<'a, T, B, F>(outer: &mut Outer<'a, T>, inner: &mut Inner<'a, T>, init: B, mut f: F) -> B
where
    F: FnMut(B, &'a T) -> B,
{
    let mut res = inner.fold(init, &mut f);
    for fragment in outer {
        res = fragment.iter().fold(res, &mut f);
    }
    res
}