pub fn values_from<'a, T: VarInt>(buf: &'a [u8]) -> VarIntValuesIter<'a, T> ⓘExpand description
Helper function to create a values decoder from a buffer
Examples found in repository?
examples/iter_example.rs (line 58)
15fn main() {
16 println!("=== Iterator-based API Example ===\n");
17
18 // 1. Encoding a single value using VarIntBytesIter iterator
19 println!("1. Encoding a single value using VarIntBytesIter iterator:");
20 let value = 16384u64;
21
22 println!(" Encoding value: {}", value);
23 println!(" Expected bytes: {}", tiny_varint::varint_size(value));
24
25 print!(" Encoded bytes: [ ");
26 for byte in bytes_of(value) {
27 print!("{:#04x} ", byte);
28 }
29 println!("]");
30
31 // Manually verify the result
32 let mut manual_buf = [0u8; 10];
33 let manual_size = tiny_varint::encode(value, &mut manual_buf).unwrap();
34
35 print!(" Verification bytes: [ ");
36 for i in 0..manual_size {
37 print!("{:#04x} ", manual_buf[i]);
38 }
39 println!("]\n");
40
41 // 2. Decoding using VarIntValuesIter iterator
42 println!("2. Decoding using VarIntValuesIter iterator:");
43
44 // Create a buffer containing multiple varints
45 let values = [0u64, 1, 127, 128, 16383, 16384, 2097151];
46 let mut buffer = [0u8; 100];
47
48 let mut encoder = VarIntEncoder::new(&mut buffer);
49 let bytes_written = encoder.write_batch(&values).unwrap();
50
51 print!(" Encoded bytes: [ ");
52 for i in 0..bytes_written {
53 print!("{:#04x} ", buffer[i]);
54 }
55 println!("]");
56
57 println!(" Decoded values:");
58 for result in values_from::<u64>(&buffer[..bytes_written]) {
59 match result {
60 Ok(value) => println!(" - {}", value),
61 Err(e) => println!(" - Error: {:?}", e),
62 }
63 }
64
65 // 3. Processing zigzag-encoded values without intermediate buffers
66 println!("\n3. Processing zigzag-encoded signed values:");
67
68 let signed_values = [-100i32, -50, -10, -1, 0, 1, 10, 50, 100];
69 println!(" Original values: {:?}", signed_values);
70
71 // Create a zigzag-encoded byte iterator for each value
72 for &value in &signed_values {
73 // First apply zigzag encoding
74 let mut buf = [0u8; 10];
75 let size = encode_zigzag(value, &mut buf).unwrap();
76
77 print!(" ZigZag encoding for {}: [ ", value);
78 for i in 0..size {
79 print!("{:#04x} ", buf[i]);
80 }
81 println!("]");
82 }
83
84 // 4. Combining iterators with encoders/decoders
85 println!("\n4. Combining iterators with encoders/decoders in stream processing:");
86
87 // Simulate a simple data processing pipeline
88 println!(" Data processing pipeline:");
89 println!(" 1. Generate raw data");
90 println!(" 2. Encode using iterator-based methods");
91 println!(" 3. Process encoded bytes");
92 println!(" 4. Decode using iterator-based methods");
93
94 // Raw data
95 let source_data = [42u64, 314, 2718, 31415];
96 println!("\n Raw data: {:?}", source_data);
97
98 // Encode and collect
99 let mut encoded_bytes = Vec::new();
100
101 for &value in &source_data {
102 let encoder = bytes_of(value);
103 println!(" Encoding {} -> {} bytes", value, encoder.size());
104
105 // Add bytes to our buffer
106 for byte in encoder {
107 encoded_bytes.push(byte);
108 }
109 }
110
111 print!(" All encoded bytes: [ ");
112 for byte in &encoded_bytes {
113 print!("{:#04x} ", byte);
114 }
115 println!("]");
116
117 // Decode bytes
118 println!("\n Decoding results:");
119 let decoder = values_from::<u64>(&encoded_bytes);
120
121 let mut i = 0;
122 for result in decoder {
123 match result {
124 Ok(value) => {
125 println!(" Original: {}, Decoded: {}", source_data[i], value);
126 i += 1;
127 }
128 Err(e) => println!(" Error: {:?}", e),
129 }
130 }
131
132 println!("\n=== Example Complete ===");
133}