Enum xi_rpc::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 of Custom

code: i64message: Stringdata: 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.

Methods

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 PartialEq<RemoteError> for RemoteError

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

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

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

This method tests for !=.

impl From<Error> for RemoteError

fn from(err: JsonError) -> RemoteError

Performs the conversion.

impl From<RemoteError> for Error

fn from(err: RemoteError) -> Error

Performs the conversion.

impl Clone for RemoteError

fn clone(&self) -> RemoteError

Returns a copy 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 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<'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.