Enum parsec_interface::requests::ResponseStatus

#[repr(u16)]pub enum ResponseStatus {
    Success,
    WrongProviderID,
    ContentTypeNotSupported,
    AcceptTypeNotSupported,
    WireProtocolVersionNotSupported,
    ProviderNotRegistered,
    ProviderDoesNotExist,
    DeserializingBodyFailed,
    SerializingBodyFailed,
    OpcodeDoesNotExist,
    ResponseTooLarge,
    AuthenticationError,
    AuthenticatorDoesNotExist,
    AuthenticatorNotRegistered,
    KeyInfoManagerError,
    ConnectionError,
    InvalidEncoding,
    InvalidHeader,
    WrongProviderUuid,
    NotAuthenticated,
    BodySizeExceedsLimit,
    PsaErrorGenericError,
    PsaErrorNotSupported,
    PsaErrorNotPermitted,
    PsaErrorBufferTooSmall,
    PsaErrorAlreadyExists,
    PsaErrorDoesNotExist,
    PsaErrorBadState,
    PsaErrorInvalidArgument,
    PsaErrorInsufficientMemory,
    PsaErrorInsufficientStorage,
    PsaErrorCommunicationFailure,
    PsaErrorStorageFailure,
    PsaErrorDataCorrupt,
    PsaErrorDataInvalid,
    PsaErrorHardwareFailure,
    PsaErrorCorruptionDetected,
    PsaErrorInsufficientEntropy,
    PsaErrorInvalidSignature,
    PsaErrorInvalidPadding,
    PsaErrorInsufficientData,
    PsaErrorInvalidHandle,
}

C-like enum mapping response status options to their code.

See the status code page for a broader description of these codes.

Variants

Success

Successful operation

WrongProviderID

Requested provider ID does not match that of the backend

ContentTypeNotSupported

Requested content type is not supported by the backend

AcceptTypeNotSupported

Requested accept type is not supported by the backend

WireProtocolVersionNotSupported

Requested version is not supported by the backend

ProviderNotRegistered

No provider registered for the requested provider ID

ProviderDoesNotExist

No provider defined for requested provider ID

DeserializingBodyFailed

Failed to deserialize the body of the message

SerializingBodyFailed

Failed to serialize the body of the message

OpcodeDoesNotExist

Requested operation is not defined

ResponseTooLarge

Response size exceeds allowed limits

AuthenticationError

Authentication failed

AuthenticatorDoesNotExist

Authenticator not supported

AuthenticatorNotRegistered

Authenticator not supported

KeyInfoManagerError

Internal error in the Key Info Manager

ConnectionError

Generic input/output error

InvalidEncoding

Invalid value for this data type

InvalidHeader

Constant fields in header are invalid

WrongProviderUuid

The UUID vector needs to only contain 16 bytes

NotAuthenticated

Request did not provide a required authentication

BodySizeExceedsLimit

Request length specified in the header is above defined limit

PsaErrorGenericError

An error occurred that does not correspond to any defined failure cause

PsaErrorNotSupported

The requested operation or a parameter is not supported by this implementation

PsaErrorNotPermitted

The requested action is denied by a policy

PsaErrorBufferTooSmall

An output buffer is too small

PsaErrorAlreadyExists

Asking for an item that already exists

PsaErrorDoesNotExist

Asking for an item that doesn't exist

PsaErrorBadState

The requested action cannot be performed in the current state

PsaErrorInvalidArgument

The parameters passed to the function are invalid

PsaErrorInsufficientMemory

There is not enough runtime memory

PsaErrorInsufficientStorage

There is not enough persistent storage

PsaErrorCommunicationFailure

There was a communication failure inside the implementation

PsaErrorStorageFailure

There was a storage failure that may have led to data loss

PsaErrorDataCorrupt

Stored data has been corrupted

PsaErrorDataInvalid

Data read from storage is not valid for the implementation

PsaErrorHardwareFailure

A hardware failure was detected

PsaErrorCorruptionDetected

A tampering attempt was detected

PsaErrorInsufficientEntropy

There is not enough entropy to generate random data needed for the requested action

PsaErrorInvalidSignature

The signature, MAC or hash is incorrect

PsaErrorInvalidPadding

The decrypted padding is incorrect

PsaErrorInsufficientData

Insufficient data when attempting to read from a resource

PsaErrorInvalidHandle

The key handle is not valid

Trait Implementations

impl Clone for ResponseStatus

fn clone(&self) -> ResponseStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for ResponseStatus

impl Debug for ResponseStatus

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

Formats the value using the given formatter.

impl Display for ResponseStatus

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

Formats the value using the given formatter.

impl Error for ResponseStatus

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

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

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

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() { // Print e itself, no need for description(). eprintln!("Error: {}", e); }

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl From<Box<ErrorKind>> for ResponseStatus

fn from(err: Error) -> Self

Performs the conversion.

impl From<Error> for ResponseStatus

Conversion from a std::io::Error to a ResponseStatus

It allows to easily return a ResponseStatus in case of error when using functions from the standard library.

fn from(err: Error) -> Self

Performs the conversion.

impl From<Error> for ResponseStatus

fn from(err: Error) -> ResponseStatus

Performs the conversion.

impl From<Infallible> for ResponseStatus

fn from(_err: Infallible) -> Self

Performs the conversion.

impl From<TryFromIntError> for ResponseStatus

fn from(err: TryFromIntError) -> Self

Performs the conversion.

impl FromPrimitive for ResponseStatus

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl PartialEq<ResponseStatus> for ResponseStatus

fn eq(&self, other: &ResponseStatus) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralPartialEq for ResponseStatus

impl TryFrom<u16> for ResponseStatus

type Error = ResponseStatus

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self>

Performs the conversion.