Struct ReducerCallInfo 

pub struct ReducerCallInfo<F>
where
    F: WebsocketFormat,
{
    pub reducer_name: Box<str>,
    pub reducer_id: u32,
    pub args: <F as WebsocketFormat>::Single,
    pub request_id: u32,
}

Contained in a TransactionUpdate, metadata about a reducer invocation.

Fields

reducer_name: Box<str>

The name of the reducer that was called.

NOTE(centril, 1.0): For bandwidth resource constrained clients this can encourage them to have poor naming of reducers like a. We should consider not sending this at all and instead having a startup message where the name <-> id bindings are established between the host and the client.

reducer_id: u32

The numerical id of the reducer that was called.

args: <F as WebsocketFormat>::Single

The arguments to the reducer, encoded as BSATN or JSON according to the reducer’s argument schema and the client’s requested protocol.

request_id: u32

An identifier for a client request

Trait Implementations

impl<F> Debug for ReducerCallInfo<F>

where F: Debug + WebsocketFormat, <F as WebsocketFormat>::Single: Debug,

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for ReducerCallInfo<F>

where F: WebsocketFormat + Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<ReducerCallInfo<F>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given deserializer.

impl<F> Serialize for ReducerCallInfo<F>

where F: WebsocketFormat + Serialize,

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

where S: Serializer,

Serialize self in the data format of S using the provided serializer.

impl<F> SpacetimeType for ReducerCallInfo<F>

where F: WebsocketFormat + SpacetimeType + 'static,

fn make_type<S>(__typespace: &mut S) -> AlgebraicType

where S: TypespaceBuilder,

Returns an AlgebraicType representing the type for Self in SATS and in the typing context in typespace. This is used by the automatic type registration system in Rust modules.