cursor 2.3.0

A more free Rust-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
135
136
137
138
139
140
141

#![allow(clippy::while_let_on_iterator)]

use cursor::*;

const SLICE: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const STRING: &str = "this is test. 안녕하세요. 이것은 #&*@( 테스트입니다. ^^ thanks.";

#[derive(Debug)]
struct Counter(pub usize);

impl Counter {
    pub fn _new() -> Self {
        Counter(0)
    }
    fn _clone(&self) -> Self {
        Counter(self.0)
    }
    fn _reset(&mut self) {
        self.0 = 0;
    }
}

impl Extras<u8> for Counter {
    fn new() -> Self {
        Counter::_new()
    }
    fn clone(&self) -> Self {
        self._clone()
    }
    fn reset(&mut self) {
        self._reset()
    }
    fn change(&mut self, input: &u8, _pos: usize) {
        if input % 2 == 0 {
            self.0 += 1;
        }
    }
}

impl Extras<char> for Counter {
    fn new() -> Self {
        Counter::_new()
    }
    fn clone(&self) -> Self {
        self._clone()
    }
    fn reset(&mut self) {
        self._reset()
    }
    fn change(&mut self, input: &char, _pos: usize) {
        if *input == ' ' {
            self.0 += 1;
        }
    }
}

fn main() {
    example1();
    example2();
    example3();
    example4();
    // TODO: more examples
    println!();
}

#[inline]
fn example1() {
    // even counter
    let mut cursor = Cursor::new_with_extras::<Counter>(SLICE);

    cursor.next_to_last();

    let extra = cursor.into_extras();

    assert_eq!(extra.0, 5);
    println!("{:?}", extra);
}

#[inline]
fn example2() {
    // space counter
    let mut cursor = StrCursor::new_with_extras::<Counter>(STRING);

    cursor.next_to_last();

    let extra = cursor.into_extras();

    assert_eq!(extra.0, 8);
    println!("{:?}", extra);
}

#[inline]
fn example3() {
    let mut cursor = StrCursor::new(STRING);
    cursor += 4;
    assert_eq!(cursor.current(), ' ');

    while let Some(ch) = &mut cursor + 1 {
        if let Some(next) = match ch {
            ' ' => &mut cursor + 1,
            '.' => &mut cursor + 2,
            _ => None,
        } {
            print!("{}", next);
        }
    }
}

#[inline]
fn example4() {
    let mut cursor = StrCursor::new(STRING);
    cursor.save();
    assert_eq!(cursor.saved().pos, 0);

    cursor += 4;
    assert_eq!(cursor.current(), ' ');

    assert_eq!(cursor.as_str_loaded(), "this ");

    cursor.save();
    assert_eq!(cursor.saved().pos, 4);

    cursor -= 2;
    assert_eq!(cursor.current(), 'i');

    assert_eq!(cursor.as_str_loaded(), "is ");

    let mut cursor = StrCursor::new("한글테스트^^");
    cursor.save();
    assert_eq!(cursor.saved().pos, 0);

    cursor += 4;
    assert_eq!(cursor.current(), '트');

    assert_eq!(cursor.as_str_loaded(), "한글테스트");

    cursor.save();
    cursor -= 2;

    assert_eq!(cursor.as_str_loaded(), "테스트");
}