Struct ErrorObject

pub struct ErrorObject {
    pub code: ErrorCode,
    pub message: Cow<'static, str>,
    pub data: Option<Value>,
}

The error object.

This is the object sent back in a Response if the method call errored.

Display

use cuprate_json_rpc::error::ErrorObject;

// The format is `$CODE: $MESSAGE`.
// If a message was not passed during construction,
// the error code's message will be used.
assert_eq!(format!("{}", ErrorObject::parse_error()),      "-32700: Parse error");
assert_eq!(format!("{}", ErrorObject::invalid_request()),  "-32600: Invalid Request");
assert_eq!(format!("{}", ErrorObject::method_not_found()), "-32601: Method not found");
assert_eq!(format!("{}", ErrorObject::invalid_params()),   "-32602: Invalid params");
assert_eq!(format!("{}", ErrorObject::internal_error()),   "-32603: Internal error");
assert_eq!(format!("{}", ErrorObject::server_error(0)),    "0: Server error");

// Set a custom message.
let mut e = ErrorObject::server_error(1);
e.message = "hello".into();
assert_eq!(format!("{e}"), "1: hello");

Fields

code: ErrorCode

The error code.

message: Cow<'static, str>

A custom message for this error, distinct from ErrorCode::msg.

A JSON string value.

This is a Cow<'static, str> to support both 0-allocation for const string ID’s commonly found in programs, as well as support for runtime String’s.

data: Option<Value>

Optional data associated with the error.

None vs Some(Value::Null)

This field will be completely omitted during serialization if None, however if it is Some(Value::Null), it will be serialized as "data": null.

Implementations

impl ErrorObject

pub const fn from_code(code: ErrorCode) -> Self

Creates a new error, deriving the message from the code.

Same as ErrorObject::from(ErrorCode).

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

for code in [
    ErrorCode::ParseError,
    ErrorCode::InvalidRequest,
    ErrorCode::MethodNotFound,
    ErrorCode::InvalidParams,
    ErrorCode::InternalError,
    ErrorCode::ServerError(0),
] {
    let object = ErrorObject::from_code(code);
    assert_eq!(object, ErrorObject {
        code,
        message: Cow::Borrowed(code.msg()),
        data: None,
    });

}

pub const fn parse_error() -> Self

Creates a new error using PARSE_ERROR.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::ParseError;
let object = ErrorObject::parse_error();
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

pub const fn invalid_request() -> Self

Creates a new error using INVALID_REQUEST.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::InvalidRequest;
let object = ErrorObject::invalid_request();
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

pub const fn method_not_found() -> Self

Creates a new error using METHOD_NOT_FOUND.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::MethodNotFound;
let object = ErrorObject::method_not_found();
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

pub const fn invalid_params() -> Self

Creates a new error using INVALID_PARAMS.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::InvalidParams;
let object = ErrorObject::invalid_params();
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

pub const fn internal_error() -> Self

Creates a new error using INTERNAL_ERROR.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::InternalError;
let object = ErrorObject::internal_error();
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

pub const fn server_error(error_code: i32) -> Self

Creates a new error using SERVER_ERROR.

You must provide the custom i32 error code.

use std::borrow::Cow;
use cuprate_json_rpc::error::{ErrorCode, ErrorObject};

let code = ErrorCode::ServerError(0);
let object = ErrorObject::server_error(0);
assert_eq!(object, ErrorObject {
    code,
    message: Cow::Borrowed(code.msg()),
    data: None,
});

Trait Implementations

impl Clone for ErrorObject

fn clone(&self) -> ErrorObject

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorObject

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorObject

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ErrorObject

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

Formats the value using the given formatter.

impl Error for ErrorObject

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<ErrorCode> for ErrorObject

fn from(code: ErrorCode) -> Self

Converts to this type from the input type.

impl PartialEq for ErrorObject

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ErrorObject

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ErrorObject

impl StructuralPartialEq for ErrorObject

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 64 bytes