Struct ntex_bytes::BytesMut [−][src]
pub struct BytesMut { /* fields omitted */ }
Expand description
A unique reference to a contiguous slice of memory.
BytesMut
represents a unique view into a potentially shared memory region.
Given the uniqueness guarantee, owners of BytesMut
handles are able to
mutate the memory. It is similar to a Vec<u8>
but with less copies and
allocations.
For more detail, see Bytes.
Growth
One key difference from Vec<u8>
is that most operations do not
implicitly grow the buffer. This means that calling my_bytes.put("hello world");
could panic if my_bytes
does not have enough capacity. Before
writing to the buffer, ensure that there is enough remaining capacity by
calling my_bytes.remaining_mut()
. In general, avoiding calls to reserve
is preferable.
The only exception is extend
which implicitly reserves required capacity.
Examples
use ntex_bytes::{BytesMut, BufMut}; let mut buf = BytesMut::with_capacity(64); buf.put_u8(b'h'); buf.put_u8(b'e'); buf.put("llo"); assert_eq!(&buf[..], b"hello"); // Freeze the buffer so that it can be shared let a = buf.freeze(); // This does not allocate, instead `b` points to the same memory. let b = a.clone(); assert_eq!(&a[..], b"hello"); assert_eq!(&b[..], b"hello");
Implementations
Creates a new BytesMut
with the specified capacity.
The returned BytesMut
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 BytesMut
, but only the capacity.
Examples
use ntex_bytes::{BytesMut, BufMut}; let mut bytes = BytesMut::with_capacity(64); // `bytes` contains no data, even though there is capacity assert_eq!(bytes.len(), 0); bytes.put(&b"hello world"[..]); assert_eq!(&bytes[..], b"hello world");
Creates a new BytesMut
with default capacity.
Resulting object has length 0 and unspecified capacity. This function does not allocate.
Examples
use ntex_bytes::{BytesMut, BufMut}; let mut bytes = BytesMut::new(); assert_eq!(0, bytes.len()); bytes.reserve(2); bytes.put_slice(b"xy"); assert_eq!(&b"xy"[..], &bytes[..]);
Returns the number of bytes contained in this BytesMut
.
Examples
use ntex_bytes::BytesMut; let b = BytesMut::from(&b"hello"[..]); assert_eq!(b.len(), 5);
Returns true if the BytesMut
has a length of 0.
Examples
use ntex_bytes::BytesMut; let b = BytesMut::with_capacity(64); assert!(b.is_empty());
Return true if the BytesMut
uses inline allocation
Examples
use ntex_bytes::BytesMut; assert!(BytesMut::with_capacity(4).is_inline()); assert!(!BytesMut::from(Vec::with_capacity(4)).is_inline()); assert!(!BytesMut::with_capacity(1024).is_inline());
Returns the number of bytes the BytesMut
can hold without reallocating.
Examples
use ntex_bytes::BytesMut; let b = BytesMut::with_capacity(64); assert_eq!(b.capacity(), 64);
Converts self
into an immutable Bytes
.
The conversion is zero cost and is used to indicate that the slice referenced by the handle will no longer be mutated. Once the conversion is done, the handle can be cloned and shared across threads.
Examples
use ntex_bytes::{BytesMut, BufMut}; use std::thread; let mut b = BytesMut::with_capacity(64); b.put("hello world"); let b1 = b.freeze(); let b2 = b1.clone(); let th = thread::spawn(move || { assert_eq!(&b1[..], b"hello world"); }); assert_eq!(&b2[..], b"hello world"); th.join().unwrap();
Splits the bytes into two at the given index.
Afterwards self
contains elements [0, at)
, and the returned
BytesMut
contains elements [at, capacity)
.
This is an O(1)
operation that just increases the reference count
and sets a few indices.
Examples
use ntex_bytes::BytesMut; let mut a = BytesMut::from(&b"hello world"[..]); let mut b = a.split_off(5); a[0] = b'j'; b[0] = b'!'; assert_eq!(&a[..], b"jello"); assert_eq!(&b[..], b"!world");
Panics
Panics if at > capacity
.
Removes the bytes from the current view, returning them in a new
BytesMut
handle.
Afterwards, self
will be empty, but will retain any additional
capacity that it had before the operation. This is identical to
self.split_to(self.len())
.
This is an O(1)
operation that just increases the reference count and
sets a few indices.
Examples
use ntex_bytes::{BytesMut, BufMut}; let mut buf = BytesMut::with_capacity(1024); buf.put(&b"hello world"[..]); let other = buf.split(); assert!(buf.is_empty()); assert_eq!(1013, buf.capacity()); assert_eq!(other, b"hello world"[..]);
Splits the buffer into two at the given index.
Afterwards self
contains elements [at, len)
, and the returned BytesMut
contains elements [0, at)
.
This is an O(1)
operation that just increases the reference count and
sets a few indices.
Examples
use ntex_bytes::BytesMut; let mut a = BytesMut::from(&b"hello world"[..]); let mut b = a.split_to(5); a[0] = b'!'; b[0] = b'j'; assert_eq!(&a[..], b"!world"); assert_eq!(&b[..], b"jello");
Panics
Panics if at > len
.
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 ntex_bytes::BytesMut; let mut buf = BytesMut::from(&b"hello world"[..]); buf.truncate(5); assert_eq!(buf, b"hello"[..]);
Clears the buffer, removing all data.
Examples
use ntex_bytes::BytesMut; let mut buf = BytesMut::from(&b"hello world"[..]); buf.clear(); assert!(buf.is_empty());
Resizes the buffer so that len
is equal to new_len
.
If new_len
is greater than len
, the buffer is extended by the
difference with each additional byte set to value
. If new_len
is
less than len
, the buffer is simply truncated.
Examples
use ntex_bytes::BytesMut; let mut buf = BytesMut::new(); buf.resize(3, 0x1); assert_eq!(&buf[..], &[0x1, 0x1, 0x1]); buf.resize(2, 0x2); assert_eq!(&buf[..], &[0x1, 0x1]); buf.resize(4, 0x3); assert_eq!(&buf[..], &[0x1, 0x1, 0x3, 0x3]);
Sets the length of the buffer.
This will explicitly set the size of the buffer without actually modifying the data, so it is up to the caller to ensure that the data has been initialized.
Examples
use ntex_bytes::BytesMut; let mut b = BytesMut::from(&b"hello world"[..]); unsafe { b.set_len(5); } assert_eq!(&b[..], b"hello"); unsafe { b.set_len(11); } assert_eq!(&b[..], b"hello world");
Panics
This method will panic if len
is out of bounds for the underlying
slice or if it comes after the end
of the configured window.
Reserves capacity for at least additional
more bytes to be inserted
into the given BytesMut
.
More than additional
bytes may be reserved in order to avoid frequent
reallocations. A call to reserve
may result in an allocation.
Before allocating new buffer space, the function will attempt to reclaim space in the existing buffer. If the current handle references a small view in the original buffer and all other handles have been dropped, and the requested capacity is less than or equal to the existing buffer’s capacity, then the current view will be copied to the front of the buffer and the handle will take ownership of the full buffer.
Examples
In the following example, a new buffer is allocated.
use ntex_bytes::BytesMut; let mut buf = BytesMut::from(&b"hello"[..]); buf.reserve(64); assert!(buf.capacity() >= 69);
In the following example, the existing buffer is reclaimed.
use ntex_bytes::{BytesMut, BufMut}; let mut buf = BytesMut::with_capacity(128); buf.put(&[0; 64][..]); let ptr = buf.as_ptr(); let other = buf.split(); assert!(buf.is_empty()); assert_eq!(buf.capacity(), 64); drop(other); buf.reserve(128); assert_eq!(buf.capacity(), 128); assert_eq!(buf.as_ptr(), ptr);
Panics
Panics if the new capacity overflows usize
.
Appends given bytes to this object.
If this BytesMut
object has not enough capacity, it is resized first.
So unlike put_slice
operation, extend_from_slice
does not panic.
Examples
use ntex_bytes::BytesMut; let mut buf = BytesMut::with_capacity(0); buf.extend_from_slice(b"aaabbb"); buf.extend_from_slice(b"cccddd"); assert_eq!(b"aaabbbcccddd", &buf[..]);
Combine splitted BytesMut objects back as contiguous.
If BytesMut
objects were not contiguous originally, they will be extended.
Examples
use ntex_bytes::BytesMut; let mut buf = BytesMut::with_capacity(64); buf.extend_from_slice(b"aaabbbcccddd"); let splitted = buf.split_off(6); assert_eq!(b"aaabbb", &buf[..]); assert_eq!(b"cccddd", &splitted[..]); buf.unsplit(splitted); assert_eq!(b"aaabbbcccddd", &buf[..]);
Returns an iterator over the bytes contained by the buffer.
Examples
use ntex_bytes::{Buf, BytesMut}; let buf = BytesMut::from(&b"abc"[..]); let mut iter = buf.iter(); assert_eq!(iter.next().map(|b| *b), Some(b'a')); assert_eq!(iter.next().map(|b| *b), Some(b'b')); assert_eq!(iter.next().map(|b| *b), Some(b'c')); assert_eq!(iter.next(), None);
Trait Implementations
Returns the number of bytes between the current position and the end of the buffer. Read more
Returns a slice starting at the current position and of length between 0
and Buf::remaining()
. Note that this can return shorter slice (this allows
non-continuous internal representation). Read more
Returns true if there are any more bytes to consume Read more
Gets an unsigned 16 bit integer from self
in big-endian byte order. Read more
Gets an unsigned 16 bit integer from self
in little-endian byte order. Read more
Gets a signed 16 bit integer from self
in big-endian byte order. Read more
Gets a signed 16 bit integer from self
in little-endian byte order. Read more
Gets an unsigned 32 bit integer from self
in the big-endian byte order. Read more
Gets an unsigned 32 bit integer from self
in the little-endian byte order. Read more
Gets a signed 32 bit integer from self
in big-endian byte order. Read more
Gets a signed 32 bit integer from self
in little-endian byte order. Read more
Gets an unsigned 64 bit integer from self
in big-endian byte order. Read more
Gets an unsigned 64 bit integer from self
in little-endian byte order. Read more
Gets a signed 64 bit integer from self
in big-endian byte order. Read more
Gets a signed 64 bit integer from self
in little-endian byte order. Read more
Gets an unsigned 128 bit integer from self
in big-endian byte order. Read more
Gets an unsigned 128 bit integer from self
in little-endian byte order. Read more
Gets a signed 128 bit integer from self
in big-endian byte order. Read more
Gets a signed 128 bit integer from self
in little-endian byte order. Read more
Gets an unsigned n-byte integer from self
in big-endian byte order. Read more
Gets an unsigned n-byte integer from self
in little-endian byte order. Read more
Gets a signed n-byte integer from self
in big-endian byte order. Read more
Gets a signed n-byte integer from self
in little-endian byte order. Read more
Gets an IEEE754 single-precision (4 bytes) floating point number from
self
in big-endian byte order. Read more
Gets an IEEE754 single-precision (4 bytes) floating point number from
self
in little-endian byte order. Read more
Gets an IEEE754 double-precision (8 bytes) floating point number from
self
in big-endian byte order. Read more
Gets an IEEE754 double-precision (8 bytes) floating point number from
self
in little-endian byte order. Read more
Returns the number of bytes that can be written from the current position until the end of the buffer is reached. Read more
Advance the internal cursor of the BufMut Read more
Returns a mutable slice starting at the current BufMut position and of
length between 0 and BufMut::remaining_mut()
. Note that this can be shorter than the
whole remainder of the buffer (this allows non-continuous implementation). Read more
Transfer bytes into self
from src
and advance the cursor by the
number of bytes written. Read more
Returns true if there is space in self
for more bytes. Read more
Transfer bytes into self
from src
and advance the cursor by the
number of bytes written. Read more
Writes an unsigned 16 bit integer to self
in big-endian byte order. Read more
Writes an unsigned 16 bit integer to self
in little-endian byte order. Read more
Writes a signed 16 bit integer to self
in big-endian byte order. Read more
Writes a signed 16 bit integer to self
in little-endian byte order. Read more
Writes an unsigned 32 bit integer to self
in big-endian byte order. Read more
Writes an unsigned 32 bit integer to self
in little-endian byte order. Read more
Writes a signed 32 bit integer to self
in big-endian byte order. Read more
Writes a signed 32 bit integer to self
in little-endian byte order. Read more
Writes an unsigned 64 bit integer to self
in the big-endian byte order. Read more
Writes an unsigned 64 bit integer to self
in little-endian byte order. Read more
Writes a signed 64 bit integer to self
in the big-endian byte order. Read more
Writes a signed 64 bit integer to self
in little-endian byte order. Read more
Writes an unsigned 128 bit integer to self
in the big-endian byte order. Read more
Writes an unsigned 128 bit integer to self
in little-endian byte order. Read more
Writes a signed 128 bit integer to self
in the big-endian byte order. Read more
Writes a signed 128 bit integer to self
in little-endian byte order. Read more
Writes an unsigned n-byte integer to self
in big-endian byte order. Read more
Writes an unsigned n-byte integer to self
in the little-endian byte order. Read more
Writes a signed n-byte integer to self
in big-endian byte order. Read more
Writes a signed n-byte integer to self
in little-endian byte order. Read more
Writes an IEEE754 single-precision (4 bytes) floating point number to
self
in big-endian byte order. Read more
Writes an IEEE754 single-precision (4 bytes) floating point number to
self
in little-endian byte order. Read more
Writes an IEEE754 double-precision (8 bytes) floating point number to
self
in big-endian byte order. Read more
Writes an IEEE754 double-precision (8 bytes) floating point number to
self
in little-endian byte order. Read more
Extends a collection with the contents of an iterator. Read more
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
Extends a collection with the contents of an iterator. Read more
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
Creates a value from an iterator. Read more
Creates a value from an iterator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Writes a string slice into this writer, returning whether the write succeeded. Read more
Auto Trait Implementations
impl RefUnwindSafe for BytesMut
impl UnwindSafe for BytesMut
Blanket Implementations
Mutably borrows from an owned value. Read more