Struct Response 

pub struct Response<T = Value, E = Value> {
    pub result: Result<T, Error<E>>,
    pub id: Id,
}

A JSON-RPC 2.0 response object.

Note that the "jsonrpc": "2.0" member is transparently checked during deserialization, and added during serialization.

Fields

result: Result<T, Error<E>>

“result”:

This member is REQUIRED on success. This member MUST NOT exist if there was an error invoking the method. The value of this member is determined by the method invoked on the Server.

“error”:

This member is REQUIRED on error. This member MUST NOT exist if there was no error triggered during invocation.

id: Id

This member is REQUIRED. It MUST be the same as the value of the id member in the Request Object. If there was an error in detecting the id in the Request object (e.g. Parse error/Invalid Request), it MUST be Null.

Trait Implementations

impl<T, E> Clone for Response<T, E>

where T: Clone, E: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, E> Debug for Response<T, E>

where T: Debug, E: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Response<T>

where T: Default,

fn default() -> Response<T>

Returns the “default value” for a type.

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

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

fn deserialize<D>( deserializer: D, ) -> Result<Response<T, E>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E> PartialEq for Response<T, E>

where T: PartialEq, E: PartialEq,

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

where T: Serialize, E: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, E> Eq for Response<T, E>

where T: Eq, E: Eq,

impl<T, E> StructuralPartialEq for Response<T, E>