Struct Annotated 

pub struct Annotated<R> {
    pub data: Option<R>,
    pub id: Option<String>,
    pub event: Option<String>,
    pub comment: Option<Vec<String>>,
}

Our services have the option of returning an “annotated” stream, which allows use to include additional information with each delta. This is useful for debugging, performance benchmarking, and improved observability.

Fields

data: Option<R>

id: Option<String>

event: Option<String>

comment: Option<Vec<String>>

Implementations

impl<R> Annotated<R>

pub fn from_error(error: String) -> Self

Create a new annotated stream from the given error

pub fn from_data(data: R) -> Self

Create a new annotated stream from the given data

pub fn from_annotation<S: Serialize>( name: impl Into<String>, value: &S, ) -> Result<Self, Error>

Add an annotation to the stream

Annotations populate the event field and the comment field

pub fn ok(self) -> Result<Self, String>

Convert to a Result<Self, String> If Self::event is “error”, return an error message(s) held by Self::comment

pub fn is_ok(&self) -> bool

pub fn is_err(&self) -> bool

pub fn is_event(&self) -> bool

pub fn transfer<U: Serialize>(self, data: Option<U>) -> Annotated<U>

pub fn map_data<U, F>(self, transform: F) -> Annotated<U>

where F: FnOnce(R) -> Result<U, String>,

Apply a mapping/transformation to the data field If the mapping fails, the error is returned as an annotated stream

pub fn is_error(&self) -> bool

pub fn into_result(self) -> Result<Option<R>>

Trait Implementations

impl<R: Clone> Clone for Annotated<R>

fn clone(&self) -> Annotated<R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug> Debug for Annotated<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for Annotated<R>

where R: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> MaybeError for Annotated<R>

where R: for<'de> Deserialize<'de> + Serialize,

fn from_err(err: Box<dyn Error + Send + Sync>) -> Self

Construct an instance from an error.

fn err(&self) -> Option<Box<dyn Error + Send + Sync>>

Construct into an error instance.

fn is_ok(&self) -> bool

Check if the current instance represents a success.

fn is_err(&self) -> bool

Check if the current instance represents an error.

impl<R> Serialize for Annotated<R>

where R: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.