tiny_varint/
lib.rs

1#![no_std]
2
3//! # tiny-varint
4//!
5//! A high-performance variable-length integer (VarInt) encoding/decoding library, 
6//! fully compatible with no_std environments.
7//!
8//! VarInt is an efficient way to encode integers into byte sequences, using fewer 
9//! bytes for smaller values. It's widely used in protocol buffers, data compression, 
10//! and network transmission scenarios.
11//!
12//! ## Features
13//!
14//! * **Generic Integer Support**: Works with all integer types (u8-u128, i8-i128)
15//! * **Batch Processing API**: Efficiently handle multiple values with state management
16//! * **Iterator-based API**: Memory-efficient processing using iterator methods
17//! * **Basic Encoding Functions**: Low-level functions for direct use
18//! * **ZigZag Support**: Efficient encoding of signed integers
19//! * **No-std Compatible**: Works in embedded environments
20//!
21//! ## Usage Examples
22//!
23//! ### Generic API with different integer types
24//! 
25//! ```rust
26//! use tiny_varint::{encode, decode};
27//! 
28//! // Works with any integer type
29//! let mut buf = [0u8; 10];
30//! 
31//! // Use with u32
32//! let bytes_written = encode(42u32, &mut buf).unwrap();
33//! let (value, bytes_read) = decode::<u32>(&buf).unwrap();
34//! assert_eq!(value, 42u32);
35//! 
36//! // Use with i16
37//! let bytes_written = encode(-42i16, &mut buf).unwrap();
38//! let (value, bytes_read) = decode::<i16>(&buf).unwrap();
39//! assert_eq!(value, -42i16);
40//! ```
41//!
42//! ### Batch API
43//! 
44//! ```rust
45//! use tiny_varint::{VarIntEncoder, VarIntDecoder};
46//! 
47//! // Encode multiple values
48//! let values = [1u64, 127, 128, 16383, 16384];
49//! let mut buffer = [0u8; 100];
50//! 
51//! let mut encoder = VarIntEncoder::new(&mut buffer);
52//! let bytes_written = encoder.write_batch(&values).unwrap();
53//! 
54//! // Decode multiple values
55//! let mut decoded = [0u64; 5];
56//! let mut decoder = VarIntDecoder::new(&buffer[..bytes_written]);
57//! decoder.read_batch(&mut decoded).unwrap();
58//! ```
59//! 
60//! ### Iterator-based API
61//! 
62//! ```rust
63//! use tiny_varint::{bytes_of, values_from};
64//! 
65//! // Encode a value into bytes using iterator methods
66//! let value = 16384u64;
67//! for byte in bytes_of(value) {
68//!     // Process each byte individually
69//!     println!("{:02X}", byte);
70//! }
71//! 
72//! // Decode values from a byte buffer using iterator methods
73//! let buffer = [0x80, 0x80, 0x01]; // Encoded value 16384
74//! for result in values_from::<u64>(&buffer) {
75//!     match result {
76//!         Ok(value) => println!("Decoded: {}", value),
77//!         Err(e) => println!("Error: {:?}", e),
78//!     }
79//! }
80//! ```
81
82// Import zigzag-rs for ZigZag encoding/decoding
83extern crate zigzag_rs;
84
85// Define modules
86mod error;
87mod traits;
88mod encoding;
89mod batch;
90mod iter;
91mod zigzag;
92#[cfg(test)]
93mod tests;
94
95// Re-export all public items
96pub use error::Error;
97pub use traits::VarInt;
98pub use encoding::{encode, decode, varint_size};
99pub use zigzag::{ZigZag, encode_zigzag, decode_zigzag};
100pub use batch::{VarIntEncoder, VarIntDecoder, encode_batch, decode_batch};
101pub use iter::{VarIntBytesIter, VarIntValuesIter, bytes_of, values_from};
tiny_varint/lib.rs

tiny_varint/
lib.rs
