feanor_math/seq/
conversion.rs

1use std::{marker::PhantomData, num::NonZero};
2
3use super::*;
4
5///
6/// Iterator over the elements of a [`VectorFn`].
7/// Produced by the function [`VectorFn::iter()`] and [`VectorFn::into_iter()`].
8/// 
9#[derive(Debug)]
10pub struct VectorFnIter<V: VectorFn<T>, T> {
11    content: V,
12    begin: usize,
13    end: usize,
14    element: PhantomData<T>
15}
16
17impl<V: VectorFn<T>, T> VectorFnIter<V, T> {
18
19    pub fn new(content: V) -> Self {
20        Self {
21            end: content.len(),
22            content: content,
23            begin: 0,
24            element: PhantomData
25        }
26    }
27}
28
29impl<V: Clone + VectorFn<T>, T> Clone for VectorFnIter<V, T> {
30    
31    fn clone(&self) -> Self {
32        Self {
33            begin: self.begin,
34            end: self.end,
35            content: self.content.clone(),
36            element: PhantomData
37        }
38    }
39}
40
41impl<V: Copy + VectorFn<T>, T> Copy for VectorFnIter<V, T> {}
42
43impl<V: VectorFn<T>, T> Iterator for VectorFnIter<V, T> {
44
45    type Item = T;
46
47    fn next(&mut self) -> Option<Self::Item> {
48        if self.begin < self.end {
49            self.begin += 1;
50            return Some(self.content.at(self.begin - 1));
51        } else {
52            return None;
53        }
54    }
55
56    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
57        if self.begin + n <= self.end {
58            self.begin += n;
59            return Ok(());
60        } else {
61            let lacking_elements = n - (self.end - self.begin);
62            self.begin = self.end;
63            return Err(NonZero::new(lacking_elements).unwrap())
64        }
65    }
66
67    fn size_hint(&self) -> (usize, Option<usize>) {
68        (self.len(), Some(self.len()))
69    }
70}
71
72impl<V: VectorFn<T>, T> DoubleEndedIterator for VectorFnIter<V, T> {
73    fn next_back(&mut self) -> Option<Self::Item> {
74        if self.begin < self.end {
75            self.end -= 1;
76            return Some(self.content.at(self.end));
77        } else {
78            return None;
79        }
80    }
81
82    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
83        if self.begin + n <= self.end {
84            self.end -= n;
85            return Ok(());
86        } else {
87            let lacking_elements = n - (self.end - self.begin);
88            self.end = self.begin;
89            return Err(NonZero::new(lacking_elements).unwrap())
90        }
91    }
92}
93
94impl<V: VectorFn<T>, T> ExactSizeIterator for VectorFnIter<V, T> {
95    fn len(&self) -> usize {
96        self.end - self.begin
97    }
98}
99
100///
101/// A [`VectorFn`] that produces its elements by cloning the elements of an underlying [`VectorView`].
102/// Produced by the functions [`VectorView::clone_els()`] and [`VectorView::clone_ring_els()`].
103/// 
104#[derive(Debug)]
105pub struct CloneElFn<V: VectorView<T>, T, F: Fn(&T) -> T> {
106    content: V,
107    clone_el: F,
108    element: PhantomData<T>
109}
110
111impl<V: Clone + VectorView<T>, T, F: Clone + Fn(&T) -> T> Clone for CloneElFn<V, T, F> {
112    
113    fn clone(&self) -> Self {
114        Self {
115            clone_el: self.clone_el.clone(),
116            content: self.content.clone(),
117            element: PhantomData
118        }
119    }
120}
121
122impl<V: Copy + VectorView<T>, T, F: Copy + Fn(&T) -> T> Copy for CloneElFn<V, T, F> {}
123
124impl<V: VectorView<T>, T, F: Fn(&T) -> T> CloneElFn<V, T, F> {
125
126    ///
127    /// Creates a new [`CloneElFn`].
128    /// 
129    /// In most circumstances, it is easier to instead use the functions [`VectorView::clone_els()`] 
130    /// and [`VectorView::clone_ring_els()`] to produce a [`CloneElFn`].
131    /// 
132    pub fn new(content: V, clone_el: F) -> Self {
133        Self {
134            content: content,
135            clone_el: clone_el,
136            element: PhantomData
137        }
138    }
139}
140
141impl<V: SelfSubvectorView<T>, T, F: Fn(&T) -> T> SelfSubvectorFn<T> for CloneElFn<V, T, F> {
142
143    fn restrict_full(self, range: Range<usize>) -> Self {
144        Self {
145            content: self.content.restrict_full(range),
146            clone_el: self.clone_el,
147            element: PhantomData
148        }
149    }
150}
151
152impl<V: VectorView<T>, T, F: Fn(&T) -> T> VectorFn<T> for CloneElFn<V, T, F> {
153    
154    fn at(&self, i: usize) -> T {
155        (self.clone_el)(self.content.at(i))
156    }
157
158    fn len(&self) -> usize {
159        self.content.len()
160    }
161}
162
163///
164/// Wrapper around [`VectorView`] that interprets it as a [`VectorFn`]. The elements it provides are
165/// just the same references that would be returned through [`VectorFn::at()`].
166/// Produced by the function [`VectorView::as_fn()`].
167/// 
168#[derive(Debug)]
169pub struct VectorViewFn<'a, V: ?Sized + VectorView<T>, T: ?Sized> {
170    content: &'a V,
171    element: PhantomData<T>
172}
173
174impl<'a, V: ?Sized + VectorView<T>, T: ?Sized> Clone for VectorViewFn<'a, V, T> {
175    
176    fn clone(&self) -> Self {
177        *self
178    }
179}
180
181impl<'a, V: ?Sized + VectorView<T>, T: ?Sized> Copy for VectorViewFn<'a, V, T> {}
182
183impl<'a, V: ?Sized + VectorView<T>, T: ?Sized> VectorViewFn<'a, V, T> {
184
185    ///
186    /// Creates a new [`VectorViewFn`].
187    /// In most circumstances, it is easier to instead use the function [`VectorView::as_fn()`].
188    /// 
189    pub fn new(content: &'a V) -> Self {
190        Self {
191            content: content,
192            element: PhantomData
193        }
194    }
195}
196
197impl<'a, V: ?Sized + VectorView<T>, T: ?Sized> VectorFn<&'a T> for VectorViewFn<'a, V, T> {
198    
199    fn at(&self, i: usize) -> &'a T {
200        self.content.at(i)
201    }
202
203    fn len(&self) -> usize {
204        self.content.len()
205    }
206}
feanor_math/seq/conversion.rs

feanor_math/seq/
conversion.rs
