aboutsummaryrefslogtreecommitdiff
path: root/src/buf/buf.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/buf/buf.rs')
-rw-r--r--src/buf/buf.rs140
1 files changed, 30 insertions, 110 deletions
diff --git a/src/buf/buf.rs b/src/buf/buf.rs
index dc20567..3b4096f 100644
--- a/src/buf/buf.rs
+++ b/src/buf/buf.rs
@@ -146,7 +146,7 @@ pub trait Buf {
/// with `dst` being a zero length slice.
///
/// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
- fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize {
+ fn bytes_vec<'a>(&'a self, dst: &mut [IoVec<'a>]) -> usize {
if dst.is_empty() {
return 0;
}
@@ -251,7 +251,7 @@ pub trait Buf {
ptr::copy_nonoverlapping(
src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
- off += src.len();
+ off += cnt;
}
self.advance(cnt);
@@ -306,14 +306,6 @@ pub trait Buf {
ret
}
- #[doc(hidden)]
- #[deprecated(note="use get_u16_be or get_u16_le")]
- fn get_u16<T: ByteOrder>(&mut self) -> u16 where Self: Sized {
- let mut buf = [0; 2];
- self.copy_to_slice(&mut buf);
- T::read_u16(&buf)
- }
-
/// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
///
/// The current position is advanced by 2.
@@ -325,13 +317,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x08\x09 hello");
- /// assert_eq!(0x0809, buf.get_u16_be());
+ /// assert_eq!(0x0809, buf.get_u16());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_u16_be(&mut self) -> u16 {
+ fn get_u16(&mut self) -> u16 {
buf_get_impl!(self, 2, BigEndian::read_u16);
}
@@ -356,14 +348,6 @@ pub trait Buf {
buf_get_impl!(self, 2, LittleEndian::read_u16);
}
- #[doc(hidden)]
- #[deprecated(note="use get_i16_be or get_i16_le")]
- fn get_i16<T: ByteOrder>(&mut self) -> i16 where Self: Sized {
- let mut buf = [0; 2];
- self.copy_to_slice(&mut buf);
- T::read_i16(&buf)
- }
-
/// Gets a signed 16 bit integer from `self` in big-endian byte order.
///
/// The current position is advanced by 2.
@@ -375,13 +359,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x08\x09 hello");
- /// assert_eq!(0x0809, buf.get_i16_be());
+ /// assert_eq!(0x0809, buf.get_i16());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_i16_be(&mut self) -> i16 {
+ fn get_i16(&mut self) -> i16 {
buf_get_impl!(self, 2, BigEndian::read_i16);
}
@@ -406,14 +390,6 @@ pub trait Buf {
buf_get_impl!(self, 2, LittleEndian::read_i16);
}
- #[doc(hidden)]
- #[deprecated(note="use get_u32_be or get_u32_le")]
- fn get_u32<T: ByteOrder>(&mut self) -> u32 where Self: Sized {
- let mut buf = [0; 4];
- self.copy_to_slice(&mut buf);
- T::read_u32(&buf)
- }
-
/// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
///
/// The current position is advanced by 4.
@@ -425,13 +401,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x08\x09\xA0\xA1 hello");
- /// assert_eq!(0x0809A0A1, buf.get_u32_be());
+ /// assert_eq!(0x0809A0A1, buf.get_u32());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_u32_be(&mut self) -> u32 {
+ fn get_u32(&mut self) -> u32 {
buf_get_impl!(self, 4, BigEndian::read_u32);
}
@@ -456,14 +432,6 @@ pub trait Buf {
buf_get_impl!(self, 4, LittleEndian::read_u32);
}
- #[doc(hidden)]
- #[deprecated(note="use get_i32_be or get_i32_le")]
- fn get_i32<T: ByteOrder>(&mut self) -> i32 where Self: Sized {
- let mut buf = [0; 4];
- self.copy_to_slice(&mut buf);
- T::read_i32(&buf)
- }
-
/// Gets a signed 32 bit integer from `self` in big-endian byte order.
///
/// The current position is advanced by 4.
@@ -475,13 +443,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x08\x09\xA0\xA1 hello");
- /// assert_eq!(0x0809A0A1, buf.get_i32_be());
+ /// assert_eq!(0x0809A0A1, buf.get_i32());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_i32_be(&mut self) -> i32 {
+ fn get_i32(&mut self) -> i32 {
buf_get_impl!(self, 4, BigEndian::read_i32);
}
@@ -506,14 +474,6 @@ pub trait Buf {
buf_get_impl!(self, 4, LittleEndian::read_i32);
}
- #[doc(hidden)]
- #[deprecated(note="use get_u64_be or get_u64_le")]
- fn get_u64<T: ByteOrder>(&mut self) -> u64 where Self: Sized {
- let mut buf = [0; 8];
- self.copy_to_slice(&mut buf);
- T::read_u64(&buf)
- }
-
/// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
///
/// The current position is advanced by 8.
@@ -525,13 +485,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03\x04\x05\x06\x07\x08 hello");
- /// assert_eq!(0x0102030405060708, buf.get_u64_be());
+ /// assert_eq!(0x0102030405060708, buf.get_u64());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_u64_be(&mut self) -> u64 {
+ fn get_u64(&mut self) -> u64 {
buf_get_impl!(self, 8, BigEndian::read_u64);
}
@@ -556,14 +516,6 @@ pub trait Buf {
buf_get_impl!(self, 8, LittleEndian::read_u64);
}
- #[doc(hidden)]
- #[deprecated(note="use get_i64_be or get_i64_le")]
- fn get_i64<T: ByteOrder>(&mut self) -> i64 where Self: Sized {
- let mut buf = [0; 8];
- self.copy_to_slice(&mut buf);
- T::read_i64(&buf)
- }
-
/// Gets a signed 64 bit integer from `self` in big-endian byte order.
///
/// The current position is advanced by 8.
@@ -575,13 +527,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03\x04\x05\x06\x07\x08 hello");
- /// assert_eq!(0x0102030405060708, buf.get_i64_be());
+ /// assert_eq!(0x0102030405060708, buf.get_i64());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_i64_be(&mut self) -> i64 {
+ fn get_i64(&mut self) -> i64 {
buf_get_impl!(self, 8, BigEndian::read_i64);
}
@@ -618,14 +570,14 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello");
- /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_be());
+ /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
#[cfg(feature = "i128")]
- fn get_u128_be(&mut self) -> u128 {
+ fn get_u128(&mut self) -> u128 {
buf_get_impl!(self, 16, BigEndian::read_u128);
}
@@ -664,14 +616,14 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello");
- /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_be());
+ /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
#[cfg(feature = "i128")]
- fn get_i128_be(&mut self) -> i128 {
+ fn get_i128(&mut self) -> i128 {
buf_get_impl!(self, 16, BigEndian::read_i128);
}
@@ -698,14 +650,6 @@ pub trait Buf {
buf_get_impl!(self, 16, LittleEndian::read_i128);
}
- #[doc(hidden)]
- #[deprecated(note="use get_uint_be or get_uint_le")]
- fn get_uint<T: ByteOrder>(&mut self, nbytes: usize) -> u64 where Self: Sized {
- let mut buf = [0; 8];
- self.copy_to_slice(&mut buf[..nbytes]);
- T::read_uint(&buf[..nbytes], nbytes)
- }
-
/// Gets an unsigned n-byte integer from `self` in big-endian byte order.
///
/// The current position is advanced by `nbytes`.
@@ -713,17 +657,17 @@ pub trait Buf {
/// # Examples
///
/// ```
- /// use bytes::{Buf, BigEndian};
+ /// use bytes::Buf;
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03 hello");
- /// assert_eq!(0x010203, buf.get_uint_be(3));
+ /// assert_eq!(0x010203, buf.get_uint(3));
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_uint_be(&mut self, nbytes: usize) -> u64 {
+ fn get_uint(&mut self, nbytes: usize) -> u64 {
buf_get_impl!(self, 8, BigEndian::read_uint, nbytes);
}
@@ -748,14 +692,6 @@ pub trait Buf {
buf_get_impl!(self, 8, LittleEndian::read_uint, nbytes);
}
- #[doc(hidden)]
- #[deprecated(note="use get_int_be or get_int_le")]
- fn get_int<T: ByteOrder>(&mut self, nbytes: usize) -> i64 where Self: Sized {
- let mut buf = [0; 8];
- self.copy_to_slice(&mut buf[..nbytes]);
- T::read_int(&buf[..nbytes], nbytes)
- }
-
/// Gets a signed n-byte integer from `self` in big-endian byte order.
///
/// The current position is advanced by `nbytes`.
@@ -767,13 +703,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x01\x02\x03 hello");
- /// assert_eq!(0x010203, buf.get_int_be(3));
+ /// assert_eq!(0x010203, buf.get_int(3));
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_int_be(&mut self, nbytes: usize) -> i64 {
+ fn get_int(&mut self, nbytes: usize) -> i64 {
buf_get_impl!(self, 8, BigEndian::read_int, nbytes);
}
@@ -798,14 +734,6 @@ pub trait Buf {
buf_get_impl!(self, 8, LittleEndian::read_int, nbytes);
}
- #[doc(hidden)]
- #[deprecated(note="use get_f32_be or get_f32_le")]
- fn get_f32<T: ByteOrder>(&mut self) -> f32 where Self: Sized {
- let mut buf = [0; 4];
- self.copy_to_slice(&mut buf);
- T::read_f32(&buf)
- }
-
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
/// `self` in big-endian byte order.
///
@@ -818,13 +746,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x3F\x99\x99\x9A hello");
- /// assert_eq!(1.2f32, buf.get_f32_be());
+ /// assert_eq!(1.2f32, buf.get_f32());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_f32_be(&mut self) -> f32 {
+ fn get_f32(&mut self) -> f32 {
buf_get_impl!(self, 4, BigEndian::read_f32);
}
@@ -850,14 +778,6 @@ pub trait Buf {
buf_get_impl!(self, 4, LittleEndian::read_f32);
}
- #[doc(hidden)]
- #[deprecated(note="use get_f64_be or get_f64_le")]
- fn get_f64<T: ByteOrder>(&mut self) -> f64 where Self: Sized {
- let mut buf = [0; 8];
- self.copy_to_slice(&mut buf);
- T::read_f64(&buf)
- }
-
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
/// `self` in big-endian byte order.
///
@@ -870,13 +790,13 @@ pub trait Buf {
/// use std::io::Cursor;
///
/// let mut buf = Cursor::new(b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello");
- /// assert_eq!(1.2f64, buf.get_f64_be());
+ /// assert_eq!(1.2f64, buf.get_f64());
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining data in `self`.
- fn get_f64_be(&mut self) -> f64 {
+ fn get_f64(&mut self) -> f64 {
buf_get_impl!(self, 8, BigEndian::read_f64);
}
@@ -1061,7 +981,7 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T {
(**self).bytes()
}
- fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {
+ fn bytes_vec<'b>(&'b self, dst: &mut [IoVec<'b>]) -> usize {
(**self).bytes_vec(dst)
}
@@ -1079,7 +999,7 @@ impl<T: Buf + ?Sized> Buf for Box<T> {
(**self).bytes()
}
- fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {
+ fn bytes_vec<'b>(&'b self, dst: &mut [IoVec<'b>]) -> usize {
(**self).bytes_vec(dst)
}
@@ -1151,4 +1071,4 @@ impl Buf for Option<[u8; 1]> {
// The existance of this function makes the compiler catch if the Buf
// trait is "object-safe" or not.
-fn _assert_trait_object(_b: &Buf) {}
+fn _assert_trait_object(_b: &dyn Buf) {}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-11 20:48:26 +0000