vectree 0.4.1

Vector-buffered tree collection with pre-/post-order, depth-first, mutable/immutable iterator
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// Copyright 2025 Redglyph
//

//! This crate offers a [skip_last](SkipLastIterator::skip_last) iterator adapter for convenience
//! when a post-order iterator such as [iter_post_depth_simple](crate::NodeProxy::iter_post_depth_simple) is used
//! on a depth-first iterator node. Since the post-order search ends with the top item itself,
//! which is the root of the children subtree, it may be desirable to skip it if it's not
//! required at all.
//!
//! ## Example
//!
//! ```ignored
//! for node in tree.iter_pre_depth() {
//!     print!("node {}: ", *node);
//!     let children = node.iter_post_depth_simple()
//!         .skip_last()
//!         .map(|n| n.to_string())
//!         .collect::<Vec<_>>().join(",");
//!     if !children.is_empty() {
//!         println!("children: {children}");
//!     } else {
//!         println!("(no children)");
//!     }
//! }
//! ```

#[derive(Clone)]
pub struct SkipLast<I: Iterator<Item=T>, T: Sized> {
    iter: I,
    first: bool,
    cache: Option<T>
}

impl<I: Iterator<Item=T>, T: Sized> Iterator for SkipLast<I, T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.first {
            self.cache = self.iter.next();
            self.first = false;
        }
        let mut item = self.cache.take();
        if item.is_some() {
            self.cache = self.iter.next();
            if self.cache.is_none() {
                item = None;
            }
        }
        item
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let (lower, upper) = self.iter.size_hint();
        let new_lower = lower.saturating_sub(1);
        let new_upper = match upper {
            Some(n) => Some(n.saturating_sub(1)),
            None => None,
        };
        (new_lower, new_upper)
    }

    fn count(self) -> usize {
        if self.first {
            self.iter.count().saturating_sub(1)
        } else {
            self.iter.count()
        }
    }
}

pub trait SkipLastIterator<T>: Iterator<Item=T> {
    /// Creates an iterator that skips the last element.
    fn skip_last(self) -> SkipLast<Self, T> where Self: Sized {
        SkipLast { iter: self, first: true, cache: None }
    }
}

impl<I: Iterator<Item=T>, T: Sized> SkipLastIterator<T> for I {}

// ---------------------------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super:: *;

    #[test]
    fn basic() {
        let v1 = vec![10, 20, 30, 40];
        let result1 = v1.iter().enumerate().skip_last().map(|(i, x)| format!("{i}:{x}")).collect::<Vec<_>>().join(",");
        assert_eq!(result1, "0:10,1:20,2:30");
        let result2 = v1.into_iter().enumerate().skip_last().map(|(i, x)| format!("{i}:{x}")).collect::<Vec<_>>().join(",");
        assert_eq!(result2, "0:10,1:20,2:30");

        let v2 = vec![10];
        let mut iter2 = v2.into_iter().skip_last();
        assert_eq!(iter2.next(), None);
        assert_eq!(iter2.next(), None);

        let v3: Vec<i32> = vec![];
        let mut iter3 = v3.iter().skip_last();
        assert_eq!(iter3.next(), None);
        assert_eq!(iter3.next(), None);

        let mut v4 = vec![10, 20, 30, 400];
        for x in v4.iter_mut().skip_last() {
            *x *= 10;
        }
        assert_eq!(v4, vec![100, 200, 300, 400]);
    }

    #[test]
    fn size_hint() {
        let iter = (0..usize::MAX).skip_last();
        let hint = iter.size_hint();
        assert_eq!(hint, (usize::MAX - 1, Some(usize::MAX - 1)));
    }

    #[test]
    fn count() {
        let iter1 = (0..usize::MAX).skip_last();
        assert_eq!(iter1.count(), usize::MAX - 1);

        let mut iter2 = (0..usize::MAX).skip_last();
        iter2.next();
        assert_eq!(iter2.count(), usize::MAX - 2);

        let iter3 = (0..0).skip_last();
        assert_eq!(iter3.count(), 0);

        let mut iter4 = (0..0).skip_last();
        iter4.next();
        assert_eq!(iter4.count(), 0);
    }
}