# Bin-It
**Bin-It** is a simple, efficient Rust library for binary serialization and deserialization. With a focus on
performance and ease of use, Bin-It lets you seamlessly serialize Rust types into compact binary formats and
read them back with precision. Whether you're storing data in binary files, transmitting data over networks,
or handling low-level byte operations, **Bin-It** has you covered.
## Features
- Serialize and deserialize common primitive types (`u8`, `i16`, `f32`, etc.).
- Supports serialization of strings and collections (e.g., `Vec<u8>`, `Vec<f64>`, etc.).
- Consistent, little-endian encoding for cross-platform compatibility.
- Minimal dependencies for fast, lightweight binary manipulation.
## Usage
### Writing Data
The BinaryWriter struct allows you to serialize various data types into a binary buffer:
```rust
use bin_it::BinaryWriter;
fn main() {
let mut writer = BinaryWriter::new();
writer.write_u32(42);
writer.write_string("Hello, Bin-It!");
writer.write_f64(3.14159);
let data = writer.get_data();
// Now `data` contains the binary representation of the serialized values.
}
```
### Reading Data
The BinaryReader struct lets you deserialize the binary data back into Rust types:
```rust
use bin_it::BinaryReader;
fn main() {
let data = vec![42, /* binary data goes here */];
let mut reader = BinaryReader::new(&data);
let number = reader.read_u32().unwrap();
let text = reader.read_string().unwrap();
let pi = reader.read_f64().unwrap();
println!("Number: {}", number);
println!("Text: {}", text);
println!("Pi: {}", pi);
}
```
## Supported Data Types
**Bin-It** supports writing and reading of:
* Primitives: u8, i8, u16, i16, u32, i32, u64, i64, f32, f64, and bool.
* Strings: UTF-8 strings serialized with length-prefix encoding.
* Collections: Fixed-size collections, such as Vec<T> for supported types.