shadow_counted 0.7.0

An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
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

use shadow_counted::{IntoShadowCounted, ShadowCountedIter};

/// Test basic iteration counting
#[test]
fn test_count_simple_iteration() {
    let data = vec![1, 2, 3, 4, 5];
    let mut iter = data.into_iter().shadow_counted();

    assert_eq!(iter.counter(), 0);
    iter.next();
    assert_eq!(iter.counter(), 1);
    iter.next();
    assert_eq!(iter.counter(), 2);

    // Consume the rest
    for _ in iter.by_ref() {}
    assert_eq!(iter.counter(), 5);
}

/// Test iteration with empty iterator
#[test]
fn test_empty_iterator_count() {
    let data: Vec<i32> = vec![];
    let mut iter = data.into_iter().shadow_counted();

    assert_eq!(iter.counter(), 0);
    assert!(iter.next().is_none());
    assert_eq!(iter.counter(), 0);
}

/// Test single element iteration
#[test]
fn test_single_element() {
    let data = vec![42];
    let mut iter = data.into_iter().shadow_counted();

    assert_eq!(iter.counter(), 0);
    assert_eq!(iter.next(), Some(42));
    assert_eq!(iter.counter(), 1);
    assert!(iter.next().is_none());
    assert_eq!(iter.counter(), 1);
}

/// Test counter increments only on successful next()
#[test]
fn test_counter_only_increments_on_next() {
    let data = vec![1, 2];
    let mut iter = data.into_iter().shadow_counted();

    assert_eq!(iter.counter(), 0);
    iter.next();
    assert_eq!(iter.counter(), 1);
    iter.next();
    assert_eq!(iter.counter(), 2);
    // No more items
    iter.next();
    assert_eq!(iter.counter(), 2); // Counter doesn't increment
    iter.next();
    assert_eq!(iter.counter(), 2); // Still doesn't increment
}

/// Test iteration with different types
#[test]
fn test_different_types() {
    // Strings
    let strings = vec!["a", "b", "c"];
    let mut iter = strings.into_iter().shadow_counted();
    for _ in iter.by_ref() {}
    assert_eq!(iter.counter(), 3);

    // Tuples
    let tuples = vec![(1, 2), (3, 4)];
    let mut iter = tuples.into_iter().shadow_counted();
    for _ in iter.by_ref() {}
    assert_eq!(iter.counter(), 2);
}

/// Test into_inner_iter
#[test]
fn test_into_inner_iter() {
    let data = vec![1, 2, 3, 4, 5];
    let mut iter = data.into_iter().shadow_counted();

    iter.next(); // consume one
    assert_eq!(iter.counter(), 1);

    let inner = iter.into_inner_iter();
    assert_eq!(inner.collect::<Vec<_>>(), vec![2, 3, 4, 5]);
}

/// Test that add() method increments counter
#[test]
fn test_add_method() {
    let data = vec![1, 2, 3];
    let mut iter = data.into_iter().shadow_counted();

    assert_eq!(iter.counter(), 0);
    iter.add(5);
    assert_eq!(iter.counter(), 5);
    iter.next();
    assert_eq!(iter.counter(), 6);
}

/// Test From trait implementation
#[test]
fn test_from_trait() {
    let vec = vec![1, 2, 3];
    let iter: ShadowCountedIter<_, _> = vec.into_iter().into();
    let count = iter.count();
    assert_eq!(count, 3);
}