Skip to content

Commit fd342a5

Browse files
StargateurStargateur
committed
Update bytes features with lasted bytes version 1.1.0 & add edition 2021
1 parent bd1b512 commit fd342a5

File tree

3 files changed

+163
-185
lines changed

3 files changed

+163
-185
lines changed

‎Cargo.toml‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -9,14 +9,14 @@ documentation = "https://docs.rs/circbuf/"
99
readme = "README.md"
1010
license = "MIT"
1111
keywords = ["buffer", "bytes", "circular", "ring"]
12+
edition = "2021"
1213

1314
[features]
1415
nightly = []
15-
bytes = ["bytes_rs"]
1616

17-
[dependencies]
18-
# Rename because a dependency can't have the same name as a feature.
19-
bytes_rs = { version = "0.5", optional = true, package = "bytes" }
17+
[dependencies.bytes]
18+
version = "1.1.0"
19+
optional = true
2020

2121
[dev-dependencies]
2222
vecio = "0.1.0"

‎src/bytes.rs‎

Lines changed: 158 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
use std::io::IoSlice;
2+
3+
use crate::CircBuf;
4+
5+
use bytes::{buf::UninitSlice, Buf, BufMut};
6+
7+
impl Buf for CircBuf {
8+
fn advance(&mut self, count: usize) {
9+
assert!(count == 0 || count <= self.remaining());
10+
self.advance_read(count);
11+
}
12+
13+
fn chunk(&self) -> &[u8] {
14+
let [left, right] = self.get_bytes();
15+
match (left.is_empty(), right.is_empty()) {
16+
(true, true) => left,
17+
(true, false) => right,
18+
(false, true) => left,
19+
(false, false) => left,
20+
}
21+
}
22+
23+
fn remaining(&self) -> usize {
24+
self.len()
25+
}
26+
27+
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
28+
let [left, right] = self.get_bytes();
29+
let mut count = 0;
30+
if let Some(slice) = dst.get_mut(0) {
31+
count += 1;
32+
*slice = IoSlice::new(left);
33+
}
34+
if let Some(slice) = dst.get_mut(1) {
35+
count += 1;
36+
*slice = IoSlice::new(right);
37+
}
38+
count
39+
}
40+
}
41+
42+
unsafe impl BufMut for CircBuf {
43+
unsafe fn advance_mut(&mut self, count: usize) {
44+
assert!(count == 0 || count <= self.remaining_mut());
45+
self.advance_write(count);
46+
}
47+
48+
fn chunk_mut<'this>(&'this mut self) -> &'this mut UninitSlice {
49+
let [left, right] = self.get_avail();
50+
let slice = match (left.is_empty(), right.is_empty()) {
51+
(true, true) => left,
52+
(true, false) => right,
53+
(false, true) => left,
54+
(false, false) => left,
55+
};
56+
// https://docs.rs/bytes/latest/bytes/buf/struct.UninitSlice.html#method.from_raw_parts_mut
57+
unsafe { UninitSlice::from_raw_parts_mut(slice.as_mut_ptr(), slice.len()) }
58+
}
59+
60+
fn remaining_mut(&self) -> usize {
61+
self.avail()
62+
}
63+
}
64+
65+
#[cfg(test)]
66+
mod tests {
67+
use crate::CircBuf;
68+
use bytes::{Buf, BufMut};
69+
use std::io::IoSlice;
70+
71+
#[test]
72+
fn bytes_buf_and_bufmut() {
73+
let mut c = CircBuf::with_capacity(4).unwrap();
74+
75+
assert_eq!(c.remaining(), 0);
76+
assert_eq!(c.remaining_mut(), 3);
77+
unsafe {
78+
c.advance_mut(2);
79+
}
80+
assert_eq!(c.remaining(), 2);
81+
assert_eq!(c.remaining_mut(), 1);
82+
c.advance(1);
83+
assert_eq!(c.remaining(), 1);
84+
assert_eq!(c.remaining_mut(), 2);
85+
unsafe {
86+
c.advance_mut(1);
87+
}
88+
assert_eq!(c.remaining(), 2);
89+
assert_eq!(c.remaining_mut(), 1);
90+
91+
assert_eq!(<CircBuf as Buf>::chunk(&c).len(), 2);
92+
assert_eq!(c.chunk_mut().len(), 1);
93+
94+
let mut dst = [IoSlice::new(&[]); 2];
95+
assert_eq!(c.chunks_vectored(&mut dst[..]), 2);
96+
97+
assert_eq!(dst[0].len(), 2);
98+
assert_eq!(dst[1].len(), 0);
99+
}
100+
101+
#[test]
102+
fn bytes_buf_remaining() {
103+
use bytes::{Buf, BufMut};
104+
105+
let mut c = CircBuf::with_capacity(4).unwrap();
106+
107+
assert_eq!(c.remaining(), 0);
108+
assert_eq!(c.remaining_mut(), 3);
109+
assert!(!c.has_remaining());
110+
assert!(c.has_remaining_mut());
111+
112+
unsafe {
113+
c.advance_mut(3);
114+
}
115+
116+
assert_eq!(c.remaining(), 3);
117+
assert_eq!(c.remaining_mut(), 0);
118+
assert!(c.has_remaining());
119+
assert!(!c.has_remaining_mut());
120+
121+
c.advance(2);
122+
123+
assert_eq!(c.remaining(), 1);
124+
assert_eq!(c.remaining_mut(), 2);
125+
assert!(c.has_remaining());
126+
assert!(c.has_remaining_mut());
127+
128+
c.advance(1);
129+
130+
assert_eq!(c.remaining(), 0);
131+
assert_eq!(c.remaining_mut(), 3);
132+
assert!(!c.has_remaining());
133+
assert!(c.has_remaining_mut());
134+
}
135+
136+
#[cfg(feature = "bytes")]
137+
#[test]
138+
fn bytes_bufmut_hello() {
139+
use bytes::BufMut;
140+
141+
let mut c = CircBuf::with_capacity(16).unwrap();
142+
143+
unsafe {
144+
c.chunk_mut().write_byte(0, b'h');
145+
c.chunk_mut().write_byte(1, b'e');
146+
147+
c.advance_mut(2);
148+
149+
c.chunk_mut().write_byte(0, b'l');
150+
c.chunk_mut().write_byte(1, b'l');
151+
c.chunk_mut().write_byte(2, b'o');
152+
153+
c.advance_mut(3);
154+
}
155+
156+
assert_eq!(c.get_bytes()[0], b"hello");
157+
}
158+
}

‎src/lib.rs‎

Lines changed: 1 addition & 181 deletions
Original file line numberDiff line numberDiff line change
@@ -119,7 +119,7 @@
119119
extern crate test;
120120

121121
#[cfg(feature = "bytes")]
122-
extern crate bytes_rs;
122+
mod bytes;
123123

124124
use std::boxed::Box;
125125
use std::error;
@@ -554,82 +554,6 @@ impl io::Write for CircBuf {
554554
}
555555
}
556556

557-
#[cfg(feature = "bytes")]
558-
impl bytes_rs::Buf for CircBuf {
559-
fn remaining(&self) -> usize {
560-
self.len()
561-
}
562-
563-
fn advance(&mut self, count: usize) {
564-
assert!(count == 0 || count <= self.remaining());
565-
self.advance_read(count);
566-
}
567-
568-
fn bytes(&self) -> &[u8] {
569-
let [left, right] = self.get_bytes();
570-
match (left.is_empty(), right.is_empty()) {
571-
(true, true) => left,
572-
(true, false) => right,
573-
(false, true) => left,
574-
(false, false) => left,
575-
}
576-
}
577-
578-
fn bytes_vectored<'a>(&'a self, dst: &mut [io::IoSlice<'a>]) -> usize {
579-
let [left, right] = self.get_bytes();
580-
let mut count = 0;
581-
if let Some(slice) = dst.get_mut(0) {
582-
count += 1;
583-
*slice = io::IoSlice::new(left);
584-
}
585-
if let Some(slice) = dst.get_mut(1) {
586-
count += 1;
587-
*slice = io::IoSlice::new(right);
588-
}
589-
count
590-
}
591-
}
592-
593-
#[cfg(feature = "bytes")]
594-
impl bytes_rs::BufMut for CircBuf {
595-
fn remaining_mut(&self) -> usize {
596-
self.avail()
597-
}
598-
599-
unsafe fn advance_mut(&mut self, count: usize) {
600-
assert!(count == 0 || count <= self.remaining_mut());
601-
self.advance_write(count);
602-
}
603-
604-
fn bytes_mut<'this>(&'this mut self) -> &'this mut [std::mem::MaybeUninit<u8>] {
605-
let [left, right] = self.get_avail();
606-
let slice = match (left.is_empty(), right.is_empty()) {
607-
(true, true) => left,
608-
(true, false) => right,
609-
(false, true) => left,
610-
(false, false) => left,
611-
};
612-
// As far as I can tell it is perfectly safe to convert from u8 to MaybeUninit<u8>.
613-
unsafe {
614-
std::mem::transmute::<&'this mut [u8], &'this mut [std::mem::MaybeUninit<u8>]>(slice)
615-
}
616-
}
617-
618-
fn bytes_vectored_mut<'a>(&'a mut self, dst: &mut [bytes_rs::buf::IoSliceMut<'a>]) -> usize {
619-
let [left, right] = self.get_avail();
620-
let mut count = 0;
621-
if let Some(slice) = dst.get_mut(0) {
622-
count += 1;
623-
*slice = bytes_rs::buf::IoSliceMut::from(left);
624-
}
625-
if let Some(slice) = dst.get_mut(1) {
626-
count += 1;
627-
*slice = bytes_rs::buf::IoSliceMut::from(right);
628-
}
629-
count
630-
}
631-
}
632-
633557
#[cfg(test)]
634558
mod tests {
635559
extern crate vecio;
@@ -956,110 +880,6 @@ mod tests {
956880
assert_eq!(s, "fizzbuzz");
957881
}
958882

959-
#[cfg(feature = "bytes")]
960-
#[test]
961-
fn bytes_buf_and_bufmut() {
962-
use bytes_rs::{Buf, BufMut};
963-
964-
let mut c = CircBuf::with_capacity(4).unwrap();
965-
966-
assert_eq!(c.remaining(), 0);
967-
assert_eq!(c.remaining_mut(), 3);
968-
unsafe {
969-
c.advance_mut(2);
970-
}
971-
assert_eq!(c.remaining(), 2);
972-
assert_eq!(c.remaining_mut(), 1);
973-
c.advance(1);
974-
assert_eq!(c.remaining(), 1);
975-
assert_eq!(c.remaining_mut(), 2);
976-
unsafe {
977-
c.advance_mut(1);
978-
}
979-
assert_eq!(c.remaining(), 2);
980-
assert_eq!(c.remaining_mut(), 1);
981-
982-
assert_eq!(<CircBuf as Buf>::bytes(&c).len(), 2);
983-
assert_eq!(c.bytes_mut().len(), 1);
984-
985-
let mut dst = [std::io::IoSlice::new(&[]); 2];
986-
assert_eq!(c.bytes_vectored(&mut dst[..]), 2);
987-
988-
assert_eq!(dst[0].len(), 2);
989-
assert_eq!(dst[1].len(), 0);
990-
991-
let b1: &mut [u8] = &mut [];
992-
let b2: &mut [u8] = &mut [];
993-
let mut dst_mut = [
994-
bytes_rs::buf::IoSliceMut::from(b1),
995-
bytes_rs::buf::IoSliceMut::from(b2),
996-
];
997-
998-
assert_eq!(c.bytes_vectored_mut(&mut dst_mut[..]), 2);
999-
1000-
assert!(c.has_remaining());
1001-
assert!(c.has_remaining_mut());
1002-
}
1003-
1004-
#[cfg(feature = "bytes")]
1005-
#[test]
1006-
fn bytes_buf_remaining() {
1007-
use bytes_rs::{Buf, BufMut};
1008-
1009-
let mut c = CircBuf::with_capacity(4).unwrap();
1010-
1011-
assert_eq!(c.remaining(), 0);
1012-
assert_eq!(c.remaining_mut(), 3);
1013-
assert!(!c.has_remaining());
1014-
assert!(c.has_remaining_mut());
1015-
1016-
unsafe {
1017-
c.advance_mut(3);
1018-
}
1019-
1020-
assert_eq!(c.remaining(), 3);
1021-
assert_eq!(c.remaining_mut(), 0);
1022-
assert!(c.has_remaining());
1023-
assert!(!c.has_remaining_mut());
1024-
1025-
c.advance(2);
1026-
1027-
assert_eq!(c.remaining(), 1);
1028-
assert_eq!(c.remaining_mut(), 2);
1029-
assert!(c.has_remaining());
1030-
assert!(c.has_remaining_mut());
1031-
1032-
c.advance(1);
1033-
1034-
assert_eq!(c.remaining(), 0);
1035-
assert_eq!(c.remaining_mut(), 3);
1036-
assert!(!c.has_remaining());
1037-
assert!(c.has_remaining_mut());
1038-
}
1039-
1040-
#[cfg(feature = "bytes")]
1041-
#[test]
1042-
fn bytes_bufmut_hello() {
1043-
use bytes_rs::BufMut;
1044-
1045-
let mut c = CircBuf::with_capacity(16).unwrap();
1046-
1047-
unsafe {
1048-
c.bytes_mut()[0].as_mut_ptr().write(b'h');
1049-
c.bytes_mut()[1].as_mut_ptr().write(b'e');
1050-
1051-
c.advance_mut(2);
1052-
1053-
c.bytes_mut()[0].as_mut_ptr().write(b'l');
1054-
c.bytes_mut()[1].as_mut_ptr().write(b'l');
1055-
c.bytes_mut()[2].as_mut_ptr().write(b'o');
1056-
1057-
c.advance_mut(3);
1058-
}
1059-
1060-
assert_eq!(c.get_bytes()[0], b"hello");
1061-
}
1062-
1063883
#[cfg(feature = "nightly")]
1064884
#[bench]
1065885
pub fn normal_read(b: &mut Bencher) {

0 commit comments

Comments
 (0)