fefix 0.7.0

FIX & FAST (FIX Adapted for STreaming) in pure Rust.
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

use std::iter::FusedIterator;

const SEPARATOR: u8 = b' ';

/// An [`Iterator`] over space-delimited byte sequences in a
/// `MultipleStringValue` FIX field.
///
/// # Example
///
/// ```
/// use fefix::fix_values::MultipleStrings;
///
/// let mut words = MultipleStrings::new(b"foo bar qwerty");
/// assert_eq!(words.next(), Some("foo".as_bytes()));
/// assert_eq!(words.next(), Some("bar".as_bytes()));
/// assert_eq!(words.next(), Some("qwerty".as_bytes()));
/// assert_eq!(words.next(), None);
/// ```
#[derive(Debug, Clone)]
pub struct MultipleStrings<'a> {
    data: &'a [u8],
    i: usize,
}

impl<'a> MultipleStrings<'a> {
    /// Creates a new [`MultipleStrings`] from `data`.
    pub fn new(data: &'a [u8]) -> Self {
        Self { data, i: 0 }
    }
}

impl<'a> Iterator for MultipleStrings<'a> {
    type Item = &'a [u8];

    fn next(&mut self) -> Option<Self::Item> {
        if self.i >= self.data.len() {
            return None;
        }
        let i_start = self.i
            + self.data[self.i..]
                .iter()
                .position(|byte| *byte != SEPARATOR)?;
        let i_end = i_start
            + self.data[i_start..]
                .iter()
                .position(|byte| *byte == SEPARATOR)
                .unwrap_or(self.data.len() - i_start);
        self.i = i_end;
        Some(&self.data[i_start..i_end])
    }
}

impl<'a> FusedIterator for MultipleStrings<'a> {}

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

    #[test]
    fn empty_data_has_no_values() {
        let mut dtf = MultipleStrings::new(&[]);
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn whitespace_has_no_values() {
        let mut dtf = MultipleStrings::new(b"     ");
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn a_single_word_has_one_value() {
        let mut dtf = MultipleStrings::new(b"foobar");
        assert_eq!(dtf.next(), Some(b"foobar" as &[u8]));
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn words_separated_by_space() {
        let mut dtf = MultipleStrings::new(b"foo bar spam");
        assert_eq!(dtf.next(), Some(b"foo" as &[u8]));
        assert_eq!(dtf.next(), Some(b"bar" as &[u8]));
        assert_eq!(dtf.next(), Some(b"spam" as &[u8]));
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn word_with_trailing_space() {
        let mut dtf = MultipleStrings::new(b"foo ");
        assert_eq!(dtf.next(), Some(b"foo" as &[u8]));
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn words_with_trailing_spaces() {
        let mut dtf = MultipleStrings::new(b"foo  bar    ");
        assert_eq!(dtf.next(), Some(b"foo" as &[u8]));
        assert_eq!(dtf.next(), Some(b"bar" as &[u8]));
        assert_eq!(dtf.next(), None);
    }

    #[test]
    fn words_with_leading_spaces() {
        let mut dtf = MultipleStrings::new(b"  \t  bar spam");
        assert_eq!(dtf.next(), Some(b"\t" as &[u8]));
        assert_eq!(dtf.next(), Some(b"bar" as &[u8]));
        assert_eq!(dtf.next(), Some(b"spam" as &[u8]));
        assert_eq!(dtf.next(), None);
    }
}