Struct bson::raw::RawDocumentBuf
source · pub struct RawDocumentBuf { /* private fields */ }
Expand description
An owned BSON document (akin to std::path::PathBuf
), backed by a buffer of raw BSON bytes.
This can be created from a Vec<u8>
or a crate::Document
.
Accessing elements within a RawDocumentBuf
is similar to element access in
crate::Document
, but because the contents are parsed during iteration instead of at creation
time, format errors can happen at any time during use.
Iterating over a RawDocumentBuf
yields either an error or a key-value pair that borrows from
the original document without making any additional allocations.
use bson::raw::RawDocumentBuf;
let doc = RawDocumentBuf::from_bytes(b"\x13\x00\x00\x00\x02hi\x00\x06\x00\x00\x00y'all\x00\x00".to_vec())?;
let mut iter = doc.iter();
let (key, value) = iter.next().unwrap()?;
assert_eq!(key, "hi");
assert_eq!(value.as_str(), Some("y'all"));
assert!(iter.next().is_none());
This type implements Deref
to RawDocument
, meaning that all methods on RawDocument
are available on RawDocumentBuf
values as well. This includes RawDocument::get
or any of
the type-specific getters, such as RawDocument::get_object_id
or RawDocument::get_str
.
Note that accessing elements is an O(N) operation, as it requires iterating through the document
from the beginning to find the requested key.
use bson::raw::RawDocumentBuf;
let doc = RawDocumentBuf::from_bytes(b"\x13\x00\x00\x00\x02hi\x00\x06\x00\x00\x00y'all\x00\x00".to_vec())?;
assert_eq!(doc.get_str("hi")?, "y'all");
Implementations§
source§impl RawDocumentBuf
impl RawDocumentBuf
sourcepub fn new() -> RawDocumentBuf
pub fn new() -> RawDocumentBuf
Creates a new, empty RawDocumentBuf
.
sourcepub fn from_bytes(data: Vec<u8>) -> Result<RawDocumentBuf>
pub fn from_bytes(data: Vec<u8>) -> Result<RawDocumentBuf>
Constructs a new RawDocumentBuf
, validating only the
following invariants:
data
is at least five bytes long (the minimum for a valid BSON document)- the initial four bytes of
data
accurately represent the length of the bytes as required by the BSON spec. - the last byte of
data
is a 0
Note that the internal structure of the bytes representing the BSON elements is not validated at all by this method. If the bytes do not conform to the BSON spec, then method calls on the RawDocument will return Errors where appropriate.
let doc = RawDocumentBuf::from_bytes(b"\x05\0\0\0\0".to_vec())?;
sourcepub fn from_document(doc: &Document) -> Result<RawDocumentBuf>
pub fn from_document(doc: &Document) -> Result<RawDocumentBuf>
Create a RawDocumentBuf
from a Document
.
use bson::{doc, oid::ObjectId, raw::RawDocumentBuf};
let document = doc! {
"_id": ObjectId::new(),
"name": "Herman Melville",
"title": "Moby-Dick",
};
let doc = RawDocumentBuf::from_document(&document)?;
sourcepub fn iter(&self) -> Iter<'_> ⓘ
pub fn iter(&self) -> Iter<'_> ⓘ
Gets an iterator over the elements in the RawDocumentBuf
, which yields
Result<(&str, RawBson<'_>)>
.
use bson::{doc, raw::RawDocumentBuf};
let doc = RawDocumentBuf::from_document(&doc! { "ferris": true })?;
for element in doc.iter() {
let (key, value) = element?;
assert_eq!(key, "ferris");
assert_eq!(value.as_bool(), Some(true));
}
Note:
There is no owning iterator for RawDocumentBuf
. If you need ownership over
elements that might need to allocate, you must explicitly convert
them to owned types yourself.
sourcepub fn into_bytes(self) -> Vec<u8> ⓘ
pub fn into_bytes(self) -> Vec<u8> ⓘ
Return the contained data as a Vec<u8>
use bson::{doc, raw::RawDocumentBuf};
let doc = RawDocumentBuf::from_document(&doc!{})?;
assert_eq!(doc.into_bytes(), b"\x05\x00\x00\x00\x00".to_vec());
sourcepub fn append(&mut self, key: impl AsRef<str>, value: impl Into<RawBson>)
pub fn append(&mut self, key: impl AsRef<str>, value: impl Into<RawBson>)
Append a key value pair to the end of the document without checking to see if the key already exists.
It is a user error to append the same key more than once to the same document, and it may result in errors when communicating with MongoDB.
If the provided key contains an interior null byte, this method will panic.
use bson::{doc, raw::RawDocumentBuf};
let mut doc = RawDocumentBuf::new();
doc.append("a string", "some string");
doc.append("an integer", 12_i32);
let mut subdoc = RawDocumentBuf::new();
subdoc.append("a key", true);
doc.append("a document", subdoc);
let expected = doc! {
"a string": "some string",
"an integer": 12_i32,
"a document": { "a key": true },
};
assert_eq!(doc.to_document()?, expected);
sourcepub fn to_document(&self) -> Result<Document>
pub fn to_document(&self) -> Result<Document>
Convert this RawDocumentBuf
to a Document
, returning an error
if invalid BSON is encountered.
Methods from Deref<Target = RawDocument>§
sourcepub fn to_raw_document_buf(&self) -> RawDocumentBuf
pub fn to_raw_document_buf(&self) -> RawDocumentBuf
Creates a new RawDocumentBuf
with an owned copy of the BSON bytes.
use bson::raw::{RawDocument, RawDocumentBuf, Error};
let data = b"\x05\0\0\0\0";
let doc_ref = RawDocument::from_bytes(data)?;
let doc: RawDocumentBuf = doc_ref.to_raw_document_buf();
sourcepub fn get(&self, key: impl AsRef<str>) -> Result<Option<RawBsonRef<'_>>>
pub fn get(&self, key: impl AsRef<str>) -> Result<Option<RawBsonRef<'_>>>
Gets a reference to the value corresponding to the given key by iterating until the key is found.
use bson::{rawdoc, oid::ObjectId};
let doc = rawdoc! {
"_id": ObjectId::new(),
"f64": 2.5,
};
let element = doc.get("f64")?.expect("finding key f64");
assert_eq!(element.as_f64(), Some(2.5));
assert!(doc.get("unknown")?.is_none());
sourcepub fn get_f64(&self, key: impl AsRef<str>) -> ValueAccessResult<f64>
pub fn get_f64(&self, key: impl AsRef<str>) -> ValueAccessResult<f64>
Gets a reference to the BSON double value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a double.
use bson::raw::ValueAccessErrorKind;
use bson::rawdoc;
let doc = rawdoc! {
"bool": true,
"f64": 2.5,
};
assert_eq!(doc.get_f64("f64")?, 2.5);
assert!(matches!(doc.get_f64("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_f64("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_str(&self, key: impl AsRef<str>) -> ValueAccessResult<&str>
pub fn get_str(&self, key: impl AsRef<str>) -> ValueAccessResult<&str>
Gets a reference to the string value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a string.
use bson::{rawdoc, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"string": "hello",
"bool": true,
};
assert_eq!(doc.get_str("string")?, "hello");
assert!(matches!(doc.get_str("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_str("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_document(
&self,
key: impl AsRef<str>
) -> ValueAccessResult<&RawDocument>
pub fn get_document( &self, key: impl AsRef<str> ) -> ValueAccessResult<&RawDocument>
Gets a reference to the document value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a document.
use bson::{rawdoc, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"doc": { "key": "value"},
"bool": true,
};
assert_eq!(doc.get_document("doc")?.get_str("key")?, "value");
assert!(matches!(doc.get_document("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_document("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_array(&self, key: impl AsRef<str>) -> ValueAccessResult<&RawArray>
pub fn get_array(&self, key: impl AsRef<str>) -> ValueAccessResult<&RawArray>
Gets a reference to the array value corresponding to a given key or returns an error if the key corresponds to a value which isn’t an array.
use bson::{rawdoc, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"array": [true, 3],
"bool": true,
};
let mut arr_iter = doc.get_array("array")?.into_iter();
let _: bool = arr_iter.next().unwrap()?.as_bool().unwrap();
let _: i32 = arr_iter.next().unwrap()?.as_i32().unwrap();
assert!(arr_iter.next().is_none());
assert!(doc.get_array("bool").is_err());
assert!(matches!(doc.get_array("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_binary(
&self,
key: impl AsRef<str>
) -> ValueAccessResult<RawBinaryRef<'_>>
pub fn get_binary( &self, key: impl AsRef<str> ) -> ValueAccessResult<RawBinaryRef<'_>>
Gets a reference to the BSON binary value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a binary value.
use bson::{
rawdoc,
raw::ValueAccessErrorKind,
spec::BinarySubtype,
Binary,
};
let doc = rawdoc! {
"binary": Binary { subtype: BinarySubtype::Generic, bytes: vec![1, 2, 3] },
"bool": true,
};
assert_eq!(&doc.get_binary("binary")?.bytes, &[1, 2, 3]);
assert!(matches!(doc.get_binary("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_binary("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_object_id(&self, key: impl AsRef<str>) -> ValueAccessResult<ObjectId>
pub fn get_object_id(&self, key: impl AsRef<str>) -> ValueAccessResult<ObjectId>
Gets a reference to the ObjectId value corresponding to a given key or returns an error if the key corresponds to a value which isn’t an ObjectId.
use bson::{rawdoc, oid::ObjectId, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"_id": ObjectId::new(),
"bool": true,
};
let oid = doc.get_object_id("_id")?;
assert!(matches!(doc.get_object_id("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_object_id("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_bool(&self, key: impl AsRef<str>) -> ValueAccessResult<bool>
pub fn get_bool(&self, key: impl AsRef<str>) -> ValueAccessResult<bool>
Gets a reference to the boolean value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a boolean.
use bson::{rawdoc, oid::ObjectId, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"_id": ObjectId::new(),
"bool": true,
};
assert!(doc.get_bool("bool")?);
assert!(matches!(doc.get_bool("_id").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_bool("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_datetime(&self, key: impl AsRef<str>) -> ValueAccessResult<DateTime>
pub fn get_datetime(&self, key: impl AsRef<str>) -> ValueAccessResult<DateTime>
Gets a reference to the BSON DateTime value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a DateTime.
use bson::{rawdoc, raw::ValueAccessErrorKind, DateTime};
let dt = DateTime::now();
let doc = rawdoc! {
"created_at": dt,
"bool": true,
};
assert_eq!(doc.get_datetime("created_at")?, dt);
assert!(matches!(doc.get_datetime("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_datetime("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_regex(
&self,
key: impl AsRef<str>
) -> ValueAccessResult<RawRegexRef<'_>>
pub fn get_regex( &self, key: impl AsRef<str> ) -> ValueAccessResult<RawRegexRef<'_>>
Gets a reference to the BSON regex value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a regex.
use bson::{rawdoc, Regex, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"regex": Regex {
pattern: r"end\s*$".into(),
options: "i".into(),
},
"bool": true,
};
assert_eq!(doc.get_regex("regex")?.pattern, r"end\s*$");
assert_eq!(doc.get_regex("regex")?.options, "i");
assert!(matches!(doc.get_regex("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_regex("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_timestamp(
&self,
key: impl AsRef<str>
) -> ValueAccessResult<Timestamp>
pub fn get_timestamp( &self, key: impl AsRef<str> ) -> ValueAccessResult<Timestamp>
Gets a reference to the BSON timestamp value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a timestamp.
use bson::{rawdoc, Timestamp, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"bool": true,
"ts": Timestamp { time: 649876543, increment: 9 },
};
let timestamp = doc.get_timestamp("ts")?;
assert_eq!(timestamp.time, 649876543);
assert_eq!(timestamp.increment, 9);
assert!(matches!(doc.get_timestamp("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_timestamp("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_i32(&self, key: impl AsRef<str>) -> ValueAccessResult<i32>
pub fn get_i32(&self, key: impl AsRef<str>) -> ValueAccessResult<i32>
Gets a reference to the BSON int32 value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a 32-bit integer.
use bson::{rawdoc, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"bool": true,
"i32": 1_000_000,
};
assert_eq!(doc.get_i32("i32")?, 1_000_000);
assert!(matches!(doc.get_i32("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { ..}));
assert!(matches!(doc.get_i32("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
sourcepub fn get_i64(&self, key: impl AsRef<str>) -> ValueAccessResult<i64>
pub fn get_i64(&self, key: impl AsRef<str>) -> ValueAccessResult<i64>
Gets a reference to the BSON int64 value corresponding to a given key or returns an error if the key corresponds to a value which isn’t a 64-bit integer.
use bson::{rawdoc, raw::ValueAccessErrorKind};
let doc = rawdoc! {
"bool": true,
"i64": 9223372036854775807_i64,
};
assert_eq!(doc.get_i64("i64")?, 9223372036854775807);
assert!(matches!(doc.get_i64("bool").unwrap_err().kind, ValueAccessErrorKind::UnexpectedType { .. }));
assert!(matches!(doc.get_i64("unknown").unwrap_err().kind, ValueAccessErrorKind::NotPresent));
Trait Implementations§
source§impl AsRef<RawDocument> for RawDocumentBuf
impl AsRef<RawDocument> for RawDocumentBuf
source§fn as_ref(&self) -> &RawDocument
fn as_ref(&self) -> &RawDocument
source§impl Borrow<RawDocument> for RawDocumentBuf
impl Borrow<RawDocument> for RawDocumentBuf
source§fn borrow(&self) -> &RawDocument
fn borrow(&self) -> &RawDocument
source§impl Clone for RawDocumentBuf
impl Clone for RawDocumentBuf
source§fn clone(&self) -> RawDocumentBuf
fn clone(&self) -> RawDocumentBuf
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for RawDocumentBuf
impl Debug for RawDocumentBuf
source§impl Default for RawDocumentBuf
impl Default for RawDocumentBuf
source§impl Deref for RawDocumentBuf
impl Deref for RawDocumentBuf
source§impl<'de> Deserialize<'de> for RawDocumentBuf
impl<'de> Deserialize<'de> for RawDocumentBuf
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,
source§impl<'a> From<&'a RawDocumentBuf> for Cow<'a, RawDocument>
impl<'a> From<&'a RawDocumentBuf> for Cow<'a, RawDocument>
source§fn from(rd: &'a RawDocumentBuf) -> Self
fn from(rd: &'a RawDocumentBuf) -> Self
source§impl<'a> From<&'a RawDocumentBuf> for RawBsonRef<'a>
impl<'a> From<&'a RawDocumentBuf> for RawBsonRef<'a>
source§fn from(d: &'a RawDocumentBuf) -> Self
fn from(d: &'a RawDocumentBuf) -> Self
source§impl<'a> From<RawDocumentBuf> for Cow<'a, RawDocument>
impl<'a> From<RawDocumentBuf> for Cow<'a, RawDocument>
source§fn from(rd: RawDocumentBuf) -> Self
fn from(rd: RawDocumentBuf) -> Self
source§impl From<RawDocumentBuf> for RawBson
impl From<RawDocumentBuf> for RawBson
source§fn from(d: RawDocumentBuf) -> Self
fn from(d: RawDocumentBuf) -> Self
source§impl<S: AsRef<str>, T: Into<RawBson>> FromIterator<(S, T)> for RawDocumentBuf
impl<S: AsRef<str>, T: Into<RawBson>> FromIterator<(S, T)> for RawDocumentBuf
source§impl<'a> IntoIterator for &'a RawDocumentBuf
impl<'a> IntoIterator for &'a RawDocumentBuf
source§impl PartialEq for RawDocumentBuf
impl PartialEq for RawDocumentBuf
source§fn eq(&self, other: &RawDocumentBuf) -> bool
fn eq(&self, other: &RawDocumentBuf) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl Serialize for RawDocumentBuf
impl Serialize for RawDocumentBuf
source§impl TryFrom<&Document> for RawDocumentBuf
impl TryFrom<&Document> for RawDocumentBuf
source§impl TryFrom<RawDocumentBuf> for Document
impl TryFrom<RawDocumentBuf> for Document
impl StructuralPartialEq for RawDocumentBuf
Auto Trait Implementations§
impl RefUnwindSafe for RawDocumentBuf
impl Send for RawDocumentBuf
impl Sync for RawDocumentBuf
impl Unpin for RawDocumentBuf
impl UnwindSafe for RawDocumentBuf
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> FmtForward for T
impl<T> FmtForward for T
source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,
self
to use its Display
implementation when
Debug
-formatted.source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere T: ?Sized,
source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,
source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,
self
and passes that borrow into the pipe function. Read moresource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,
self
and passes that borrow into the pipe function. Read moresource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,
source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,
source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,
self
, then passes self.as_ref()
into the pipe function.source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,
self
, then passes self.as_mut()
into the pipe
function.source§impl<T> Tap for T
impl<T> Tap for T
source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
Borrow<B>
of a value. Read moresource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
BorrowMut<B>
of a value. Read moresource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
AsRef<R>
view of a value. Read moresource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
AsMut<R>
view of a value. Read moresource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere Self: Deref<Target = T>, T: ?Sized,
Deref::Target
of a value. Read moresource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere Self: DerefMut<Target = T> + Deref, T: ?Sized,
Deref::Target
of a value. Read moresource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
.tap_borrow()
only in debug builds, and is erased in release
builds.source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
.tap_ref()
only in debug builds, and is erased in release
builds.source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
.tap_ref_mut()
only in debug builds, and is erased in release
builds.