Skip to content

Commit d5b4419

Browse files
terahlunahterahlunah
committed
Improved the api to use more common method names
1 parent dbb73a7 commit d5b4419

File tree

5 files changed

+180
-75
lines changed

5 files changed

+180
-75
lines changed

‎Cargo.toml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "bytebuffer-rs"
3-
version = "1.0.0"
3+
version = "2.0.0"
44
authors = ["Terah <[email protected]>", "Shiroy <[email protected]>"]
55
description = "A bytebuffer for networking and binary protocols"
66
homepage = "https://github.com/terahlunah/bytebuffer-rs"

‎README.md

Lines changed: 51 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,55 @@
22
[![docs.rs](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.rs/bytebuffer-rs)
33
[![CI Checks](https://github.com/terahlunah/bytebuffer-rs/actions/workflows/rust.yml/badge.svg?branch=master)](https://github.com/terahlunah/bytebuffer-rs/actions/workflows/rust.yml)
44

5-
## License
5+
### A bytebuffer implementation for Rust
6+
7+
---
8+
9+
This crate provides an easy to use api to read / write data from / to a bunch of bytes.
10+
11+
12+
```rust
13+
use bytebuffer::ByteBuffer;
14+
15+
let mut buffer = ByteBuffer::new();
16+
buffer.write_bytes(&vec![0x1, 0xFF, 0x45]);
17+
buffer.write_u8(1);
18+
buffer.write_i8(1);
19+
buffer.write_u16(1);
20+
buffer.write_i16(1);
21+
buffer.write_u32(1);
22+
buffer.write_i32(1);
23+
buffer.write_u64(1);
24+
buffer.write_i64(1);
25+
buffer.write_f32(0.1);
26+
buffer.write_f64(0.1);
27+
buffer.write_string("Hello");
28+
buffer.write_bit(true);
29+
buffer.write_bits(4, 3);
30+
buffer.flush_bits();
31+
32+
let data = buffer.into_bytes();
33+
34+
let mut buffer = ByteBuffer::from_vec(data);
35+
let _ = buffer.read_bytes(3);
36+
let _ = buffer.read_u8();
37+
let _ = buffer.read_i8();
38+
let _ = buffer.read_u16();
39+
let _ = buffer.read_i16();
40+
let _ = buffer.read_u32();
41+
let _ = buffer.read_i32();
42+
let _ = buffer.read_u64();
43+
let _ = buffer.read_i64();
44+
let _ = buffer.read_f32();
45+
let _ = buffer.read_f64();
46+
let _ = buffer.read_string();
47+
let _ = buffer.read_bit();
48+
let _ = buffer.read_bits(3);
49+
```
50+
51+
---
52+
53+
### License
654

755
Licensed under either of
856

@@ -11,6 +59,8 @@ Licensed under either of
1159

1260
at your option.
1361

62+
---
63+
1464
### Contribution
1565

1666
Unless you explicitly state otherwise, any contribution intentionally submitted

‎rust-toolchain.toml

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
[toolchain]
2+
channel = "nightly"

‎src/lib.rs

Lines changed: 84 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,14 @@ use std::{
55
};
66

77
/// An enum to represent the byte order of the ByteBuffer object
8-
#[derive(Debug, Clone, Copy)]
8+
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
99
pub enum Endian {
1010
BigEndian,
1111
LittleEndian,
1212
}
1313

1414
/// A byte buffer object specifically turned to easily read and write binary values
15-
#[derive(Clone)]
15+
#[derive(Clone, PartialEq, Eq, Hash)]
1616
pub struct ByteBuffer {
1717
data: Vec<u8>,
1818
wpos: usize,
@@ -22,9 +22,74 @@ pub struct ByteBuffer {
2222
endian: Endian,
2323
}
2424

25+
impl From<Vec<u8>> for ByteBuffer {
26+
fn from(val: Vec<u8>) -> Self {
27+
ByteBuffer::from_vec(val)
28+
}
29+
}
30+
31+
impl From<ByteBuffer> for Vec<u8> {
32+
fn from(val: ByteBuffer) -> Self {
33+
val.into_bytes()
34+
}
35+
}
36+
37+
impl Default for ByteBuffer {
38+
fn default() -> Self {
39+
Self::new()
40+
}
41+
}
42+
43+
impl Read for ByteBuffer {
44+
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
45+
self.flush_bits();
46+
let read_len = std::cmp::min(self.data.len() - self.rpos, buf.len());
47+
let range = self.rpos..self.rpos + read_len;
48+
for (i, val) in self.data[range].iter().enumerate() {
49+
buf[i] = *val;
50+
}
51+
self.rpos += read_len;
52+
Ok(read_len)
53+
}
54+
}
55+
56+
impl Write for ByteBuffer {
57+
fn write(&mut self, buf: &[u8]) -> Result<usize> {
58+
self.write_bytes(buf);
59+
Ok(buf.len())
60+
}
61+
62+
fn flush(&mut self) -> Result<()> {
63+
Ok(())
64+
}
65+
}
66+
67+
impl Debug for ByteBuffer {
68+
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
69+
let rpos = if self.rbit > 0 {
70+
self.rpos + 1
71+
} else {
72+
self.rpos
73+
};
74+
75+
let read_len = self.data.len() - rpos;
76+
let mut remaining_data = vec![0; read_len];
77+
let range = rpos..rpos + read_len;
78+
for (i, val) in self.data[range].iter().enumerate() {
79+
remaining_data[i] = *val;
80+
}
81+
82+
write!(
83+
f,
84+
"ByteBuffer {{ remaining_data: {:?}, total_data: {:?}, endian: {:?} }}",
85+
remaining_data, self.data, self.endian
86+
)
87+
}
88+
}
89+
2590
macro_rules! read_number {
2691
($self:ident, $name:ident, $offset:expr) => {{
27-
$self.flush_bit();
92+
$self.flush_bits();
2893
if $self.rpos + $offset > $self.data.len() {
2994
return Err(Error::new(
3095
ErrorKind::UnexpectedEof,
@@ -41,12 +106,6 @@ macro_rules! read_number {
41106
}};
42107
}
43108

44-
impl Default for ByteBuffer {
45-
fn default() -> Self {
46-
Self::new()
47-
}
48-
}
49-
50109
impl ByteBuffer {
51110
/// Construct a new, empty, ByteBuffer
52111
pub fn new() -> ByteBuffer {
@@ -144,7 +203,7 @@ impl ByteBuffer {
144203
/// buffer.write_bytes(&vec![0x1, 0xFF, 0x45]); // buffer contains [0x1, 0xFF, 0x45]
145204
/// ```
146205
pub fn write_bytes(&mut self, bytes: &[u8]) {
147-
self.flush_bit();
206+
self.flush_bits();
148207

149208
let size = bytes.len() + self.wpos;
150209

@@ -322,7 +381,7 @@ impl ByteBuffer {
322381
/// available.
323382
/// _Note_: This method resets the read and write cursor for bitwise reading.
324383
pub fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>> {
325-
self.flush_bit();
384+
self.flush_bits();
326385
if self.rpos + size > self.data.len() {
327386
return Err(Error::new(
328387
ErrorKind::UnexpectedEof,
@@ -347,7 +406,7 @@ impl ByteBuffer {
347406
/// let value = buffer.read_u8().unwrap(); //Value contains 1
348407
/// ```
349408
pub fn read_u8(&mut self) -> Result<u8> {
350-
self.flush_bit();
409+
self.flush_bits();
351410
if self.rpos >= self.data.len() {
352411
return Err(Error::new(
353412
ErrorKind::UnexpectedEof,
@@ -483,8 +542,13 @@ impl ByteBuffer {
483542
self.wpos = std::cmp::min(wpos, self.data.len());
484543
}
485544

486-
/// Return the raw byte buffer.
487-
pub fn to_bytes(&self) -> Vec<u8> {
545+
/// Return the raw byte buffer bytes.
546+
pub fn as_bytes(&self) -> &[u8] {
547+
&self.data
548+
}
549+
550+
/// Return the raw byte buffer as a Vec<u8>.
551+
pub fn into_bytes(&self) -> Vec<u8> {
488552
self.data.to_vec()
489553
}
490554

@@ -512,7 +576,7 @@ impl ByteBuffer {
512576
let bit = self.data[self.rpos] & (1 << (7 - self.rbit)) != 0;
513577
self.rbit += 1;
514578
if self.rbit > 7 {
515-
self.flush_rbit();
579+
self.flush_rbits();
516580
}
517581
Ok(bit)
518582
}
@@ -559,21 +623,21 @@ impl ByteBuffer {
559623
/// 10010010 | 00000001 // flush_bit() called
560624
/// ^
561625
/// ```
562-
pub fn flush_bit(&mut self) {
626+
pub fn flush_bits(&mut self) {
563627
if self.rbit > 0 {
564-
self.flush_rbit();
628+
self.flush_rbits();
565629
}
566630
if self.wbit > 0 {
567-
self.flush_wbit();
631+
self.flush_wbits();
568632
}
569633
}
570634

571-
fn flush_rbit(&mut self) {
635+
fn flush_rbits(&mut self) {
572636
self.rpos += 1;
573637
self.rbit = 0
574638
}
575639

576-
fn flush_wbit(&mut self) {
640+
fn flush_wbits(&mut self) {
577641
self.wpos += 1;
578642
self.wbit = 0
579643
}
@@ -620,50 +684,3 @@ impl ByteBuffer {
620684
}
621685
}
622686
}
623-
624-
impl Read for ByteBuffer {
625-
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
626-
self.flush_bit();
627-
let read_len = std::cmp::min(self.data.len() - self.rpos, buf.len());
628-
let range = self.rpos..self.rpos + read_len;
629-
for (i, val) in self.data[range].iter().enumerate() {
630-
buf[i] = *val;
631-
}
632-
self.rpos += read_len;
633-
Ok(read_len)
634-
}
635-
}
636-
637-
impl Write for ByteBuffer {
638-
fn write(&mut self, buf: &[u8]) -> Result<usize> {
639-
self.write_bytes(buf);
640-
Ok(buf.len())
641-
}
642-
643-
fn flush(&mut self) -> Result<()> {
644-
Ok(())
645-
}
646-
}
647-
648-
impl Debug for ByteBuffer {
649-
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
650-
let rpos = if self.rbit > 0 {
651-
self.rpos + 1
652-
} else {
653-
self.rpos
654-
};
655-
656-
let read_len = self.data.len() - rpos;
657-
let mut remaining_data = vec![0; read_len];
658-
let range = rpos..rpos + read_len;
659-
for (i, val) in self.data[range].iter().enumerate() {
660-
remaining_data[i] = *val;
661-
}
662-
663-
write!(
664-
f,
665-
"ByteBuffer {{ remaining_data: {:?}, total_data: {:?}, endian: {:?} }}",
666-
remaining_data, self.data, self.endian
667-
)
668-
}
669-
}

‎tests/lib.rs

Lines changed: 42 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,44 @@
1-
extern crate bytebuffer;
2-
31
use bytebuffer::*;
42
use std::io::{ErrorKind, Read, Write};
53

4+
#[test]
5+
fn test_api() {
6+
let mut buffer = ByteBuffer::new();
7+
buffer.write_bytes(&vec![0x1, 0xFF, 0x45]);
8+
buffer.write_u8(1);
9+
buffer.write_i8(1);
10+
buffer.write_u16(1);
11+
buffer.write_i16(1);
12+
buffer.write_u32(1);
13+
buffer.write_i32(1);
14+
buffer.write_u64(1);
15+
buffer.write_i64(1);
16+
buffer.write_f32(0.1);
17+
buffer.write_f64(0.1);
18+
buffer.write_string("Hello");
19+
buffer.write_bit(true);
20+
buffer.write_bits(4, 3);
21+
buffer.flush_bits();
22+
23+
let data = buffer.into_bytes();
24+
25+
let mut buffer = ByteBuffer::from_vec(data);
26+
let _ = buffer.read_bytes(3);
27+
let _ = buffer.read_u8();
28+
let _ = buffer.read_i8();
29+
let _ = buffer.read_u16();
30+
let _ = buffer.read_i16();
31+
let _ = buffer.read_u32();
32+
let _ = buffer.read_i32();
33+
let _ = buffer.read_u64();
34+
let _ = buffer.read_i64();
35+
let _ = buffer.read_f32();
36+
let _ = buffer.read_f64();
37+
let _ = buffer.read_string();
38+
let _ = buffer.read_bit();
39+
let _ = buffer.read_bits(3);
40+
}
41+
642
#[test]
743
fn test_empty() {
844
let mut buffer = ByteBuffer::new();
@@ -138,7 +174,7 @@ fn test_rpos() {
138174
fn test_to_bytes() {
139175
let mut buffer = ByteBuffer::new();
140176
buffer.write_u8(0xFF);
141-
assert_eq!(buffer.to_bytes(), vec![0xFF]);
177+
assert_eq!(buffer.into_bytes(), vec![0xFF]);
142178
}
143179

144180
#[test]
@@ -187,14 +223,14 @@ fn test_write_bit() {
187223
buffer.write_bit(true);
188224
buffer.write_bit(true);
189225
buffer.write_bit(false);
190-
assert_eq!(buffer.to_bytes()[0], 128 + 64);
226+
assert_eq!(buffer.into_bytes()[0], 128 + 64);
191227
}
192228

193229
#[test]
194230
fn test_write_bits() {
195231
let mut buffer = ByteBuffer::new();
196232
buffer.write_bits(6, 3); // 110b
197-
assert_eq!(buffer.to_bytes()[0], 128 + 64);
233+
assert_eq!(buffer.into_bytes()[0], 128 + 64);
198234
}
199235

200236
#[test]
@@ -203,7 +239,7 @@ fn test_flush_bit() {
203239
buffer.write_bit(true);
204240
buffer.write_i8(1);
205241

206-
let buffer_result_1 = buffer.to_bytes();
242+
let buffer_result_1 = buffer.into_bytes();
207243
assert_eq!(buffer_result_1[0], 128);
208244
assert_eq!(buffer_result_1[1], 1);
209245

0 commit comments

Comments
 (0)