memoverlay 0.1.3

Puts a writable layer of bytes over some byte stream
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

//! 
//! ```txt
//! +-----------------+------------+-----------------+-------+----------------------+-------+-----------------+
//! |    chunk 0      |  chunk 1   |    chunk 2      |   3   |       chunk 4        |   5   |     chunk 6     |
//! +-----------------+------------+-----------------+-------+----------------------+-------+-----------------+
//!
//!                                +-----------------+       +----------------------+
//!                                +-----------------+       +----------------------+
//!                   +-------------------+                           +---------------------+
//!                   +-------------------+                           +---------------------+
//! +---------------------------------------------------------------------------------------------------------+
//! +---------------------------------------------------------------------------------------------------------+
//! ```
//! 
//! # Usage example
//! 
//! ```
//! # use std::error::Error;
//! use std::io::{Cursor, Read, Seek, SeekFrom};
//! use memoverlay::MemOverlay;
//! use memoverlay::overlay;
//! 
//! # fn main() -> Result<(), Box<dyn Error>> {
//! let message1 = "hello, world!";
//! let mut overlay = overlay!(message1.as_bytes());
//! overlay.add_bytes_at(7, "peter".as_bytes()).unwrap();
//!
//! let mut message2 = String::new();
//! let _ = overlay.read_to_string(&mut message2).unwrap();
//!
//! assert_eq!(message2, "hello, peter!");
//! # Ok(())
//! # }
//! ```

mod memoverlay;
mod patch;
mod traits;
mod error;
mod patch_layer;
mod patch_search_result;

pub use crate::memoverlay::*;
pub use patch::*;
pub use traits::*;
pub use error::*;
pub use patch_layer::*;
pub use patch_search_result::*;

#[macro_export]
macro_rules! overlay {
    ($s: expr) => {
        MemOverlay::from(Cursor::new($s))
    };
}

#[cfg(test)]
mod tests {
    use crate::MemOverlay;
    use std::io::{Cursor, Read, SeekFrom, Seek};

    #[test]
    fn double_mod_single_byte() {
        let message1 = "hello, world!";
        let mut overlay = overlay!(message1.as_bytes());
        overlay.add_bytes_at(1, "a".as_bytes()).unwrap();
        overlay.add_bytes_at(1, "o".as_bytes()).unwrap();

        let mut message2 = String::new();
        let _ = overlay.read_to_string(&mut message2).unwrap();
        assert_eq!(message2, "hollo, world!");
    }

    #[test]
    fn double_mod_multiple_bytes() {
        let message1 = "hello, world!";
        let mut overlay = overlay!(message1.as_bytes());
        overlay.add_bytes_at(7, "peter".as_bytes()).unwrap();
        overlay.add_bytes_at(7, "claus".as_bytes()).unwrap();

        let mut message2 = String::new();
        let _ = overlay.read_to_string(&mut message2).unwrap();
        assert_eq!(message2, "hello, claus!");
    }


    #[test]
    fn double_mod_overlapping1() {
        let message1 = "hello, world!";
        let mut overlay = overlay!(message1.as_bytes());
        overlay.add_bytes_at(3, "XXXX".as_bytes()).unwrap();
        overlay.add_bytes_at(5, "YYYY".as_bytes()).unwrap();

        let mut message2 = String::new();
        let _ = overlay.read_to_string(&mut message2).unwrap();
        assert_eq!(message2, "helXXYYYYrld!");
    }

    #[test]
    fn double_mod_overlapping2() {
        let message1 = "hello, world!";
        let mut overlay = overlay!(message1.as_bytes());
        overlay.add_bytes_at(5, "YYYY".as_bytes()).unwrap();
        overlay.add_bytes_at(3, "XXXX".as_bytes()).unwrap();

        let mut message2 = String::new();
        let _ = overlay.read_to_string(&mut message2).unwrap();
        assert_eq!(message2, "helXXXXYYrld!");
    }

    #[test]
    fn doc_test() {
        let message1 = "hello, world!";
        let mut overlay = overlay!(message1.as_bytes());
        overlay.add_bytes_at(7, "peter".as_bytes()).unwrap();
        
        let mut message2 = String::new();
        let _ = overlay.read_to_string(&mut message2).unwrap();
        overlay.seek(SeekFrom::Start(0)).unwrap();
        
        assert_eq!(message2, "hello, peter!");
        
        overlay.add_bytes_at(1, "a".as_bytes()).unwrap();
        let mut message3 = String::new();
        let _ = overlay.read_to_string(&mut message3).unwrap();
        overlay.seek(SeekFrom::Start(0)).unwrap();
        assert_eq!(message3, "hallo, peter!");
        
        overlay.add_bytes_at(1, "o".as_bytes()).unwrap();
        overlay.add_bytes_at(5, "w".as_bytes()).unwrap();
        let mut message4 = String::new();
        let _ = overlay.read_to_string(&mut message4).unwrap();
        assert_eq!(message4, "hollow peter!");
    }
}