insert_multiple 0.2.0

insert multiple items into a stream in reasonable runtime
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

use inserter::Inserter;
use std::io::{self, Cursor};
use std::string::FromUtf8Error;

type Insertions<'i> = Vec<(usize, &'i str)>;

#[derive(Debug)]
pub enum Error {
    IoError(io::Error),
    Utf8Error(FromUtf8Error),
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Error {
        Error::IoError(err)
    }
}

impl From<FromUtf8Error> for Error {
    fn from(err: FromUtf8Error) -> Error {
        Error::Utf8Error(err)
    }
}

/// inserter keeps track of origin, target writer, and all points of insertion
pub struct StringInserter<'o, 'i> {
    origin: &'o str,
    insertions: Insertions<'i>,
}

impl<'o, 'i> StringInserter<'o, 'i> {
    /// create a new inserter with the specified origin document and target
    pub fn new(origin: &'o str) -> StringInserter<'o, 'i> {
        StringInserter {
            origin: origin,
            insertions: Insertions::new(),
        }
    }

    /// insert the source document into the output document at the given origin index
    pub fn insert(mut self, position: usize, source: &'i str) -> Self {
        self.insertions.push((position, source));
        self
    }

    /// execute this inserter, consuming it
    pub fn execute(self) -> Result<String, Error> {
        // this just delegates to Inserter, of course
        let mut buffer: Vec<u8> = Vec::with_capacity(
            self.origin.len() + self.insertions.iter().map(|(_, i)| i.len()).sum::<usize>(),
        );
        {
            let mut inserter = Inserter::new(self.origin.as_bytes(), Cursor::new(&mut buffer));
            for (position, item) in self.insertions.iter() {
                inserter = inserter.insert(*position, item.as_bytes());
            }
            if let Err(err) = inserter.execute() {
                return Err(err.into());
            }
        }

        String::from_utf8(buffer).map_err(|e| e.into())
    }
}

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

    #[test]
    fn insert_one_at_beginning() {
        let origin = "fghij";
        let insertion = "abcde";

        let out = StringInserter::new(origin)
            .insert(0, insertion)
            .execute()
            .unwrap();

        assert_eq!("abcdefghij", &out);
    }

    #[test]
    fn insert_one_at_end() {
        let origin = "abcde";
        let insertion = "fghij";

        let out = StringInserter::new(origin)
            .insert(origin.len(), insertion)
            .execute()
            .unwrap();

        assert_eq!("abcdefghij", &out);
    }

    #[test]
    fn insert_one_past_end() {
        let origin = "abcde";
        let insertion = "klmno";

        let out = StringInserter::new(origin)
            .insert(origin.len() * 2, insertion)
            .execute()
            .unwrap();

        assert_eq!("abcdeklmno", &out);
    }

    #[test]
    fn interleave() {
        let origin = "alpha bravo delta hotel";
        let out = StringInserter::new(origin)
            .insert(12, "charlie ")
            .insert(18, "echo fox golf ")
            .execute()
            .unwrap();

        assert_eq!("alpha bravo charlie delta echo fox golf hotel", &out);
    }
}