soapy 0.2.9

Structure-of-arrays derive macro
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

use crate::{
    iter_raw::{iter_with_raw, IterRaw, IterRawAdapter},
    Slice, SoaRaw, Soapy,
};
use std::{
    fmt::{self, Debug, Formatter},
    iter::FusedIterator,
    marker::PhantomData,
};

/// Immutable [`Slice`] iterator.
///
/// This struct is created by the [`iter`] method.
///
/// [`Slice`]: crate::Slice
/// [`iter`]: crate::Slice::iter
pub struct Iter<'a, T>
where
    T: 'a + Soapy,
{
    pub(crate) iter_raw: IterRaw<T, Self>,
    pub(crate) _marker: PhantomData<&'a T>,
}

impl<'a, T> Debug for Iter<'a, T>
where
    T: Soapy,
    for<'b> T::Ref<'b>: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self.as_slice())
    }
}

impl<'a, T> Default for Iter<'a, T>
where
    T: Soapy,
{
    fn default() -> Self {
        Self {
            iter_raw: IterRaw {
                slice: Slice::empty(),
                len: 0,
                adapter: PhantomData,
            },
            _marker: PhantomData,
        }
    }
}

impl<'a, T> Clone for Iter<'a, T>
where
    T: Soapy,
{
    fn clone(&self) -> Self {
        Self {
            iter_raw: self.iter_raw,
            _marker: PhantomData,
        }
    }
}

impl<'a, T> Iter<'a, T>
where
    T: Soapy,
{
    /// Returns an immutable slice of all elements that have not been yielded
    /// yet.
    pub fn as_slice(&self) -> &'a Slice<T> {
        unsafe { self.iter_raw.as_slice() }
    }
}

impl<'a, T> IterRawAdapter<T> for Iter<'a, T>
where
    T: Soapy,
{
    type Item = T::Ref<'a>;

    fn item_from_raw(raw: T::Raw) -> Self::Item {
        unsafe { raw.get_ref() }
    }
}

iter_with_raw!(Iter<'a, T>, 'a);