# PKBuffer
```PKBuffer``` is a simple but flexible buffer library for reading and writing data to byte buffers using safe byte-copy operations. It was born of multiple memory parsing scenarios such as executable header parsing and game ROM memory mapping. Its name comes from the magic that is casting arbitrary structure definitions at byte buffers and the fact that I was reverse engineering the game [EarthBound](https://en.wikipedia.org/wiki/EarthBound) at the time.
You can read the documentation [here](https://docs.rs/pkbuffer/), and see various use examples in [the test file](https://github.com/frank2/pkbuffer/blob/main/src/tests.rs). The changelog can be found [here](https://github.com/frank2/pkbuffer/blob/main/CHANGELOG.md).
## Quick Start
```rust
use pkbuffer::{Buffer, VecBuffer};
let mut buffer = VecBuffer::new();
buffer.append_val::<u8>(&0x1);
buffer.append_val::<u16>(&0x0302);
buffer.append_val::<u32>(&0x07060504);
assert_eq!(buffer, [1, 2, 3, 4, 5, 6, 7]);
```
## Aligned Reference Access (0.7.0+)
For well-aligned data, use `get_aligned_ref` and `get_aligned_mut` to get direct references:
```rust
use pkbuffer::{Buffer, VecBuffer};
let mut buffer = VecBuffer::with_initial_size(16);
buffer.write_val::<u32>(0, &0xDEADBEEF).unwrap();
// Get a reference at an aligned offset
let val: &u32 = buffer.get_aligned_ref(0).unwrap();
assert_eq!(*val, 0xDEADBEEF);
// Get a mutable reference for in-place modification
let val: &mut u32 = buffer.get_aligned_mut(0).unwrap();
*val = 0xFEEDFACE; // writes directly to buffer
// Misaligned access returns an error
assert!(buffer.get_aligned_ref::<u32>(1).is_err());
// Error::AlignmentMismatch(offset, required_alignment)
```
## Key Features
- **Safe byte-copy reads/writes**: Use `read_val<T>()` and `write_val<T>()` to read/write any `Copy` type without alignment requirements
- **Two buffer types**: `PtrBuffer` for unowned memory and `VecBuffer` for owned data
- **Rich search functionality**: Search for byte patterns with `search()` and dynamic patterns with wildcards via `search_dynamic()`
- **No unsafe pointer casting**: All type conversions use safe byte-copying instead of pointer casting
- **Aligned reference access**: `get_aligned_ref` and `get_aligned_mut` provide direct references with alignment verification
## API Changes in 0.6.0
This version removes the `Castable` trait and all methods that relied on unsafe pointer casting for type conversions. The new API uses safe byte-copy operations exclusively:
- `read_val<T: Copy>(offset)` replaces `get_ref<T: Castable>(offset)`
- `write_val<T: Copy>(offset, &data)` replaces `write_ref<T: Castable>(offset, &data)`
- `search(bytes)` replaces `search_ref(data)`
- `contains(bytes)` replaces `contains_ref(data)`
All `Copy` types (primitives like `u8`, `u16`, `u32`, etc.) work directly with the new API. No trait derivations required.