Struct Output

pub struct Output<T = Value> {
    pub result: Option<T>,
    pub error: Option<Error>,
    pub id: Option<Id>,
}

Represents success / failure output of JSON-RPC 1.0 response.

Fields

result: Option<T>

Successful execution result.

error: Option<Error>

Failed execution error.

id: Option<Id>

Correlation id.

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.

Implementations

impl<T: Serialize + DeserializeOwned> Output<T>

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

Creates a JSON-RPC 1.0 success response output.

pub fn failure(error: Error, id: Option<Id>) -> Self

Creates a JSON-RPC 1.0 failure response output.

pub fn invalid_request(id: Option<Id>) -> Self

Creates a new failure response output indicating malformed request.

Trait Implementations

impl<T: Clone> Clone for Output<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Output<T>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Output<T>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Serialize> Display for Output<T>

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

Formats the value using the given formatter.

impl<T: Serialize + DeserializeOwned> From<Output<T>> for Result<T, Error>

fn from(output: Output<T>) -> Result<T, Error>

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Output<T>

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

impl<T> StructuralPartialEq for Output<T>