flexible-io 0.4.0

Wraps values such that dyn-safe IO traits need not appear as static bounds
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

use flexible_io::{Reader, Writer};

#[test]
fn reader_reuses() {
    let data: &'static [u8] = b"Hello, world!";
    let mut read = Reader::new(std::io::Cursor::new(data));

    {
        let mut inner = read.as_mut();
        // This is also for miri, check some aliasing assumptions.
        let _ = inner.as_seek_mut();
        assert!(inner.as_seek_mut().is_none());
        let _ = inner.as_read_mut().read(&mut []);
    }

    read.set_seek();

    {
        let mut inner = read.as_mut();
        inner.as_seek_mut();
        let _ = inner.as_seek_mut();
        assert!(inner.as_seek_mut().is_some());
        let _ = inner.as_read_mut().read(&mut []);
    }

    read.into_inner();
}

#[test]
fn writer_reuses() {
    let data: &mut [u8] = &mut { *b"Hello, world!" };
    let mut write = Writer::new(std::io::Cursor::new(data));

    {
        let mut inner = write.as_mut();
        // This is also for miri, check some aliasing assumptions.
        let _ = inner.as_seek_mut();
        assert!(inner.as_seek_mut().is_none());
        let _ = inner.as_write_mut().write(&[]);
    }

    write.set_seek();

    {
        let mut inner = write.as_mut();
        inner.as_seek_mut();
        let _ = inner.as_seek_mut();
        assert!(inner.as_seek_mut().is_some());
        let _ = inner.as_write_mut().write(&[]);
    }

    write.into_inner();
}

#[test]
fn writer_any() {
    let data: Vec<u8> = b"Hello, world!".to_vec();
    let mut write = Writer::new(std::io::Cursor::new(data));

    {
        let mut inner = write.as_mut();
        assert!(inner.as_any().is_none());
        assert!(inner.as_any_mut().is_none());
    }

    write.set_any();

    {
        let mut inner = write.as_mut();
        assert!(inner.as_any().is_some());
        assert!(inner.as_any_mut().is_some());

        type Inner = std::io::Cursor<Vec<u8>>;
        assert!(inner
            .as_any()
            .and_then(|v| v.downcast_ref::<Inner>())
            .is_some());
    }
}

#[test]
fn reader_any() {
    let data: Vec<u8> = b"Hello, world!".to_vec();
    let mut write = Reader::new(std::io::Cursor::new(data));

    {
        let mut inner = write.as_mut();
        assert!(inner.as_any().is_none());
        assert!(inner.as_any_mut().is_none());
    }

    write.set_any();

    {
        let mut inner = write.as_mut();
        assert!(inner.as_any().is_some());
        assert!(inner.as_any_mut().is_some());

        type Inner = std::io::Cursor<Vec<u8>>;
        assert!(inner
            .as_any()
            .and_then(|v| v.downcast_ref::<Inner>())
            .is_some());
    }
}