[−][src]Struct bytes::Bytes

pub struct Bytes { /* fields omitted */ }

A reference counted contiguous slice of memory.

Bytes is an efficient container for storing and operating on contiguous slices of memory. It is intended for use primarily in networking code, but could have applications elsewhere as well.

Bytes values facilitate zero-copy network programming by allowing multiple Bytes objects to point to the same underlying memory. This is managed by using a reference count to track when the memory is no longer needed and can be freed.

use bytes::Bytes;

let mut mem = Bytes::from(&b"Hello world"[..]);
let a = mem.slice(0, 5);

assert_eq!(&a[..], b"Hello");

let b = mem.split_to(6);

assert_eq!(&mem[..], b"world");
assert_eq!(&b[..], b"Hello ");

Memory layout

The Bytes struct itself is fairly small, limited to a pointer to the memory and 4 usize fields used to track information about which segment of the underlying memory the Bytes handle has access to.

The memory layout looks like this:

+-------+
| Bytes |
+-------+
 /      \_____
|              \
v               v
+-----+------------------------------------+
| Arc |         |      Data     |          |
+-----+------------------------------------+

Bytes keeps both a pointer to the shared Arc containing the full memory slice and a pointer to the start of the region visible by the handle. Bytes also tracks the length of its view into the memory.

The memory itself is reference counted, and multiple Bytes objects may point to the same region. Each Bytes handle point to different sections within the memory region, and Bytes handle may or may not have overlapping views into the memory.


   Arc ptrs                   +---------+
   ________________________ / | Bytes 2 |
  /                           +---------+
 /          +-----------+     |         |
|_________/ |  Bytes 1  |     |         |
|           +-----------+     |         |
|           |           | ___/ data     | tail
|      data |      tail |/              |
v           v           v               v
+-----+---------------------------------+-----+
| Arc |     |           |               |     |
+-----+---------------------------------+-----+

Mutating

While Bytes handles may potentially represent overlapping views of the underlying memory slice and may not be mutated, BytesMut handles are guaranteed to be the only handle able to view that slice of memory. As such, BytesMut handles are able to mutate the underlying memory. Note that holding a unique view to a region of memory does not mean that there are no other Bytes and BytesMut handles with disjoint views of the underlying memory.

Inline bytes

As an optimization, when the slice referenced by a Bytes or BytesMut handle is small enough ¹, with_capacity will avoid the allocation by inlining the slice directly in the handle. In this case, a clone is no longer "shallow" and the data will be copied. Converting from a Vec will never use inlining.

Small enough: 31 bytes on 64 bit systems, 15 on 32 bit systems. ↩

Implementations

`impl Bytes`[src]

`pub fn with_capacity(capacity: usize) -> Bytes`[src]

Creates a new Bytes with the specified capacity.

The returned Bytes will be able to hold at least capacity bytes without reallocating. If capacity is under 4 * size_of::<usize>() - 1, then BytesMut will not allocate.

It is important to note that this function does not specify the length of the returned Bytes, but only the capacity.

Examples

use bytes::Bytes;

let mut bytes = Bytes::with_capacity(64);

// `bytes` contains no data, even though there is capacity
assert_eq!(bytes.len(), 0);

bytes.extend_from_slice(&b"hello world"[..]);

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

`pub fn new() -> Bytes`[src]

Creates a new empty Bytes.

This will not allocate and the returned Bytes handle will be empty.

Examples

use bytes::Bytes;

let b = Bytes::new();
assert_eq!(&b[..], b"");

`pub fn from_static(bytes: &'static [u8]) -> Bytes`[src]

Creates a new Bytes from a static slice.

The returned Bytes will point directly to the static slice. There is no allocating or copying.

Examples

use bytes::Bytes;

let b = Bytes::from_static(b"hello");
assert_eq!(&b[..], b"hello");

`pub fn len(&self) -> usize`[src]

Returns the number of bytes contained in this Bytes.

Examples

use bytes::Bytes;

let b = Bytes::from(&b"hello"[..]);
assert_eq!(b.len(), 5);

`pub fn is_empty(&self) -> bool`[src]

Returns true if the Bytes has a length of 0.

Examples

use bytes::Bytes;

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

`pub fn slice(&self, begin: usize, end: usize) -> Bytes`[src]

Returns a slice of self for the index range [begin..end).

This will increment the reference count for the underlying memory and return a new Bytes handle set to the slice.

This operation is O(1).

Examples

use bytes::Bytes;

let a = Bytes::from(&b"hello world"[..]);
let b = a.slice(2, 5);

assert_eq!(&b[..], b"llo");

Panics

Requires that begin <= end and end <= self.len(), otherwise slicing will panic.

`pub fn slice_from(&self, begin: usize) -> Bytes`[src]

Returns a slice of self for the index range [begin..self.len()).

This will increment the reference count for the underlying memory and return a new Bytes handle set to the slice.

This operation is O(1) and is equivalent to self.slice(begin, self.len()).

Examples

use bytes::Bytes;

let a = Bytes::from(&b"hello world"[..]);
let b = a.slice_from(6);

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

Panics

Requires that begin <= self.len(), otherwise slicing will panic.

`pub fn slice_to(&self, end: usize) -> Bytes`[src]

Returns a slice of self for the index range [0..end).

This will increment the reference count for the underlying memory and return a new Bytes handle set to the slice.

This operation is O(1) and is equivalent to self.slice(0, end).

Examples

use bytes::Bytes;

let a = Bytes::from(&b"hello world"[..]);
let b = a.slice_to(5);

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

Panics

Requires that end <= self.len(), otherwise slicing will panic.

`pub fn slice_ref(&self, subset: &[u8]) -> Bytes`[src]

Returns a slice of self that is equivalent to the given subset.

When processing a Bytes buffer with other tools, one often gets a &[u8] which is in fact a slice of the Bytes, i.e. a subset of it. This function turns that &[u8] into another Bytes, as if one had called self.slice() with the offsets that correspond to subset.

This operation is O(1).

Examples

use bytes::Bytes;

let bytes = Bytes::from(&b"012345678"[..]);
let as_slice = bytes.as_ref();
let subset = &as_slice[2..6];
let subslice = bytes.slice_ref(&subset);
assert_eq!(&subslice[..], b"2345");

Panics

Requires that the given sub slice is in fact contained within the Bytes buffer; otherwise this function will panic.

`pub fn split_off(&mut self, at: usize) -> Bytes`[src]

Splits the bytes into two at the given index.

Afterwards self contains elements [0, at), and the returned Bytes contains elements [at, len).

This is an O(1) operation that just increases the reference count and sets a few indices.

Examples

use bytes::Bytes;

let mut a = Bytes::from(&b"hello world"[..]);
let b = a.split_off(5);

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

Panics

Panics if at > len.

`pub fn split_to(&mut self, at: usize) -> Bytes`[src]

Splits the bytes into two at the given index.

Afterwards self contains elements [at, len), and the returned Bytes contains elements [0, at).

This is an O(1) operation that just increases the reference count and sets a few indices.

Examples

use bytes::Bytes;

let mut a = Bytes::from(&b"hello world"[..]);
let b = a.split_to(5);

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

Panics

Panics if at > len.

`pub fn truncate(&mut self, len: usize)`[src]

Shortens the buffer, keeping the first len bytes and dropping the rest.

If len is greater than the buffer's current length, this has no effect.

The split_off method can emulate truncate, but this causes the excess bytes to be returned instead of dropped.

Examples

use bytes::Bytes;

let mut buf = Bytes::from(&b"hello world"[..]);
buf.truncate(5);
assert_eq!(buf, b"hello"[..]);

`pub fn advance(&mut self, cnt: usize)`[src]

Shortens the buffer, dropping the first cnt bytes and keeping the rest.

This is the same function as Buf::advance, and in the next breaking release of bytes, this implementation will be removed in favor of having Bytes implement Buf.

Panics

This function panics if cnt is greater than self.len()

`pub fn clear(&mut self)`[src]

Clears the buffer, removing all data.

Examples

use bytes::Bytes;

let mut buf = Bytes::from(&b"hello world"[..]);
buf.clear();
assert!(buf.is_empty());

`pub fn try_mut(self) -> Result<BytesMut, Bytes>`[src]

Attempts to convert into a BytesMut handle.

This will only succeed if there are no other outstanding references to the underlying chunk of memory. Bytes handles that contain inlined bytes will always be convertable to BytesMut.

Examples

use bytes::Bytes;

let a = Bytes::from(&b"Mary had a little lamb, little lamb, little lamb..."[..]);

// Create a shallow clone
let b = a.clone();

// This will fail because `b` shares a reference with `a`
let a = a.try_mut().unwrap_err();

drop(b);

// This will succeed
let mut a = a.try_mut().unwrap();

a[0] = b'b';

assert_eq!(&a[..4], b"bary");

`pub fn extend_from_slice(&mut self, extend: &[u8])`[src]

Appends given bytes to this object.

If this Bytes object has not enough capacity, it is resized first. If it is shared (refcount > 1), it is copied first.

This operation can be less effective than the similar operation on BytesMut, especially on small additions.

Examples

use bytes::Bytes;

let mut buf = Bytes::from("aabb");
buf.extend_from_slice(b"ccdd");
buf.extend_from_slice(b"eeff");

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