vu64 0.3.0

variable length encode/decode for a 64-bits integer
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

#[cfg(test)]
mod test5 {
    use std::io::{self, Cursor, Read, Write};
    use vu64::io::{ReadVu64, WriteVu64};

    // A custom reader that reads data in small, fixed-size chunks.
    struct ChunkedReader<R: Read> {
        inner: R,
        chunk_size: usize,
    }

    impl<R: Read> Read for ChunkedReader<R> {
        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
            let bytes_to_read = self.chunk_size.min(buf.len());
            self.inner.read(&mut buf[..bytes_to_read])
        }
        }

        // A simple writer that appends to a Vec<u8>.

    struct VecWriter {
        buf: Vec<u8>,
    }

    impl Write for VecWriter {
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
            self.buf.extend_from_slice(buf);
            Ok(buf.len())
        }

        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
    }

    #[test]
    fn test_io_with_custom_reader_and_writer() {
        let values: Vec<u64> = vec![
            0,
            1,
            127,
            128,
            16383,
            16384,
            2097151,
            2097152,
            u64::MAX,
            42,
            999999,
        ];

        // 1. Write values to a VecWriter.
        let mut writer = VecWriter { buf: Vec::new() };
        for &value in &values {
            let result = writer.encode_and_write_vu64(value);
            assert!(result.is_ok());
        }

        // The writer now contains all the encoded bytes.
        let encoded_data = writer.buf;

        // 2. Read values back with a ChunkedReader.
        // We will try various chunk sizes to test robustness.
        for chunk_size in 1..=10 {
            let cursor = Cursor::new(encoded_data.clone());
            let mut reader = ChunkedReader {
                inner: cursor,
                chunk_size,
            };

            let mut decoded_values = Vec::new();
            while let Ok(val) = reader.read_and_decode_vu64() {
                decoded_values.push(val);
            }

            assert_eq!(
                decoded_values, values,
                "Failed with chunk size: {}",
                chunk_size
            );
        }
    }

    #[test]
    fn test_signed_io_with_custom_reader_and_writer() {
        let values: Vec<i64> = vec![0, -1, 1, -100, 100, i64::MAX, i64::MIN, 12345, -54321];

        // 1. Write values to a VecWriter.
        let mut writer = VecWriter { buf: Vec::new() };
        for &value in &values {
            let result = writer.encode_and_write_vi64(value);
            assert!(result.is_ok());
        }

        let encoded_data = writer.buf;

        // 2. Read values back with a ChunkedReader.
        let cursor = Cursor::new(encoded_data);
        let mut reader = ChunkedReader {
            inner: cursor,
            chunk_size: 3, // Just pick one chunk size for this test
        };

        let mut decoded_values = Vec::new();
        while let Ok(val) = reader.read_and_decode_vi64() {
            decoded_values.push(val);
        }

        assert_eq!(decoded_values, values);
    }
}