Struct ClientResult 

pub struct ClientResult<T> { /* private fields */ }

The outcome of a client operation.

Different from the standard Result, this one may contain more than one error. And at the same time, even if an error ocurrs, there may be a value to rescue.

It would be mistake if this contains no value and no errors at the same time. This is taken care on creation time, and it can’t be modified afterwards.

Implementations

impl<T> ClientResult<T>

pub fn new_ok(value: T) -> ClientResult<T>

Creates a result containing a successful value and no errors.

pub fn new_err(errors: Vec<ClientError>) -> ClientResult<T>

Creates a result containing errors and no value to rescue.

The errors list should be non empty. If it’s empty a default error will be added to avoid the invariant of having no value and no errors at the same time.

pub fn new_ok_and_err(value: T, errors: Vec<ClientError>) -> ClientResult<T>

Creates a result containing errors and a value to rescue.

This method should only be used when there are both errors and a value.

• If there are no errors, use ClientResult::new_ok instead.
• Similar to ClientResult::new_err, if the errors list is empty, a default error will be added.

pub fn value(&self) -> Option<&T>

Returns the successful value if there is one.

pub fn errors(&self) -> &[ClientError]

Returns the errors list.

pub fn value_and_errors(&self) -> (Option<&T>, &[ClientError])

Returns the successful value and the errors list.

pub fn new_unchecked( value: Option<T>, errors: Vec<ClientError>, ) -> ClientResult<T>

Creates a result with the given value and errors without checking the invariant of having at least one of them.

Warning: The main purpose of this method is to construct ClientResults from already existing ClientResults that are known to be valid. Using this without caution may lead to invalid states and panic at runtime.

pub fn map_value<'t, U>(&'t self, f: impl FnOnce(&'t T) -> U) -> ClientResult<U>

where U: 't,

Maps the successful value to another value, cloning the errors list.

pub fn has_value(&self) -> bool

Returns true if there is a successful value.

pub fn has_errors(&self) -> bool

Returns true if there are errors.

pub fn into_value(self) -> Option<T>

Consume the result and return the successful value if there is one.

pub fn into_errors(self) -> Vec<ClientError>

Consume the result and return the errors list.

pub fn into_value_and_errors(self) -> (Option<T>, Vec<ClientError>)

Consume the result and return the successful value and the errors list.

pub fn try_from_value_and_errors( value: Option<T>, errors: Vec<ClientError>, ) -> Result<ClientResult<T>, ClientError>

Crates a ClientResult from an optional value and a list of errors, failing if both are empty (as it would violate the invariant).

The Err case will contain a default ClientError indicating that no value nor errors were provided. You can forward this error into ClientResult::new_err to construct a fallback result, but the error message is addressed to devs, not users.

This method is essentially the inverse of ClientResult::into_value_and_errors.

This method can be used through the standard TryFrom trait as well, when you have a tuple of (Option<T>, Vec<ClientError>), either by calling try_from or try_into.

pub fn into_result(self) -> Result<T, Vec<ClientError>>

Consume the result to convert it into a standard Result.

Trait Implementations

impl<T> Clone for ClientResult<T>

where T: Clone,

fn clone(&self) -> ClientResult<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ClientResult<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> From<ClientError> for ClientResult<T>

fn from(error: ClientError) -> ClientResult<T>

Converts to this type from the input type.

impl<T> From<Result<T, ClientError>> for ClientResult<T>

fn from(result: Result<T, ClientError>) -> ClientResult<T>

Converts to this type from the input type.

impl<T> From<Result<T, Vec<ClientError>>> for ClientResult<T>

fn from(result: Result<T, Vec<ClientError>>) -> ClientResult<T>

Converts to this type from the input type.

impl<T> TryFrom<(Option<T>, Vec<ClientError>)> for ClientResult<T>

type Error = ClientError

The type returned in the event of a conversion error.

fn try_from( value: (Option<T>, Vec<ClientError>), ) -> Result<ClientResult<T>, <ClientResult<T> as TryFrom<(Option<T>, Vec<ClientError>)>>::Error>

Performs the conversion.