特性 Buf

Source

pub trait Buf {
Show 87 methods    // Required methods
    fn remaining(&self) -> usize;
    fn chunk(&self) -> &[u8] ⓘ;
    fn advance(&mut self, cnt: usize);

    // Provided methods
    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { ... }
    fn has_remaining(&self) -> bool { ... }
    fn copy_to_slice(&mut self, dst: &mut [u8]) { ... }
    fn get_u8(&mut self) -> u8 { ... }
    fn get_i8(&mut self) -> i8 { ... }
    fn get_u16(&mut self) -> u16 { ... }
    fn get_u16_le(&mut self) -> u16 { ... }
    fn get_u16_ne(&mut self) -> u16 { ... }
    fn get_i16(&mut self) -> i16 { ... }
    fn get_i16_le(&mut self) -> i16 { ... }
    fn get_i16_ne(&mut self) -> i16 { ... }
    fn get_u32(&mut self) -> u32 { ... }
    fn get_u32_le(&mut self) -> u32 { ... }
    fn get_u32_ne(&mut self) -> u32 { ... }
    fn get_i32(&mut self) -> i32 { ... }
    fn get_i32_le(&mut self) -> i32 { ... }
    fn get_i32_ne(&mut self) -> i32 { ... }
    fn get_u64(&mut self) -> u64 { ... }
    fn get_u64_le(&mut self) -> u64 { ... }
    fn get_u64_ne(&mut self) -> u64 { ... }
    fn get_i64(&mut self) -> i64 { ... }
    fn get_i64_le(&mut self) -> i64 { ... }
    fn get_i64_ne(&mut self) -> i64 { ... }
    fn get_u128(&mut self) -> u128 { ... }
    fn get_u128_le(&mut self) -> u128 { ... }
    fn get_u128_ne(&mut self) -> u128 { ... }
    fn get_i128(&mut self) -> i128 { ... }
    fn get_i128_le(&mut self) -> i128 { ... }
    fn get_i128_ne(&mut self) -> i128 { ... }
    fn get_uint(&mut self, nbytes: usize) -> u64 { ... }
    fn get_uint_le(&mut self, nbytes: usize) -> u64 { ... }
    fn get_uint_ne(&mut self, nbytes: usize) -> u64 { ... }
    fn get_int(&mut self, nbytes: usize) -> i64 { ... }
    fn get_int_le(&mut self, nbytes: usize) -> i64 { ... }
    fn get_int_ne(&mut self, nbytes: usize) -> i64 { ... }
    fn get_f32(&mut self) -> f32 { ... }
    fn get_f32_le(&mut self) -> f32 { ... }
    fn get_f32_ne(&mut self) -> f32 { ... }
    fn get_f64(&mut self) -> f64 { ... }
    fn get_f64_le(&mut self) -> f64 { ... }
    fn get_f64_ne(&mut self) -> f64 { ... }
    fn try_copy_to_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError> { ... }
    fn try_get_u8(&mut self) -> Result<u8, TryGetError> { ... }
    fn try_get_i8(&mut self) -> Result<i8, TryGetError> { ... }
    fn try_get_u16(&mut self) -> Result<u16, TryGetError> { ... }
    fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> { ... }
    fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> { ... }
    fn try_get_i16(&mut self) -> Result<i16, TryGetError> { ... }
    fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> { ... }
    fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> { ... }
    fn try_get_u32(&mut self) -> Result<u32, TryGetError> { ... }
    fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> { ... }
    fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> { ... }
    fn try_get_i32(&mut self) -> Result<i32, TryGetError> { ... }
    fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> { ... }
    fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> { ... }
    fn try_get_u64(&mut self) -> Result<u64, TryGetError> { ... }
    fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> { ... }
    fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> { ... }
    fn try_get_i64(&mut self) -> Result<i64, TryGetError> { ... }
    fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> { ... }
    fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> { ... }
    fn try_get_u128(&mut self) -> Result<u128, TryGetError> { ... }
    fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> { ... }
    fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> { ... }
    fn try_get_i128(&mut self) -> Result<i128, TryGetError> { ... }
    fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> { ... }
    fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> { ... }
    fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> { ... }
    fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> { ... }
    fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> { ... }
    fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> { ... }
    fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> { ... }
    fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> { ... }
    fn try_get_f32(&mut self) -> Result<f32, TryGetError> { ... }
    fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> { ... }
    fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> { ... }
    fn try_get_f64(&mut self) -> Result<f64, TryGetError> { ... }
    fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> { ... }
    fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> { ... }
    fn copy_to_bytes(&mut self, len: usize) -> Bytes { ... }
    fn take(self, limit: usize) -> Take<Self>
       where Self: Sized { ... }
    fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
       where Self: Sized { ... }
    fn reader(self) -> Reader<Self> ⓘ
       where Self: Sized { ... }
}

展开描述

从缓冲区读取字节。

缓冲区将字节存储在内存中，以便读取操作不会失败。底层存储可能连续也可能不连续。Buf 值是指向缓冲区的游标。从 Buf 读取会推进游标位置。可以将其视为字节集合的高效 Iterator。

最简单的 Buf 是 &[u8]。

use bytes::Buf;

let mut buf = &b"hello world"[..];

assert_eq!(b'h', buf.get_u8());
assert_eq!(b'e', buf.get_u8());
assert_eq!(b'l', buf.get_u8());

let mut rest = [0; 8];
buf.copy_to_slice(&mut rest);

assert_eq!(&rest[..], &b"lo world"[..]);

必需方法§

Source

fn remaining(&self) -> usize

返回从当前位置到缓冲区末尾的字节数。

此值大于或等于 chunk() 返回切片的长度。

§示例

use bytes::Buf;

let mut buf = &b"hello world"[..];

assert_eq!(buf.remaining(), 11);

buf.get_u8();

assert_eq!(buf.remaining(), 10);

§Implementer notes

remaining 的实现应确保返回值不会改变，除非调用了 advance 或任何其他文档明确会改变 Buf’s 当前位置的函数。

Source

fn chunk(&self) -> &[u8] ⓘ

返回从当前位置开始、长度介于 0 和 Buf::remaining() 之间的切片。注意这可能返回较短的切片（允许非连续的内部表示）。

这是一个较低级别的函数。大多数操作通过其他函数完成。

§示例

use bytes::Buf;

let mut buf = &b"hello world"[..];

assert_eq!(buf.chunk(), &b"hello world"[..]);

buf.advance(6);

assert_eq!(buf.chunk(), &b"world"[..]);

§Implementer notes

此函数不应 panic。chunk() 返回空切片当且仅当 remaining() 返回 0。换言之，chunk() 返回空切片意味着 remaining() 将返回 0，而 remaining() 返回 0 意味着 chunk() 将返回空切片。

Source

fn advance(&mut self, cnt: usize)

推进 Buf 的内部游标

下一次调用 chunk() 时将返回一个从底层缓冲区再深入 cnt 字节开始的切片。

§示例

use bytes::Buf;

let mut buf = &b"hello world"[..];

assert_eq!(buf.chunk(), &b"hello world"[..]);

buf.advance(6);

assert_eq!(buf.chunk(), &b"world"[..]);

§Panics

若 cnt > self.remaining()，此函数可能会 panic。

§Implementer notes

建议 advance 的实现在 cnt > self.remaining() 时 panic。若实现不 panic，则调用行为必须如同 cnt == self.remaining()。

调用 cnt == 0 时绝不应 panic，且应为无操作。

提供方法§

Source

fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize

从 self 的当前位置开始，向 dst 中填充可能的多段切片。

如果 Buf 由不相邻的字节切片支撑，chunk_vectored 允许一次性取出多段切片。dst 是一个 IoSlice 引用数组，其中的切片可直接配合 writev 使用而无需额外转换。所有写入 dst 的缓冲区长度之和应小于或等于 Buf::remaining()。

dst 中的元素会被覆盖，但切片包含的数据不会被修改。返回值是写入 dst 的切片个数。若 Buf::remaining() 非零，则本方法至少会向 dst 写入一段非空切片。

这是一个底层函数，大多数操作应使用其他方法完成。

§实现者须知

本方法绝不能 panic。一旦到达缓冲区末尾，即 Buf::remaining 返回 0，对 chunk_vectored 的调用必须返回 0，且不得修改 dst。

实现还需注意正确处理 dst 为零长度切片的调用情形。

Source

fn has_remaining(&self) -> bool

若还有更多字节可供消费则返回 true

这等价于 self.remaining() != 0。

§示例

use bytes::Buf;

let mut buf = &b"a"[..];

assert!(buf.has_remaining());

buf.get_u8();

assert!(!buf.has_remaining());

Source

fn copy_to_slice(&mut self, dst: &mut [u8])

将 self 中的字节复制到 dst。

游标按已复制的字节数推进。self 必须有足够的剩余字节填满 dst。

§示例

use bytes::Buf;

let mut buf = &b"hello world"[..];
let mut dst = [0; 5];

buf.copy_to_slice(&mut dst);
assert_eq!(&b"hello"[..], &dst);
assert_eq!(6, buf.remaining());

§Panics

若 self.remaining() < dst.len()，此函数会 panic。

Source

fn get_u8(&mut self) -> u8

从 self 读取一个无符号 8 位整数。

当前位置前进 1 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(8, buf.get_u8());

§Panics

若 self 中没有更多剩余数据，此函数会 panic。

Source

fn get_i8(&mut self) -> i8

从 self 读取一个有符号 8 位整数。

当前位置前进 1 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(8, buf.get_i8());

§Panics

若 self 中没有更多剩余数据，此函数会 panic。

Source

fn get_u16(&mut self) -> u16

从 self 以大端字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(0x0809, buf.get_u16());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u16_le(&mut self) -> u16

从 self 以小端字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(0x0809, buf.get_u16_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u16_ne(&mut self) -> u16

从 self 以原生字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09 hello",
    false => b"\x09\x08 hello",
};
assert_eq!(0x0809, buf.get_u16_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i16(&mut self) -> i16

从 self 以大端字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(0x0809, buf.get_i16());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i16_le(&mut self) -> i16

从 self 以小端字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(0x0809, buf.get_i16_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i16_ne(&mut self) -> i16

从 self 以原生字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09 hello",
    false => b"\x09\x08 hello",
};
assert_eq!(0x0809, buf.get_i16_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u32(&mut self) -> u32

从 self 以大端字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(0x0809A0A1, buf.get_u32());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u32_le(&mut self) -> u32

从 self 以小端字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
assert_eq!(0x0809A0A1, buf.get_u32_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u32_ne(&mut self) -> u32

从 self 以原生字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09\xA0\xA1 hello",
    false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(0x0809A0A1, buf.get_u32_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i32(&mut self) -> i32

从 self 以大端字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(0x0809A0A1, buf.get_i32());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i32_le(&mut self) -> i32

从 self 以小端字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
assert_eq!(0x0809A0A1, buf.get_i32_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i32_ne(&mut self) -> i32

从 self 以原生字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09\xA0\xA1 hello",
    false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(0x0809A0A1, buf.get_i32_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u64(&mut self) -> u64

从 self 以大端字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(0x0102030405060708, buf.get_u64());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u64_le(&mut self) -> u64

从 self 以小端字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x0102030405060708, buf.get_u64_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u64_ne(&mut self) -> u64

从 self 以原生字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
    false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x0102030405060708, buf.get_u64_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i64(&mut self) -> i64

从 self 以大端字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(0x0102030405060708, buf.get_i64());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i64_le(&mut self) -> i64

从 self 以小端字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x0102030405060708, buf.get_i64_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i64_ne(&mut self) -> i64

从 self 以原生字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
    false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x0102030405060708, buf.get_i64_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u128(&mut self) -> u128

从 self 以大端字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_u128());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u128_le(&mut self) -> u128

从 self 以小端字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_u128_ne(&mut self) -> u128

从 self 以原生字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
    false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i128(&mut self) -> i128

从 self 以大端字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_i128());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i128_le(&mut self) -> i128

从 self 以小端字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_i128_ne(&mut self) -> i128

从 self 以原生字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
    false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_uint(&mut self, nbytes: usize) -> u64

从 self 以大端字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03 hello"[..];
assert_eq!(0x010203, buf.get_uint(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_uint_le(&mut self, nbytes: usize) -> u64

从 self 以小端字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(0x010203, buf.get_uint_le(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_uint_ne(&mut self, nbytes: usize) -> u64

从 self 以原生字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03 hello",
    false => b"\x03\x02\x01 hello",
};
assert_eq!(0x010203, buf.get_uint_ne(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_int(&mut self, nbytes: usize) -> i64

从 self 以大端字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03 hello"[..];
assert_eq!(0x010203, buf.get_int(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_int_le(&mut self, nbytes: usize) -> i64

从 self 以小端字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(0x010203, buf.get_int_le(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_int_ne(&mut self, nbytes: usize) -> i64

从 self 以原生字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03 hello",
    false => b"\x03\x02\x01 hello",
};
assert_eq!(0x010203, buf.get_int_ne(3));

§Panics

若 self 中没有足够剩余数据，或 nbytes 大于 8，此函数会 panic。

Source

fn get_f32(&mut self) -> f32

从 self 以大端字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
assert_eq!(1.2f32, buf.get_f32());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_f32_le(&mut self) -> f32

从 self 以小端字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
assert_eq!(1.2f32, buf.get_f32_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_f32_ne(&mut self) -> f32

从 self 以原生字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x3F\x99\x99\x9A hello",
    false => b"\x9A\x99\x99\x3F hello",
};
assert_eq!(1.2f32, buf.get_f32_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_f64(&mut self) -> f64

从 self 以大端字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
assert_eq!(1.2f64, buf.get_f64());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_f64_le(&mut self) -> f64

从 self 以小端字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
assert_eq!(1.2f64, buf.get_f64_le());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn get_f64_ne(&mut self) -> f64

从 self 以原生字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
    false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
};
assert_eq!(1.2f64, buf.get_f64_ne());

§Panics

若 self 中没有足够剩余数据，此函数会 panic。

Source

fn try_copy_to_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError>

将 self 中的字节复制到 dst。

游标按已复制的字节数推进。self 必须有足够的剩余字节填满 dst。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"hello world"[..];
let mut dst = [0; 5];

assert_eq!(Ok(()), buf.try_copy_to_slice(&mut dst));
assert_eq!(&b"hello"[..], &dst);
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"hello world"[..];
let mut dst = [0; 12];

assert_eq!(Err(TryGetError{requested: 12, available: 11}), buf.try_copy_to_slice(&mut dst));
assert_eq!(11, buf.remaining());

Source

fn try_get_u8(&mut self) -> Result<u8, TryGetError>

从 self 读取一个无符号 8 位整数。

当前位置前进 1 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(Ok(0x08_u8), buf.try_get_u8());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b""[..];
assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8());

Source

fn try_get_i8(&mut self) -> Result<i8, TryGetError>

从 self 读取一个有符号 8 位整数。

当前位置前进 1 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(Ok(0x08_i8), buf.try_get_i8());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b""[..];
assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_i8());

Source

fn try_get_u16(&mut self) -> Result<u16, TryGetError>

从 self 以大端字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(Ok(0x0809_u16), buf.try_get_u16());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16());
assert_eq!(1, buf.remaining());

Source

fn try_get_u16_le(&mut self) -> Result<u16, TryGetError>

从 self 以小端字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(Ok(0x0809_u16), buf.try_get_u16_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_le());
assert_eq!(1, buf.remaining());

Source

fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError>

从 self 以原生字节序读取无符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09 hello",
    false => b"\x09\x08 hello",
};
assert_eq!(Ok(0x0809_u16), buf.try_get_u16_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_ne());
assert_eq!(1, buf.remaining());

Source

fn try_get_i16(&mut self) -> Result<i16, TryGetError>

从 self 以大端字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(Ok(0x0809_i16), buf.try_get_i16());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16());
assert_eq!(1, buf.remaining());

Source

fn try_get_i16_le(&mut self) -> Result<i16, TryGetError>

从 self 以小端字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(Ok(0x0809_i16), buf.try_get_i16_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_le());
assert_eq!(1, buf.remaining());

Source

fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError>

从 self 以原生字节序读取有符号 16 位整数。

当前位置前进 2 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09 hello",
    false => b"\x09\x08 hello",
};
assert_eq!(Ok(0x0809_i16), buf.try_get_i16_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08"[..];
assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_ne());
assert_eq!(1, buf.remaining());

Source

fn try_get_u32(&mut self) -> Result<u32, TryGetError>

从 self 以大端字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(Ok(0x0809A0A1), buf.try_get_u32());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32());
assert_eq!(3, buf.remaining());

Source

fn try_get_u32_le(&mut self) -> Result<u32, TryGetError>

从 self 以小端字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x09\xA0"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_le());
assert_eq!(3, buf.remaining());

Source

fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError>

从 self 以原生字节序读取无符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09\xA0\xA1 hello",
    false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x09\xA0"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_ne());
assert_eq!(3, buf.remaining());

Source

fn try_get_i32(&mut self) -> Result<i32, TryGetError>

从 self 以大端字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32());
assert_eq!(3, buf.remaining());

Source

fn try_get_i32_le(&mut self) -> Result<i32, TryGetError>

从 self 以小端字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x09\xA0"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_le());
assert_eq!(3, buf.remaining());

Source

fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError>

从 self 以原生字节序读取有符号 32 位整数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x08\x09\xA0\xA1 hello",
    false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x09\xA0"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_ne());
assert_eq!(3, buf.remaining());

Source

fn try_get_u64(&mut self) -> Result<u64, TryGetError>

从 self 以大端字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64());
assert_eq!(7, buf.remaining());

Source

fn try_get_u64_le(&mut self) -> Result<u64, TryGetError>

从 self 以小端字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_le());
assert_eq!(7, buf.remaining());

Source

fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError>

从 self 以原生字节序读取无符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
    false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_ne());
assert_eq!(7, buf.remaining());

Source

fn try_get_i64(&mut self) -> Result<i64, TryGetError>

从 self 以大端字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64());
assert_eq!(7, buf.remaining());

Source

fn try_get_i64_le(&mut self) -> Result<i64, TryGetError>

从 self 以小端字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_le());
assert_eq!(7, buf.remaining());

Source

fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError>

从 self 以原生字节序读取有符号 64 位整数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
    false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_ne());
assert_eq!(7, buf.remaining());

Source

fn try_get_u128(&mut self) -> Result<u128, TryGetError>

从 self 以大端字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128());
assert_eq!(15, buf.remaining());

Source

fn try_get_u128_le(&mut self) -> Result<u128, TryGetError>

从 self 以小端字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_le());
assert_eq!(15, buf.remaining());

Source

fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError>

从 self 以原生字节序读取无符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
    false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_ne());
assert_eq!(15, buf.remaining());

Source

fn try_get_i128(&mut self) -> Result<i128, TryGetError>

从 self 以大端字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128());
assert_eq!(15, buf.remaining());

Source

fn try_get_i128_le(&mut self) -> Result<i128, TryGetError>

从 self 以小端字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_le());
assert_eq!(15, buf.remaining());

Source

fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError>

从 self 以原生字节序读取有符号 128 位整数。

当前位置前进 16 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
    false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_ne());
assert_eq!(15, buf.remaining());

Source

fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError>

从 self 以大端字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03 hello"[..];
assert_eq!(Ok(0x010203_u64), buf.try_get_uint(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes > 8，此函数会 panic。

Source

fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError>

从 self 以小端字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x010203_u64), buf.try_get_uint_le(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_le(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes > 8，此函数会 panic。

Source

fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError>

从 self 以原生字节序读取一个 n 字节无符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03 hello",
    false => b"\x03\x02\x01 hello",
};
assert_eq!(Ok(0x010203_u64), buf.try_get_uint_ne(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03",
    false => b"\x03\x02\x01",
};
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_ne(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes 大于 8，此函数会 panic。

Source

fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError>

从 self 以大端字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x01\x02\x03 hello"[..];
assert_eq!(Ok(0x010203_i64), buf.try_get_int(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes 大于 8，此函数会 panic。

Source

fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError>

从 self 以小端字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(Ok(0x010203_i64), buf.try_get_int_le(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x01\x02\x03"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_le(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes 大于 8，此函数会 panic。

Source

fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError>

从 self 以原生字节序读取一个 n 字节有符号整数。

当前位置推进 nbytes 字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03 hello",
    false => b"\x03\x02\x01 hello",
};
assert_eq!(Ok(0x010203_i64), buf.try_get_int_ne(3));
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x01\x02\x03",
    false => b"\x03\x02\x01",
};
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_ne(4));
assert_eq!(3, buf.remaining());

§Panics

若 nbytes 大于 8，此函数会 panic。

Source

fn try_get_f32(&mut self) -> Result<f32, TryGetError>

从 self 以大端字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
assert_eq!(1.2f32, buf.get_f32());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\x99\x99"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32());
assert_eq!(3, buf.remaining());

Source

fn try_get_f32_le(&mut self) -> Result<f32, TryGetError>

从 self 以小端字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
assert_eq!(1.2f32, buf.get_f32_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\x99\x99"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_le());
assert_eq!(3, buf.remaining());

Source

fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError>

从 self 以原生字节序读取 IEEE754 单精度（4 字节）浮点数。

当前位置前进 4 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x3F\x99\x99\x9A hello",
    false => b"\x9A\x99\x99\x3F hello",
};
assert_eq!(1.2f32, buf.get_f32_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\x99\x99"[..];
assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_ne());
assert_eq!(3, buf.remaining());

Source

fn try_get_f64(&mut self) -> Result<f64, TryGetError>

从 self 以大端字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
assert_eq!(1.2f64, buf.get_f64());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64());
assert_eq!(7, buf.remaining());

Source

fn try_get_f64_le(&mut self) -> Result<f64, TryGetError>

从 self 以小端字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
assert_eq!(1.2f64, buf.get_f64_le());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_le());
assert_eq!(7, buf.remaining());

Source

fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError>

从 self 以原生字节序读取 IEEE754 双精度（8 字节）浮点数。

当前位置前进 8 个字节。

当没有足够的剩余字节读取值时返回 Err(TryGetError)。

§示例

use bytes::Buf;

let mut buf: &[u8] = match cfg!(target_endian = "big") {
    true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
    false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
};
assert_eq!(1.2f64, buf.get_f64_ne());
assert_eq!(6, buf.remaining());

use bytes::{Buf, TryGetError};

let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_ne());
assert_eq!(7, buf.remaining());

Source

fn copy_to_bytes(&mut self, len: usize) -> Bytes

消耗 self 中的 len 字节，并返回包含此数据的新 Bytes 实例。

此函数可由底层类型优化以避免实际复制。例如，Bytes 的实现将执行浅拷贝（引用计数递增）。

§示例

use bytes::Buf;

let bytes = (&b"hello world"[..]).copy_to_bytes(5);
assert_eq!(&bytes[..], &b"hello"[..]);

§Panics

若 len > self.remaining()，此函数会 panic。

Source

fn take(self, limit: usize) -> Take<Self>
where Self: Sized,

创建一个适配器，从 self 中最多读取 limit 字节。

此函数返回一个新的 Buf 实例，其最多读取 limit 字节。

§示例

use bytes::{Buf, BufMut};

let mut buf = b"hello world"[..].take(5);
let mut dst = vec![];

dst.put(&mut buf);
assert_eq!(dst, b"hello");

let mut buf = buf.into_inner();
dst.clear();
dst.put(&mut buf);
assert_eq!(dst, b" world");

Source

fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
where Self: Sized,

创建一个将此缓冲区与另一个缓冲区链接起来的适配器。

返回的 Buf 实例将先消耗 self 中的所有字节。之后其输出等价于 next 的输出。

§示例

use bytes::Buf;

let mut chain = b"hello "[..].chain(&b"world"[..]);

let full = chain.copy_to_bytes(11);
assert_eq!(full.chunk(), b"hello world");

Source

fn reader(self) -> Reader<Self> ⓘ
where Self: Sized,

创建一个为 self 实现 Read trait 的适配器。

此函数返回一个新值，通过将 Read trait 函数适配到 Buf trait 函数来实现 Read。由于 Buf 操作是 infallible 的，Read 函数都不会返回 Err。

§示例

use bytes::{Bytes, Buf};
use std::io::Read;

let buf = Bytes::from("hello world");

let mut reader = buf.reader();
let mut dst = [0; 1024];

let num = reader.read(&mut dst).unwrap();

assert_eq!(11, num);
assert_eq!(&dst[..11], &b"hello world"[..]);