Enum ark_module::behavior::ErrorCode

#[non_exhaustive]
#[repr(u32)]
pub enum ErrorCode {
    Success,
    ApiNotAvailable,
    InternalError,
    InvalidArguments,
    NotFound,
    Unavailable,
    HttpRequestFailed,
}

Error return codes for API functions.

Note that there is an ErrorCode::Success, so the presence of ErrorCode does NOT signify an error.

Do NOT use this type in the public interface of ark-api. Use idiomatic Rust error enum or ark_api::Error instead

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Success

Success - there was no error and the operation completed successfully

ApiNotAvailable

API not available.

Typically happens if a module calls an API it has not specified that it requires

InternalError

Internal error - something went wrong on in the Ark host.

Such an error will cause a trap on the host, causing an unload of the module triggering it.

InvalidArguments

Invalid arguments - the inputs to the called API function were not valid

NotFound

Resource not found - used by APIs to indicate a requested resource can’t be found

Unavailable

The API or resource is currently not available

HttpRequestFailed

HTTP request failed due to external server error - something went wrong when communicating with the remote server

This can happen when sending a HTTP request to a server that is unavailable, if DNS lookup fails, or other server related issues.

Trait Implementations

impl Clone for ErrorCode

fn clone(&self) -> ErrorCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorCode

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

Formats the value using the given formatter.

impl Hash for ErrorCode

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ErrorCode> for ErrorCode

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ErrorCode

impl Eq for ErrorCode

impl StructuralEq for ErrorCode

impl StructuralPartialEq for ErrorCode