Enum RequestError 

pub enum RequestError {
    BadRequest {
        name: String,
        violations: Vec<PathError>,
    },
    Path(PathError),
    Generic(GenericErrorBox),
    Encode(EncodeError),
    Decode(DecodeError),
}

Request error types.

Variants

BadRequest

Invalid request with field violations.

Fields

name: String

Request name.

violations: Vec<PathError>

Field violations.

Path(PathError)

Path-specific error.

Generic(GenericErrorBox)

Generic error.

Encode(EncodeError)

Encode error.

Decode(DecodeError)

Decode error.

Implementations

impl RequestError

pub fn bad_request<N, V, F, E>(name: N, violations: V) -> Self

where N: Display, V: IntoIterator<Item = (F, E)>, F: Display, E: Into<GenericErrorBox>,

Creates a bad request error.

pub fn generic<E: Into<GenericErrorBox>>(error: E) -> Self

Creates a generic error.

pub fn path<P, E>(path: P, error: E) -> Self

where P: IntoIterator<Item = PathErrorStep>, E: Into<GenericErrorBox>,

Creates a path error.

pub fn field<F, E>(field: F, error: E) -> Self

where F: Display, E: Into<GenericErrorBox>,

Creates a field error.

pub fn field_index<F, E>(field: F, index: usize, error: E) -> Self

where F: Display, E: Into<GenericErrorBox>,

Creates a field index error.

pub fn field_key<F, K, E>(field: F, key: K, error: E) -> Self

where F: Display, K: Display, E: Into<GenericErrorBox>,

Creates a field key error.

pub fn field_parse<F, E>(field: F, error: E) -> Self

where F: Display, E: Into<GenericErrorBox>,

Creates a field parse error.

pub fn index<E>(index: usize, error: E) -> Self

where E: Into<GenericErrorBox>,

Creates an index error.

pub fn key<K, E>(key: K, error: E) -> Self

where K: Display, E: Into<GenericErrorBox>,

Creates a key error.

pub fn wrap_path<P>(self, path: P) -> Self

where P: IntoIterator<Item = PathErrorStep>,

Wraps the error with a path.

Panics

Will panic if trying to wrap error path for error types that don’t support path wrapping.

pub fn insert_path<P>(self, path: P, index: usize) -> Self

where P: IntoIterator<Item = PathErrorStep>,

Inserts a path at the specified index.

Panics

Will panic if trying to insert error path for error types that don’t support path insertion.

pub fn wrap_field<F: Display>(self, field: F) -> Self

Wraps the error with a field.

pub fn wrap_index(self, index: usize) -> Self

Wraps error with an index.

pub fn wrap_key<K: Display>(self, key: K) -> Self

Wraps error with a key.

pub fn wrap_field_index<F>(self, field: F, index: usize) -> Self

where F: Display,

Wraps error with a field and index.

pub fn wrap_field_key<F, K>(self, field: F, key: K) -> Self

where F: Display, K: Display,

Wraps error with a field and key.

pub fn wrap_request<N: Display>(self, name: N) -> Self

Wraps error for a request.

pub fn code(&self) -> Code

Returns the error code.

pub fn details(&self) -> Vec<Any>

Returns the error details.

Panics

Will panic if unable to convert bad request details to protobuf Any type.

Trait Implementations

impl Debug for RequestError

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

Formats the value using the given formatter.

impl Display for RequestError

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

Formats the value using the given formatter.

impl Error for RequestError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<&RequestError> for Status

fn from(err: &RequestError) -> Self

Converts to this type from the input type.

impl From<DecodeError> for RequestError

fn from(source: DecodeError) -> Self

Converts to this type from the input type.

impl From<EncodeError> for RequestError

fn from(source: EncodeError) -> Self

Converts to this type from the input type.

impl From<PathError> for RequestError

fn from(err: PathError) -> Self

Converts to this type from the input type.

impl From<RequestError> for Status

fn from(err: RequestError) -> Self

Converts to this type from the input type.

impl<T: 'static + GenericError + Send + Sync> From<T> for RequestError

fn from(err: T) -> Self

Converts to this type from the input type.