Enum RemoteError 

pub enum RemoteError {
    InvalidRequest(Option<Value>),
    Custom {
        code: i64,
        message: String,
        data: Option<Value>,
    },
    Unknown(Value),
}

Errors that can be received from the other side of the RPC channel.

This type is intended to go over the wire. And by convention should Serialize as a JSON object with “code”, “message”, and optionally “data” fields.

The xi RPC protocol defines one error: RemoteError::InvalidRequest, represented by error code -32600; however codes in the range -32700 ... -32000 (inclusive) are reserved for compatability with the JSON-RPC spec.

Examples

An invalid request:

use xi_rpc::RemoteError;
use serde_json::Value;

let json = r#"{
    "code": -32600,
    "message": "Invalid request",
    "data": "Additional details"
    }"#;

let err = serde_json::from_str::<RemoteError>(&json).unwrap();
assert_eq!(err,
           RemoteError::InvalidRequest(
               Some(Value::String("Additional details".into()))));

A custom error:

use xi_rpc::RemoteError;
use serde_json::Value;

let json = r#"{
    "code": 404,
    "message": "Not Found"
    }"#;

let err = serde_json::from_str::<RemoteError>(&json).unwrap();
assert_eq!(err, RemoteError::custom(404, "Not Found", None));

Variants

InvalidRequest(Option<Value>)

The JSON was valid, but was not a correctly formed request.

This Error is used internally, and should not be returned by clients.

Custom

A custom error, defined by the client.

Fields

code: i64

message: String

data: Option<Value>

Unknown(Value)

An error that cannot be represented by an error object.

This error is intended to accommodate clients that return arbitrary error values. It should not be used for new errors.

Implementations

impl RemoteError

pub fn custom<S, V>(code: i64, message: S, data: V) -> Self

where S: AsRef<str>, V: Into<Option<Value>>,

Creates a new custom error.

Trait Implementations

impl Clone for RemoteError

fn clone(&self) -> RemoteError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RemoteError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RemoteError

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Error> for RemoteError

fn from(err: JsonError) -> RemoteError

Converts to this type from the input type.

impl From<RemoteError> for Error

fn from(err: RemoteError) -> Error

Converts to this type from the input type.

impl PartialEq for RemoteError

fn eq(&self, other: &RemoteError) -> 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 RemoteError

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RemoteError