Skip to main content

Protocol

rings_node::extension::ext

Trait Protocol 

Source 
pub trait Protocol {
    type State;
    type Event: MaybeSend;
    type Effect;

    // Required methods
    fn namespace(&self) -> &str;
    fn init(&self) -> Self::State;
    fn decode(&self, wire: Wire<'_>) -> Result<Self::Event, Reject>;
    fn step(
        &self,
        ctx: Ctx<'_, Self::State>,
        event: Self::Event,
    ) -> Transition<Self::State, Self::Effect>;

    // Provided method
    fn capabilities(&self) -> &'static [&'static str] { ... }
}
Expand description

A protocol: a namespace, an initial state, a decode boundary, and a state transition that is pure by contract.

  init   :              → S
  decode : Wire        ⇀ Event            (partial: may Reject)
  step   : (Ctx S, Event) → Transition (S, Effect)

decode is the single place raw bytes become a typed Event; a malformed/foreign message is an explicit Reject, not a silent no-op in step. step is then total over well-typed events and pure: no IO, no clocks, no globals. All side effects are described as values of the protocol’s own Effect type and performed by the extension’s Interpret shell.

Required Associated Types§

Source

type State

Protocol-private state, owned by the runtime and threaded through step.

Source

type Event: MaybeSend

The protocol’s typed input, produced by decode.

Source

type Effect

The protocol’s own effect algebra (the core defines no global effect enum).

Required Methods§

Source

fn namespace(&self) -> &str

The namespace this protocol is registered and routed under.

Source

fn init(&self) -> Self::State

Initial state. init : 1 → S.

Source

fn decode(&self, wire: Wire<'_>) -> Result<Self::Event, Reject>

Decode the boundary into a typed event, or Reject it. decode : Wire ⇀ Event.

Source

fn step( &self, ctx: Ctx<'_, Self::State>, event: Self::Event, ) -> Transition<Self::State, Self::Effect>

Pure transition. step : (Ctx S, Event) → Transition (S, Effect).

Provided Methods§

Source

fn capabilities(&self) -> &'static [&'static str]

Optional online-node capability labels advertised when this protocol is registered.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§