Struct Methods 

pub struct Methods { /* private fields */ }

Available on crate feature server-core only.

Reference-counted, clone-on-write collection of synchronous and asynchronous methods.

Implementations

impl Methods

pub fn new() -> Methods

Creates a new empty Methods.

pub fn verify_method_name( &mut self, name: &'static str, ) -> Result<(), RegisterMethodError>

Verifies that the method name is not already taken, and returns an error if it is.

pub fn verify_and_insert( &mut self, name: &'static str, callback: MethodCallback, ) -> Result<&mut MethodCallback, RegisterMethodError>

Inserts the method callback for a given name, or returns an error if the name was already taken. On success it returns a mut reference to the MethodCallback just inserted.

pub fn merge( &mut self, other: impl Into<Methods>, ) -> Result<(), RegisterMethodError>

Merge two Methods’s by adding all MethodCallbacks from other into self. Fails if any of the methods in other is present already.

pub fn method(&self, method_name: &str) -> Option<&MethodCallback>

Returns the method callback.

pub async fn raw_json_request( &self, request: &str, buf_size: usize, ) -> Result<(String, Receiver<String>), Error>

Make a request (JSON-RPC method call or subscription) by using raw JSON.

Returns the raw JSON response to the call and a stream to receive notifications if the call was a subscription.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::{RpcModule, SubscriptionMessage};
    use jsonrpsee::types::{response::Success, Response};
    use jsonrpsee::core::to_json_raw_value;
    use futures_util::StreamExt;

    let mut module = RpcModule::new(());
    module.register_subscription("hi", "hi", "goodbye", |_, pending, _| async {
        let sink = pending.accept().await?;

        // see comment above.
        let msg = to_json_raw_value(&"one answer").unwrap();
        sink.send(msg).await?;

        Ok(())
    }).unwrap();
    let (resp, mut stream) = module.raw_json_request(r#"{"jsonrpc":"2.0","method":"hi","id":0}"#, 1).await.unwrap();
    // If the response is an error converting it to `Success` will fail.
    let resp: Success<u64> = serde_json::from_str::<Response<u64>>(&resp).unwrap().try_into().unwrap();
    let sub_resp = stream.recv().await.unwrap();
    assert_eq!(
        format!(r#"{{"jsonrpc":"2.0","method":"hi","params":{{"subscription":{},"result":"one answer"}}}}"#, resp.result),
        sub_resp
    );
}

pub fn method_names(&self) -> impl Iterator<Item = &'static str>

Returns an Iterator with all the method names registered on this server.

Trait Implementations

impl Clone for Methods

fn clone(&self) -> Methods

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Methods

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

Formats the value using the given formatter.

impl Default for Methods

fn default() -> Methods

Returns the “default value” for a type.

impl<Context> From<RpcModule<Context>> for Methods

fn from(module: RpcModule<Context>) -> Methods

Converts to this type from the input type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes