Struct cuprate_json_rpc::Response

pub struct Response<T> {
    pub jsonrpc: Version,
    pub id: Id,
    pub payload: Result<T, ErrorObject>,
}

The response object.

The generic T is the response payload, i.e. it is the type that holds both the method and params.

Fields

jsonrpc: Version

JSON-RPC protocol version; always 2.0.

id: Id

This field must always be present in serialized JSON.

JSON-RPC 2.0 rules

• The Response’s ID must be the same as the Request
• If the Request omitted the id field, there should be no Response
• If there was an error in detecting the Request’s ID, the Response must contain an Id::Null

payload: Result<T, ErrorObject>

The response payload.

JSON-RPC 2.0 rules

• This must be Ok upon success
• This must be Err upon error
• This can be any (de)serializable data T on success
• This must be ErrorObject on errors

Implementations

impl<T> Response<T>

pub const fn ok(id: Id, result: T) -> Self

Creates a successful response.

use cuprate_json_rpc::{Id, Response};

let ok = Response::ok(Id::Num(123), "OK");
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":123,"result":"OK"}"#);

pub const fn err(id: Id, error: ErrorObject) -> Self

Creates an error response.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let err = ErrorObject {
    code: 0.into(),
    message: "m".into(),
    data: Some("d".into()),
};

let ok = Response::<()>::err(Id::Num(123), err);
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":123,"error":{"code":0,"message":"m","data":"d"}}"#);

pub const fn parse_error(id: Id) -> Self

Creates an error response using ErrorObject::parse_error.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let ok = Response::<()>::parse_error(Id::Num(0));
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":0,"error":{"code":-32700,"message":"Parse error"}}"#);

pub const fn invalid_request(id: Id) -> Self

Creates an error response using ErrorObject::invalid_request.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let ok = Response::<()>::invalid_request(Id::Num(0));
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":0,"error":{"code":-32600,"message":"Invalid Request"}}"#);

pub const fn method_not_found(id: Id) -> Self

Creates an error response using ErrorObject::method_not_found.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let ok = Response::<()>::method_not_found(Id::Num(0));
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":0,"error":{"code":-32601,"message":"Method not found"}}"#);

pub const fn invalid_params(id: Id) -> Self

Creates an error response using ErrorObject::invalid_params.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let ok = Response::<()>::invalid_params(Id::Num(0));
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":0,"error":{"code":-32602,"message":"Invalid params"}}"#);

pub const fn internal_error(id: Id) -> Self

Creates an error response using ErrorObject::internal_error.

use cuprate_json_rpc::{Id, Response, error::{ErrorObject, ErrorCode}};

let ok = Response::<()>::internal_error(Id::Num(0));
let json = serde_json::to_string(&ok).unwrap();
assert_eq!(json, r#"{"jsonrpc":"2.0","id":0,"error":{"code":-32603,"message":"Internal error"}}"#);

Trait Implementations

impl<T: Clone> Clone for Response<T>

fn clone(&self) -> Response<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Response<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Response<T>

where T: Deserialize<'de> + 'de,

fn deserialize<D: Deserializer<'de>>(der: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T> Display for Response<T>

where T: Serialize,

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Response<T>

fn eq(&self, other: &Response<T>) -> 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<T> Serialize for Response<T>

where T: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Response<T>

impl<T> StructuralPartialEq for Response<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.