kutil_std/iter/
first_last.rs

1use std::iter::*;
2
3//
4//  IterateWithFirstLast
5//
6
7/// Iterator providing first and last flags.
8pub struct IterateWithFirstLast<ItemT, IterableT>
9where
10    IterableT: IntoIterator<Item = ItemT>,
11{
12    iterator: Peekable<IterableT::IntoIter>,
13    first: bool,
14}
15
16impl<ItemT, IterableT> IterateWithFirstLast<ItemT, IterableT>
17where
18    IterableT: IntoIterator<Item = ItemT>,
19{
20    /// Constructor.
21    pub fn new(iterable: IterableT) -> Self {
22        Self { iterator: iterable.into_iter().peekable(), first: true }
23    }
24}
25
26impl<ItemT, IterableT> Iterator for IterateWithFirstLast<ItemT, IterableT>
27where
28    IterableT: IntoIterator<Item = ItemT>,
29{
30    type Item = (ItemT, bool, bool);
31
32    fn next(&mut self) -> Option<Self::Item> {
33        let first = if self.first {
34            self.first = false;
35            true
36        } else {
37            false
38        };
39
40        self.iterator.next().map(|i| (i, first, self.iterator.peek().is_none()))
41    }
42}
43
44//
45//  IterateWithFirst
46//
47
48/// Iterator providing first flag.
49pub struct IterateWithFirst<ItemT, IterableT>
50where
51    IterableT: IntoIterator<Item = ItemT>,
52{
53    iterator: IterableT::IntoIter,
54    first: bool,
55}
56
57impl<ItemT, IterableT> IterateWithFirst<ItemT, IterableT>
58where
59    IterableT: IntoIterator<Item = ItemT>,
60{
61    /// Constructor.
62    pub fn new(iterable: IterableT) -> Self {
63        Self { iterator: iterable.into_iter(), first: true }
64    }
65}
66
67impl<ItemT, IterableT> Iterator for IterateWithFirst<ItemT, IterableT>
68where
69    IterableT: IntoIterator<Item = ItemT>,
70{
71    type Item = (ItemT, bool);
72
73    fn next(&mut self) -> Option<Self::Item> {
74        let first = if self.first {
75            self.first = false;
76            true
77        } else {
78            false
79        };
80
81        self.iterator.next().map(|i| (i, first))
82    }
83}
84
85//
86//  IterateWithLast
87//
88
89/// Iterator providing last flag.
90pub struct IterateWithLast<ItemT, IterableT>
91where
92    IterableT: IntoIterator<Item = ItemT>,
93{
94    iterator: Peekable<IterableT::IntoIter>,
95}
96
97impl<ItemT, IterableT> IterateWithLast<ItemT, IterableT>
98where
99    IterableT: IntoIterator<Item = ItemT>,
100{
101    /// Constructor.
102    pub fn new(iterable: IterableT) -> Self {
103        Self { iterator: iterable.into_iter().peekable() }
104    }
105}
106
107impl<ItemT, IterableT> Iterator for IterateWithLast<ItemT, IterableT>
108where
109    IterableT: IntoIterator<Item = ItemT>,
110{
111    type Item = (ItemT, bool);
112
113    fn next(&mut self) -> Option<Self::Item> {
114        self.iterator.next().map(|i| (i, self.iterator.peek().is_none()))
115    }
116}