#[repr(C)]pub struct Tendril<F, A = NonAtomic> where
F: Format,
A: Atomicity, { /* private fields */ }
Expand description
Compact string type for zero-copy parsing.
Tendril
s have the semantics of owned strings, but are sometimes views
into shared buffers. When you mutate a Tendril
, an owned copy is made
if necessary. Further mutations occur in-place until the string becomes
shared, e.g. with clone()
or subtendril()
.
Buffer sharing is accomplished through thread-local (non-atomic) reference
counting, which has very low overhead. The Rust type system will prevent
you at compile time from sending a Tendril
between threads. We plan to
relax this restriction in the future; see README.md
.
Whereas String
allocates in the heap for any non-empty string, Tendril
can store small strings (up to 8 bytes) in-line, without a heap allocation.
Tendril
is also smaller than String
on 64-bit platforms — 16 bytes
versus 24.
The type parameter F
specifies the format of the tendril, for example
UTF-8 text or uninterpreted bytes. The parameter will be instantiated
with one of the marker types from tendril::fmt
. See the StrTendril
and ByteTendril
type aliases for two examples.
The type parameter A
indicates the atomicity of the tendril; it is by
default NonAtomic
, but can be specified as Atomic
to get a tendril
which implements Send
(viz. a thread-safe tendril).
The maximum length of a Tendril
is 4 GB. The library will panic if
you attempt to go over the limit.
Implementations
impl<F, A> Tendril<F, A> where
F: Format,
A: Atomicity,
impl<F, A> Tendril<F, A> where
F: Format,
A: Atomicity,
pub fn new() -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn new() -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Create a new, empty Tendril
in any format.
pub fn with_capacity(capacity: u32) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn with_capacity(capacity: u32) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Create a new, empty Tendril
with a specified capacity.
pub fn reserve(&mut self, additional: u32)
pub fn reserve(&mut self, additional: u32)
Reserve space for additional bytes.
This is only a suggestion. There are cases where Tendril
will
decline to allocate until the buffer is actually modified.
pub fn len32(&self) -> u32
pub fn len32(&self) -> u32
Get the length of the Tendril
.
This is named not to conflict with len()
on the underlying
slice, if any.
Is the backing buffer shared?
Is the backing buffer shared with this other Tendril
?
pub fn clear(&mut self)
pub fn clear(&mut self)
Truncate to length 0 without discarding any owned storage.
pub fn try_from_byte_slice(x: &[u8]) -> Result<Tendril<F, A>, ()>
pub fn try_from_byte_slice(x: &[u8]) -> Result<Tendril<F, A>, ()>
Build a Tendril
by copying a byte slice, if it conforms to the format.
pub fn as_bytes(&self) -> &Tendril<Bytes, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn as_bytes(&self) -> &Tendril<Bytes, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
View as uninterpreted bytes.
pub fn into_bytes(self) -> Tendril<Bytes, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn into_bytes(self) -> Tendril<Bytes, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Convert into uninterpreted bytes.
pub fn into_send(self) -> SendTendril<F>
pub fn into_send(self) -> SendTendril<F>
Convert self
into a type which is Send
.
If the tendril is owned or inline, this is free, but if it’s shared this will entail a copy of the contents.
pub fn as_superset<Super>(&self) -> &Tendril<Super, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
F: SubsetOf<Super>,
Super: Format,
pub fn as_superset<Super>(&self) -> &Tendril<Super, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
F: SubsetOf<Super>,
Super: Format,
A: Atomicity,
View as a superset format, for free.
pub fn into_superset<Super>(self) -> Tendril<Super, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
F: SubsetOf<Super>,
Super: Format,
pub fn into_superset<Super>(self) -> Tendril<Super, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
F: SubsetOf<Super>,
Super: Format,
A: Atomicity,
Convert into a superset format, for free.
pub fn try_as_subset<Sub>(&self) -> Result<&Tendril<Sub, A>, ()> where
Sub: SubsetOf<F>,
pub fn try_as_subset<Sub>(&self) -> Result<&Tendril<Sub, A>, ()> where
Sub: SubsetOf<F>,
View as a subset format, if the Tendril
conforms to that subset.
pub fn try_into_subset<Sub>(self) -> Result<Tendril<Sub, A>, Tendril<F, A>> where
Sub: SubsetOf<F>,
pub fn try_into_subset<Sub>(self) -> Result<Tendril<Sub, A>, Tendril<F, A>> where
Sub: SubsetOf<F>,
Convert into a subset format, if the Tendril
conforms to that subset.
pub fn try_reinterpret_view<Other>(&self) -> Result<&Tendril<Other, A>, ()> where
Other: Format,
pub fn try_reinterpret_view<Other>(&self) -> Result<&Tendril<Other, A>, ()> where
Other: Format,
View as another format, if the bytes of the Tendril
are valid for
that format.
pub fn try_reinterpret<Other>(self) -> Result<Tendril<Other, A>, Tendril<F, A>> where
Other: Format,
pub fn try_reinterpret<Other>(self) -> Result<Tendril<Other, A>, Tendril<F, A>> where
Other: Format,
Convert into another format, if the Tendril
conforms to that format.
This only re-validates the existing bytes under the new format. It will not change the byte content of the tendril!
See the encode
and decode
methods for character encoding conversion.
pub fn try_push_bytes(&mut self, buf: &[u8]) -> Result<(), ()>
pub fn try_push_bytes(&mut self, buf: &[u8]) -> Result<(), ()>
Push some bytes onto the end of the Tendril
, if they conform to the
format.
pub fn push_tendril(&mut self, other: &Tendril<F, A>)
pub fn push_tendril(&mut self, other: &Tendril<F, A>)
Push another Tendril
onto the end of this one.
pub fn try_subtendril(
&self,
offset: u32,
length: u32
) -> Result<Tendril<F, A>, SubtendrilError>
pub fn try_subtendril(
&self,
offset: u32,
length: u32
) -> Result<Tendril<F, A>, SubtendrilError>
Attempt to slice this Tendril
as a new Tendril
.
This will share the buffer when possible. Mutating a shared buffer will copy the contents.
The offset and length are in bytes. The function will return
Err
if these are out of bounds, or if the resulting slice
does not conform to the format.
pub fn subtendril(&self, offset: u32, length: u32) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn subtendril(&self, offset: u32, length: u32) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Slice this Tendril
as a new Tendril
.
Panics on bounds or validity check failure.
pub fn try_pop_front(&mut self, n: u32) -> Result<(), SubtendrilError>
pub fn try_pop_front(&mut self, n: u32) -> Result<(), SubtendrilError>
Try to drop n
bytes from the front.
Returns Err
if the bytes are not available, or the suffix fails
validation.
pub fn pop_front(&mut self, n: u32)
pub fn pop_front(&mut self, n: u32)
Drop n
bytes from the front.
Panics if the bytes are not available, or the suffix fails validation.
pub fn try_pop_back(&mut self, n: u32) -> Result<(), SubtendrilError>
pub fn try_pop_back(&mut self, n: u32) -> Result<(), SubtendrilError>
Drop n
bytes from the back.
Returns Err
if the bytes are not available, or the prefix fails
validation.
pub fn pop_back(&mut self, n: u32)
pub fn pop_back(&mut self, n: u32)
Drop n
bytes from the back.
Panics if the bytes are not available, or the prefix fails validation.
pub unsafe fn reinterpret_view_without_validating<Other>(
&self
) -> &Tendril<Other, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
Other: Format,
pub unsafe fn reinterpret_view_without_validating<Other>(
&self
) -> &Tendril<Other, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
Other: Format,
A: Atomicity,
View as another format, without validating.
pub unsafe fn reinterpret_without_validating<Other>(self) -> Tendril<Other, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
Other: Format,
pub unsafe fn reinterpret_without_validating<Other>(self) -> Tendril<Other, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
where
Other: Format,
A: Atomicity,
Convert into another format, without validating.
pub unsafe fn from_byte_slice_without_validating(x: &[u8]) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub unsafe fn from_byte_slice_without_validating(x: &[u8]) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Build a Tendril
by copying a byte slice, without validating.
pub unsafe fn push_bytes_without_validating(&mut self, buf: &[u8])
pub unsafe fn push_bytes_without_validating(&mut self, buf: &[u8])
Push some bytes onto the end of the Tendril
, without validating.
pub unsafe fn unsafe_subtendril(
&self,
offset: u32,
length: u32
) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub unsafe fn unsafe_subtendril(
&self,
offset: u32,
length: u32
) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Slice this Tendril
as a new Tendril
.
Does not check validity or bounds!
pub unsafe fn unsafe_pop_front(&mut self, n: u32)
pub unsafe fn unsafe_pop_front(&mut self, n: u32)
Drop n
bytes from the front.
Does not check validity or bounds!
pub unsafe fn unsafe_pop_back(&mut self, n: u32)
pub unsafe fn unsafe_pop_back(&mut self, n: u32)
Drop n
bytes from the back.
Does not check validity or bounds!
impl<F, A> Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<F, A> Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
pub fn from_slice(x: &<F as SliceFormat>::Slice) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
pub fn from_slice(x: &<F as SliceFormat>::Slice) -> Tendril<F, A>ⓘNotable traits for Tendril<Bytes, A>impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
A: Atomicity,
Build a Tendril
by copying a slice.
pub fn push_slice(&mut self, x: &<F as SliceFormat>::Slice)
pub fn push_slice(&mut self, x: &<F as SliceFormat>::Slice)
Push a slice onto the end of the Tendril
.
impl<F, A> Tendril<F, A> where
F: for<'a> CharFormat<'a>,
A: Atomicity,
impl<F, A> Tendril<F, A> where
F: for<'a> CharFormat<'a>,
A: Atomicity,
pub fn pop_front_char(&'a mut self) -> Option<char>
pub fn pop_front_char(&'a mut self) -> Option<char>
Remove and return the first character, if any.
pub fn pop_front_char_run<C, R>(
&'a mut self,
classify: C
) -> Option<(Tendril<F, A>, R)> where
C: FnMut(char) -> R,
R: PartialEq<R>,
pub fn pop_front_char_run<C, R>(
&'a mut self,
classify: C
) -> Option<(Tendril<F, A>, R)> where
C: FnMut(char) -> R,
R: PartialEq<R>,
Remove and return a run of characters at the front of the Tendril
which are classified the same according to the function classify
.
Returns None
on an empty string.
pub fn try_push_char(&mut self, c: char) -> Result<(), ()>
pub fn try_push_char(&mut self, c: char) -> Result<(), ()>
Push a character, if it can be represented in this format.
impl<F, A> Tendril<F, A> where
A: Atomicity,
F: SliceFormat<Slice = [u8]>,
impl<F, A> Tendril<F, A> where
A: Atomicity,
F: SliceFormat<Slice = [u8]>,
pub unsafe fn push_uninitialized(&mut self, n: u32)
pub unsafe fn push_uninitialized(&mut self, n: u32)
Push “uninitialized bytes” onto the end.
Really, this grows the tendril without writing anything to the new area. It’s only defined for byte tendrils because it’s only useful if you plan to then mutate the buffer.
impl<A> Tendril<UTF8, A> where
A: Atomicity,
impl<A> Tendril<UTF8, A> where
A: Atomicity,
impl<A> Tendril<Bytes, A> where
A: Atomicity,
impl<A> Tendril<Bytes, A> where
A: Atomicity,
pub fn decode_utf8_lossy<F>(self, push_utf8: F) -> Option<IncompleteUtf8> where
F: FnMut(Tendril<UTF8, A>),
Trait Implementations
impl<F, A> AsRef<<F as SliceFormat>::Slice> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<F, A> AsRef<<F as SliceFormat>::Slice> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
fn as_ref(&self) -> &<F as SliceFormat>::Slice
fn as_ref(&self) -> &<F as SliceFormat>::Slice
Converts this type into a shared reference of the (usually inferred) input type.
impl<F, A> Debug for Tendril<F, A> where
F: SliceFormat + Default + Debug,
A: Atomicity,
<F as SliceFormat>::Slice: Debug,
impl<F, A> Debug for Tendril<F, A> where
F: SliceFormat + Default + Debug,
A: Atomicity,
<F as SliceFormat>::Slice: Debug,
impl<F, A> Deref for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<F, A> Deref for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
type Target = <F as SliceFormat>::Slice
type Target = <F as SliceFormat>::Slice
The resulting type after dereferencing.
fn deref(&self) -> &<F as SliceFormat>::Slice
fn deref(&self) -> &<F as SliceFormat>::Slice
Dereferences the value.
impl<F, A> DerefMut for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<F, A> DerefMut for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
fn deref_mut(&mut self) -> &mut <F as SliceFormat>::Slice
fn deref_mut(&mut self) -> &mut <F as SliceFormat>::Slice
Mutably dereferences the value.
impl<'a, A> Extend<&'a [u8]> for Tendril<Bytes, A> where
A: Atomicity,
impl<'a, A> Extend<&'a [u8]> for Tendril<Bytes, A> where
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a [u8]>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a [u8]>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<'a, F, A> Extend<&'a Tendril<F, A>> for Tendril<F, A> where
F: 'a + Format,
A: Atomicity,
impl<'a, F, A> Extend<&'a Tendril<F, A>> for Tendril<F, A> where
F: 'a + Format,
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a Tendril<F, A>>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a Tendril<F, A>>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<'a, A> Extend<&'a str> for Tendril<UTF8, A> where
A: Atomicity,
impl<'a, A> Extend<&'a str> for Tendril<UTF8, A> where
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a str>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a str>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<'a, A> Extend<&'a u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<'a, A> Extend<&'a u8> for Tendril<Bytes, A> where
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a u8>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = &'a u8>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<A> Extend<char> for Tendril<UTF8, A> where
A: Atomicity,
impl<A> Extend<char> for Tendril<UTF8, A> where
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = char>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = char>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<A> Extend<u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<A> Extend<u8> for Tendril<Bytes, A> where
A: Atomicity,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = u8>,
fn extend<I>(&mut self, iterable: I) where
I: IntoIterator<Item = u8>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<'a, F, A> From<&'a <F as SliceFormat>::Slice> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<'a, F, A> From<&'a <F as SliceFormat>::Slice> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
impl<F, A> From<SendTendril<F>> for Tendril<F, A> where
F: Format,
A: Atomicity,
impl<F, A> From<SendTendril<F>> for Tendril<F, A> where
F: Format,
A: Atomicity,
impl<F, A> From<Tendril<F, A>> for SendTendril<F> where
F: Format,
A: Atomicity,
impl<F, A> From<Tendril<F, A>> for SendTendril<F> where
F: Format,
A: Atomicity,
fn from(tendril: Tendril<F, A>) -> SendTendril<F>
fn from(tendril: Tendril<F, A>) -> SendTendril<F>
Converts to this type from the input type.
impl<'a, F, A> FromIterator<&'a Tendril<F, A>> for Tendril<F, A> where
F: 'a + Format,
A: Atomicity,
impl<'a, F, A> FromIterator<&'a Tendril<F, A>> for Tendril<F, A> where
F: 'a + Format,
A: Atomicity,
impl<'a, A> FromIterator<&'a str> for Tendril<UTF8, A> where
A: Atomicity,
impl<'a, A> FromIterator<&'a str> for Tendril<UTF8, A> where
A: Atomicity,
impl<'a, A> FromIterator<&'a u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<'a, A> FromIterator<&'a u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<A> FromIterator<char> for Tendril<UTF8, A> where
A: Atomicity,
impl<A> FromIterator<char> for Tendril<UTF8, A> where
A: Atomicity,
impl<A> FromIterator<u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<A> FromIterator<u8> for Tendril<Bytes, A> where
A: Atomicity,
impl<F, A> Ord for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
<F as SliceFormat>::Slice: Ord,
impl<F, A> Ord for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
<F as SliceFormat>::Slice: Ord,
impl<F, A> PartialOrd<Tendril<F, A>> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
<F as SliceFormat>::Slice: PartialOrd<<F as SliceFormat>::Slice>,
impl<F, A> PartialOrd<Tendril<F, A>> for Tendril<F, A> where
F: SliceFormat,
A: Atomicity,
<F as SliceFormat>::Slice: PartialOrd<<F as SliceFormat>::Slice>,
fn partial_cmp(&self, other: &Tendril<F, A>) -> Option<Ordering>
fn partial_cmp(&self, other: &Tendril<F, A>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
impl<A> Write for Tendril<Bytes, A> where
A: Atomicity,
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
Write a buffer into this writer, returning how many bytes were written. Read more
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer. Read more
fn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
sourcefn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)Determines if this Write
r has an efficient write_vectored
implementation. Read more
sourcefn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
write_all_vectored
)Attempts to write multiple buffers into this writer. Read more
impl<A> Write for Tendril<UTF8, A> where
A: Atomicity,
impl<A> Write for Tendril<UTF8, A> where
A: Atomicity,
impl<F, A> Eq for Tendril<F, A> where
F: Format,
A: Atomicity,
impl<F, A> Send for Tendril<F, A> where
F: Format,
A: Atomicity + Sync,
Auto Trait Implementations
impl<F, A = NonAtomic> !RefUnwindSafe for Tendril<F, A>
impl<F, A = NonAtomic> !Sync for Tendril<F, A>
impl<F, A> Unpin for Tendril<F, A> where
A: Unpin,
impl<F, A> UnwindSafe for Tendril<F, A> where
A: UnwindSafe,
F: RefUnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more