Struct jsonrpsee_types::params::ParamsSequence

pub struct ParamsSequence<'a>(_);

An Iterator-like parser for a sequence of Params.

This will parse the params one at a time, and allows for graceful handling of optional parameters at the tail; other use cases are likely better served by Params::parse. The reason this is not an actual Iterator is that params parsing (often) yields values of different types.

Regards empty array [] as no parameters provided.

Implementations

impl<'a> ParamsSequence<'a>

pub fn next<T>(&mut self) -> Result<T, CallError>where T: Deserialize<'a>,

Parse the next parameter to type T

let params = Params::new(Some(r#"[true, 10, "foo"]"#));
let mut seq = params.sequence();

let a: bool = seq.next().unwrap();
let b: i32 = seq.next().unwrap();
let c: &str = seq.next().unwrap();

assert_eq!(a, true);
assert_eq!(b, 10);
assert_eq!(c, "foo");

pub fn optional_next<T>(&mut self) -> Result<Option<T>, CallError>where T: Deserialize<'a>,

Parse the next optional parameter to type Option<T>.

The result will be None for null, and for missing values in the supplied JSON array.

let params = Params::new(Some(r#"[1, 2, null]"#));
let mut seq = params.sequence();

let params: [Option<u32>; 4] = [
    seq.optional_next().unwrap(),
    seq.optional_next().unwrap(),
    seq.optional_next().unwrap(),
    seq.optional_next().unwrap(),
];

assert_eq!(params, [Some(1), Some(2), None, None]);

Trait Implementations

impl<'a> Clone for ParamsSequence<'a>

fn clone(&self) -> ParamsSequence<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ParamsSequence<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for ParamsSequence<'a>