pub fn decode<T: VarInt>(buf: &[u8]) -> Result<(T, usize), Error>Expand description
Decodes arbitrary VarInt type from varint format
Returns the decoded value and the number of bytes read
§Parameters
buf- Input buffer containing varint encoding
§Errors
- Returns
Error::InputTooShortif the input buffer is insufficient - Returns
Error::InvalidEncodingif the varint encoding is invalid - Returns
Error::Overflowif overflow occurs during decoding
Examples found in repository?
examples/benchmark.rs (line 134)
41fn main() {
42 println!("VarintValue Performance Test");
43 println!("===========================\n");
44
45 // Test parameters
46 const ITERATIONS: usize = 1_000_000;
47
48 // Prepare test data and buffer
49 let test_values = [
50 varint!(u8: 127),
51 varint!(u16: 16383),
52 varint!(u32: 1000000),
53 varint!(i8: -42),
54 varint!(i16: -1000),
55 varint!(i32: -100000),
56 varint!(u64: 1_000_000_000_000),
57 ];
58
59 let mut buffer = [0u8; 20];
60
61 // 1. Test type ID calculation performance
62 let mut benchmark = Benchmark::new("Type ID calculation", ITERATIONS);
63 benchmark.run(|| {
64 for value in &test_values {
65 let _ = value.get_type_id();
66 }
67 });
68 benchmark.report();
69
70 // 2. Test serialization size calculation performance
71 let mut benchmark = Benchmark::new("Serialization size calculation", ITERATIONS);
72 benchmark.run(|| {
73 for value in &test_values {
74 let _ = value.serialized_size();
75 }
76 });
77 benchmark.report();
78
79 // 3. Test serialization performance
80 let mut benchmark = Benchmark::new("VarintValue serialization", ITERATIONS / 10);
81 benchmark.run(|| {
82 for value in &test_values {
83 let _ = value.to_bytes(&mut buffer);
84 }
85 });
86 benchmark.report();
87
88 // Prepare deserialization test
89 let mut encoded_values = Vec::new();
90 let mut positions = Vec::new();
91 let mut pos = 0;
92
93 for value in &test_values {
94 let bytes_written = value.to_bytes(&mut buffer[..]).unwrap();
95 encoded_values.extend_from_slice(&buffer[..bytes_written]);
96 positions.push((pos, bytes_written));
97 pos += bytes_written;
98 }
99
100 // 4. Test deserialization performance
101 let mut benchmark = Benchmark::new("VarintValue deserialization", ITERATIONS / 10);
102 benchmark.run(|| {
103 for (start, len) in &positions {
104 let _ = VarintValue::from_bytes(&encoded_values[*start..*start + *len]);
105 }
106 });
107 benchmark.report();
108
109 // 5. Compare with regular varint encoding (without type information)
110 let u32_values = [127u32, 16383, 1000000];
111 let mut benchmark = Benchmark::new("Regular u32 varint encoding", ITERATIONS);
112 benchmark.run(|| {
113 for value in &u32_values {
114 let _ = encode(*value, &mut buffer);
115 }
116 });
117 benchmark.report();
118
119 // 6. Compare with regular varint decoding (without type information)
120 let mut u32_encoded = Vec::new();
121 let mut u32_positions = Vec::new();
122 let mut pos = 0;
123
124 for value in &u32_values {
125 let bytes_written = encode(*value, &mut buffer).unwrap();
126 u32_encoded.extend_from_slice(&buffer[..bytes_written]);
127 u32_positions.push((pos, bytes_written));
128 pos += bytes_written;
129 }
130
131 let mut benchmark = Benchmark::new("Regular u32 varint decoding", ITERATIONS);
132 benchmark.run(|| {
133 for (start, len) in &u32_positions {
134 let _ = decode::<u32>(&u32_encoded[*start..*start + *len]);
135 }
136 });
137 benchmark.report();
138
139 println!("\nPerformance Summary:");
140 println!("1. VarintValue type information introduces some performance overhead");
141 println!("2. Optimizations (special zero handling, avoiding temporary buffers, etc.) effectively improve performance");
142 println!("3. For scenarios requiring mixed types, the performance cost is acceptable");
143}More examples
examples/basic_usage.rs (line 33)
16fn main() {
17 println!("=== tiny-varint Basic Example (no-alloc version) ===\n");
18
19 // 1. Single unsigned integer encoding/decoding
20 println!("1. Encoding and decoding single unsigned integers:");
21 let values = [0u64, 127, 128, 16383, 16384, 2097151];
22
23 for &value in &values {
24 let mut buf = [0u8; 10];
25 let bytes_written = encode(value, &mut buf).unwrap();
26
27 print!(" Value {} encoded as {} bytes: [ ", value, bytes_written);
28 for i in 0..bytes_written {
29 print!("{:#04x} ", buf[i]);
30 }
31 println!("]");
32
33 let (decoded, bytes_read) = decode::<u64>(&buf).unwrap();
34 println!(" Decoded: {} (read {} bytes)", decoded, bytes_read);
35 println!();
36 }
37
38 // 2. Signed integer zigzag encoding/decoding
39 println!("\n2. ZigZag encoding and decoding of signed integers:");
40 let signed_values = [0i32, 1, -1, 2, -2, 127, -127, 128, -128];
41
42 for &value in &signed_values {
43 let mut buf = [0u8; 10];
44 let bytes_written = encode_zigzag(value, &mut buf).unwrap();
45
46 print!(" Value {} encoded as {} bytes: [ ", value, bytes_written);
47 for i in 0..bytes_written {
48 print!("{:#04x} ", buf[i]);
49 }
50 println!("]");
51
52 let (decoded, bytes_read) = decode_zigzag::<i32>(&buf).unwrap();
53 println!(" Decoded: {} (read {} bytes)", decoded, bytes_read);
54 println!();
55 }
56
57 // 3. Batch processing using VarIntEncoder/VarIntDecoder
58 println!("\n3. Batch processing using VarIntEncoder/VarIntDecoder:");
59 let batch_values = [1u64, 127, 128, 16383, 16384, 2097151];
60 let mut buffer = [0u8; 100];
61
62 // Using encoder
63 let mut encoder = VarIntEncoder::new(&mut buffer);
64 let bytes_written = encoder.write_batch(&batch_values).unwrap();
65
66 println!(" Encoded {} values using {} bytes", batch_values.len(), bytes_written);
67
68 print!(" Encoded bytes: [ ");
69 for i in 0..bytes_written {
70 print!("{:#04x} ", buffer[i]);
71 }
72 println!("]");
73
74 // Using decoder
75 let mut decoder = VarIntDecoder::new(&buffer[..bytes_written]);
76 let mut decoded = [0u64; 6];
77 let count = decoder.read_batch(&mut decoded).unwrap();
78
79 print!(" Decoded values: [ ");
80 for i in 0..count {
81 print!("{} ", decoded[i]);
82 }
83 println!("]");
84 println!(" Read {} bytes in total", decoder.position());
85
86 // 4. Using different integer types
87 println!("\n4. Using different integer types:");
88
89 // Using u64 type
90 let value = 16384u64;
91 let mut buf = [0u8; 10];
92 let size = encode(value, &mut buf).unwrap();
93
94 print!(" u64 value {} encoded as {} bytes: [ ", value, size);
95 for i in 0..size {
96 print!("{:#04x} ", buf[i]);
97 }
98 println!("]");
99
100 let (decoded, bytes_read) = decode::<u64>(&buf).unwrap();
101 println!(" Decoded: {} (read {} bytes)", decoded, bytes_read);
102
103 // Using u32 type
104 let u32_value = 42u32;
105 let mut buf = [0u8; 10];
106 let size = encode(u32_value, &mut buf).unwrap();
107
108 print!(" u32 value {} encoded as {} bytes: [ ", u32_value, size);
109 for i in 0..size {
110 print!("{:#04x} ", buf[i]);
111 }
112 println!("]");
113
114 let (decoded, bytes_read) = decode::<u32>(&buf).unwrap();
115 println!(" Decoded: {} (read {} bytes)", decoded, bytes_read);
116
117 // Using i16 type
118 let i16_value = -256i16;
119 let size = encode(i16_value, &mut buf).unwrap();
120
121 print!(" i16 value {} encoded as {} bytes: [ ", i16_value, size);
122 for i in 0..size {
123 print!("{:#04x} ", buf[i]);
124 }
125 println!("]");
126
127 let (decoded, bytes_read) = decode::<i16>(&buf).unwrap();
128 println!(" Decoded: {} (read {} bytes)", decoded, bytes_read);
129
130 // 5. Error handling
131 println!("\n5. Error handling:");
132 let large_value: u64 = 0xFFFFFFFFFFFFFFFF; // Requires 10 bytes
133 let mut small_buf = [0u8; 5];
134
135 match encode(large_value, &mut small_buf) {
136 Ok(_) => println!(" Encoding successful (should not reach here)"),
137 Err(Error::BufferTooSmall { needed, actual }) => {
138 println!(" Buffer too small: needed {} bytes, but only had {} bytes", needed, actual);
139 }
140 Err(e) => println!(" Error occurred: {:?}", e),
141 }
142
143 // Create an incomplete varint - flag bit is 1 but no following bytes
144 let incomplete_buf = [0x80];
145
146 match decode::<u64>(&incomplete_buf) {
147 Ok(_) => println!(" Decoding successful (should not reach here)"),
148 Err(Error::InputTooShort) => {
149 println!(" Input too short: high bit is 1 indicating more bytes follow, but data ended");
150 }
151 Err(e) => println!(" Error occurred: {:?}", e),
152 }
153
154 println!("\n=== Example Complete ===");
155}