Enum System 

pub enum System<Status, State> {
    Batch(Batch<Status, State>),
    DispatchBatch(DispatchBatch<Status, State>),
    Routed(Routed<Status, State>),
    FirstMatch(FirstMatch<Status, State>),
}

A system is a collection of actions that can be invoked as services.

Variants

Batch(Batch<Status, State>)

An unordered system that invokes all actions.

DispatchBatch(DispatchBatch<Status, State>)

A system that routes frames to actions fully matching patterns.

Routed(Routed<Status, State>)

A system that routes frames to matching patterns.

FirstMatch(FirstMatch<Status, State>)

A system that invokes the first action that matches a frame.

Implementations

impl<State> System<Open, State>

where State: Clone + Send + Sync + 'static,

pub fn batch() -> Self

Create a new batch system. Batch systems invoke all actions with a frame, returning a Frame that contains a list of frames.

pub fn dispatch_batch() -> Self

Create a new dispatched system that aggregates responses from all matching actions into a list. Dispatch systems match actions exactly using a full path.

pub fn routed() -> Self

Create a new routed system which aggregates responses from all matching actions. Routed systems match actions using a composed path fragment.

pub fn first_match() -> Self

Create a new first match system.

pub fn with_state(&self, state: State) -> System<Stateful<State>, State>

Transition to a stateful system with a given state.

impl System<Open, ()>

pub fn without_state(self) -> StatelessSystem

If we know that the state is empty, we know that we can transition to a stateless system. Transition to a stateless system.

pub fn handle_frame(self, frame: Frame) -> FrameFuture

Call the system with a frame.

impl<State> System<Stateful<State>, State>

where State: Clone + Send + Sync + 'static,

pub async fn handle_frame(self, frame: Frame) -> Result<Frame>

Call the system with a frame.

impl System<Stateless, ()>

pub fn handle_frame(self, frame: Frame) -> FrameFuture

Call the system with a frame.

impl<Status, State> System<Status, State>

where State: Clone + Send + Sync + 'static,

pub fn on_frame<ActionHandler, Args>(self, action: ActionHandler) -> Self

where ActionHandler: Handler<Args, State> + Clone + Send + Sync + 'static, Args: Clone + Send + Sync + 'static,

Add a frame handler to the system. This is a no-op for systems that do not support wildcard routing or only support specific patterns.

pub fn on<ActionHandler, Args>( self, pattern: impl AsRef<str>, action: ActionHandler, ) -> Self

where ActionHandler: Handler<Args, State> + Clone + Send + Sync + 'static, Args: Clone + Send + Sync + 'static,

Add a uri bound or path bound handler to the system.

• Dispatch systems will match the pattern exactly.
• Routed systems will match the pattern as a path fragment.

pub fn routes(&self) -> Option<Vec<String>>

Get the routes for this system, if any.

pub fn action_context(&self) -> ActionContext<State>

Get the action context for this system.

Trait Implementations

impl<Status: Clone, State: Clone> Clone for System<Status, State>

fn clone(&self) -> System<Status, State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State> Handler<Frame, State> for System<Open, State>

where State: Clone + Send + Sync + 'static,

type Future = FrameFuture

Action futures must resolve into an Frame of some kind.

fn invoke(&self, frame: impl Into<Frame>, state: State) -> Self::Future

Invoke the action with a given frame and state, returning the frameual frame that will be produced by the action.

fn context(&self) -> ActionContext<State>

Poll for the action context. This is normally a service, but in some cases, it may be a frame handler or a router.

fn as_into_actionable(&self) -> BoxedAction<State>

where Self: Clone + Send + Sync + 'static, Args: Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static,

Convert this action into a type erased actionable service.

fn into_stream( self, state: State, ) -> (impl Stream<Item = Result<Frame>>, FrameOutbox)

where Self: Clone + Send + Sync + 'static, Args: Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static,

Use into_stream to turn the action into a stream and a stream handle. See [Actionable::into_stream] for more information.

fn ready(self, state: State) -> ReadyAction<Self, Args, State>

where Self: Clone + Send + 'static, Args: Clone + Send + 'static, State: Clone + Send + 'static,

Use with_state to turn the action into a stateful action, which can be used as a tower::Service.

fn candidate(self) -> CandidateAction<Self, Args, State>

where Self: Clone + Send + 'static, Args: Clone + Send + 'static, State: Clone + Send + 'static,

Create a Candidate actionable from the action, with the given state. Candidates can be “suspended” by boxing them for later.

fn active(self, state: State) -> ActiveAction

where Self: Clone + Send + Sync + 'static, Args: Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static,

Create an Active actionable from the action, with the given state.

impl<IntoFrame> Service<IntoFrame> for System<Open, ()>

where IntoFrame: Into<Frame> + Clone + Send + 'static,

type Response = Frame

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = FrameFuture

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, frame: IntoFrame) -> Self::Future

Process the request and return the response asynchronously.