audio-core 0.2.1

The core audio traits
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

macro_rules! iterators {
    (
        $($field:ident : $field_ty:ty),* $(,)?
        =>
        $self:ident . $fn:ident ($($arg:ident),* $(,)?)
    ) => {
        pub struct IterChannels<I> {
            iter: I,
            $($field: $field_ty,)*
        }

        impl<I> Iterator for IterChannels<I>
        where
            I: Iterator,
            I::Item: Channel,
        {
            type Item = I::Item;

            fn next(&mut $self) -> Option<Self::Item> {
                Some($self.iter.next()?.$fn($($self.$arg),*))
            }

            fn nth(&mut $self, n: usize) -> Option<Self::Item> {
                Some($self.iter.nth(n)?.$fn($($self.$arg),*))
            }
        }

        impl<I> DoubleEndedIterator for IterChannels<I>
        where
            I: DoubleEndedIterator,
            I::Item: Channel,
        {
            fn next_back(&mut $self) -> Option<Self::Item> {
                Some($self.iter.next_back()?.$fn($($self.$arg),*))
            }

            fn nth_back(&mut $self, n: usize) -> Option<Self::Item> {
                Some($self.iter.nth_back(n)?.$fn($($self.$arg),*))
            }
        }

        impl<I> ExactSizeIterator for IterChannels<I>
        where
            I: ExactSizeIterator,
            I::Item: ChannelMut,
        {
            fn len(&$self) -> usize {
                $self.iter.len()
            }
        }

        pub struct IterChannelsMut<I> {
            iter: I,
            $($field: $field_ty,)*
        }

        impl<I> Iterator for IterChannelsMut<I>
        where
            I: Iterator,
            I::Item: ChannelMut,
        {
            type Item = I::Item;

            fn next(&mut $self) -> Option<Self::Item> {
                Some($self.iter.next()?.$fn($($self . $arg),*))
            }

            fn nth(&mut $self, n: usize) -> Option<Self::Item> {
                Some($self.iter.nth(n)?.$fn($($self . $arg),*))
            }
        }

        impl<I> DoubleEndedIterator for IterChannelsMut<I>
        where
            I: DoubleEndedIterator,
            I::Item: ChannelMut,
        {
            fn next_back(&mut $self) -> Option<Self::Item> {
                Some($self.iter.next_back()?.$fn($($self . $arg),*))
            }

            fn nth_back(&mut $self, n: usize) -> Option<Self::Item> {
                Some($self.iter.nth_back(n)?.$fn($($self . $arg),*))
            }
        }

        impl<I> ExactSizeIterator for IterChannelsMut<I>
        where
            I: ExactSizeIterator,
            I::Item: ChannelMut,
        {
            fn len(&$self) -> usize {
                $self.iter.len()
            }
        }
    }
}