Enum sc_rpc_spec_v2::chain_head::api::ListOrValue

pub enum ListOrValue<T> {
    List(Vec<T>),
    Value(T),
}

RPC list or value wrapper.

For some RPCs it’s convenient to call them with either a single value or a whole list of values to get a proper response. In theory you could do a batch query, but it’s:

1. Less convenient in client libraries
2. If the response value is small, the protocol overhead might be dominant.

Also it’s nice to be able to maintain backward compatibility for methods that were initially taking a value and now we want to expand them to take a list.

Variants

List(Vec<T>)

A list of values of given type.

Value(T)

A single value of given type.

Implementations

impl<T> ListOrValue<T>

pub fn map<F, X>(self, f: F) -> ListOrValue<X>

where F: Fn(T) -> X,

Map every contained value using function F.

This allows to easily convert all values in any of the variants.

Trait Implementations

impl<T> Clone for ListOrValue<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ListOrValue<T>

where T: Debug,

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

Formats the value using the given formatter.

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

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ListOrValue<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for ListOrValue<T>

fn from(n: T) -> ListOrValue<T>

Converts to this type from the input type.

impl<T> From<Vec<T>> for ListOrValue<T>

fn from(n: Vec<T>) -> ListOrValue<T>

Converts to this type from the input type.

impl<T> PartialEq for ListOrValue<T>

where T: PartialEq,

fn eq(&self, other: &ListOrValue<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ListOrValue<T>

where T: 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> StructuralPartialEq for ListOrValue<T>