spade/delaunay_core/handles/iterators/
circular_iterator.rs

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
use core::marker::PhantomData;

use super::super::DirectedEdgeHandle;

pub trait NextBackFn {
    fn next<V, DE, UE, F>(
        edge_handle: DirectedEdgeHandle<V, DE, UE, F>,
    ) -> DirectedEdgeHandle<V, DE, UE, F>;

    fn next_back<V, DE, UE, F>(
        edge_handle: DirectedEdgeHandle<V, DE, UE, F>,
    ) -> DirectedEdgeHandle<V, DE, UE, F>;
}

pub struct CircularIterator<'a, V, DE, UE, F, NB> {
    pub(super) current_handle: DirectedEdgeHandle<'a, V, DE, UE, F>,
    final_handle: DirectedEdgeHandle<'a, V, DE, UE, F>,
    iteration_finished: bool,
    next_back_fn: PhantomData<NB>,
}

impl<'a, V, DE, UE, F, NB: NextBackFn> CircularIterator<'a, V, DE, UE, F, NB> {
    pub fn new(start_edge: DirectedEdgeHandle<'a, V, DE, UE, F>) -> Self {
        CircularIterator {
            current_handle: start_edge,
            final_handle: start_edge,
            iteration_finished: false,
            next_back_fn: Default::default(),
        }
    }

    pub fn new_empty(some_edge: DirectedEdgeHandle<'a, V, DE, UE, F>) -> Self {
        CircularIterator {
            current_handle: some_edge,
            final_handle: some_edge,
            iteration_finished: true,
            next_back_fn: Default::default(),
        }
    }
}

impl<'a, V, DE, UE, F, NB: NextBackFn> Iterator for CircularIterator<'a, V, DE, UE, F, NB> {
    type Item = DirectedEdgeHandle<'a, V, DE, UE, F>;

    fn next(&mut self) -> Option<DirectedEdgeHandle<'a, V, DE, UE, F>> {
        if self.iteration_finished {
            return None;
        }
        let result = self.current_handle;
        self.current_handle = NB::next(self.current_handle);
        if self.current_handle == self.final_handle {
            self.iteration_finished = true;
        }
        Some(result)
    }
}

impl<'a, V, DE, UE, F, NB: NextBackFn> DoubleEndedIterator
    for CircularIterator<'a, V, DE, UE, F, NB>
{
    fn next_back(&mut self) -> Option<DirectedEdgeHandle<'a, V, DE, UE, F>> {
        if self.iteration_finished {
            return None;
        }
        self.final_handle = NB::next_back(self.final_handle);
        if self.current_handle == self.final_handle {
            self.iteration_finished = true;
        }
        Some(self.final_handle)
    }
}