Construct a new byte array.

Examples

let bytes = Bytes::new();
assert_eq!(bytes, b"");

Construct a byte array with the given preallocated capacity.

Examples

let bytes = Bytes::with_capacity(32);
assert_eq!(bytes, b"");
bytes.extend(b"abcd");
assert_eq!(bytes, b"abcd");

Convert a byte array into bytes.

Examples

let bytes = Bytes::from_vec([b'a', b'b', b'c', b'd']);
assert_eq!(bytes, b"abcd");

Convert the byte array into a vector of bytes.

Examples

let bytes = b"abcd";
assert_eq!([b'a', b'b', b'c', b'd'], bytes.into_vec());

assert!(!is_readable(bytes));

Convert the byte array into a vector of bytes without consuming it.

Examples

let bytes = b"abcd";
assert_eq!([b'a', b'b', b'c', b'd'], bytes.as_vec());

assert!(is_readable(bytes));

Extend these bytes with another collection of bytes.

Examples

let bytes = b"abcd";
bytes.extend(b"efgh");
assert_eq!(bytes, b"abcdefgh");

Extend this bytes collection with a string.

Examples

let bytes = b"abcd";
bytes.extend_str("efgh");
assert_eq!(bytes, b"abcdefgh");

Pop the last byte.

Examples

let bytes = b"abcd";
assert_eq!(bytes.pop(), Some(b'd'));
assert_eq!(bytes, b"abc");

Get the last byte.

Examples

let bytes = b"abcd";
assert_eq!(bytes.last(), Some(b'd'));

Get the length of the bytes collection.

Examples

let bytes = Bytes::new();
assert_eq!(bytes.len(), 0);
bytes.extend(b"abcd");
assert_eq!(bytes.len(), 4);

Test if the collection is empty.

Examples

let bytes = Bytes::new();
assert!(bytes.is_empty());

Returns the total number of elements the vector can hold without reallocating.

Examples

let bytes = Bytes::with_capacity(10);
bytes.extend(b"abc");
assert!(bytes.capacity() >= 10);

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

Examples

let bytes = b"abc";
bytes.clear();
assert!(bytes.is_empty());

Reserves capacity for at least additional more elements to be inserted in the given Bytes. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Examples

let vec = b"a";
vec.reserve(10);
assert!(vec.capacity() >= 11);

Reserves the minimum capacity for at least additional more elements to be inserted in the given Bytes. Unlike reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Examples

let vec = b"a";
vec.reserve_exact(10);
assert!(vec.capacity() >= 11);

Clone the byte array.

Examples

let a = b"hello world";
let b = a.clone();

a.extend(b"!");

assert_eq!(a, b"hello world!");
assert_eq!(b, b"hello world");

Shrinks the capacity of the byte array as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the byte array that there is space for a few more elements.

Examples

let bytes = Bytes::with_capacity(10);
bytes.extend(b"abc");
assert!(bytes.capacity() >= 10);
bytes.shrink_to_fit();
assert!(bytes.capacity() >= 3);