Struct Action 

pub struct Action<ActionState: Clone> { /* private fields */ }

The Action struct wraps an action state that describes the progression of a handler from a function-like thing into a full-blown frame service.

Implementations

impl Action<Active>

pub fn active(service: ActionService) -> Self

Create an active actionable from a given action service.

pub fn into_inner(self) -> ActionService

Get a reference to the inner action service.

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

Handle a frame using an active actionable.

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

Turn the active actionable into a stream that emits frames returned by the interior service.

Take an active actionable into a stream and a stream handle. The stream handle can be used in one part of an application to send frames to the actionable wherever it is being used, and the stream will yield any frames returned from the actionable. This is useful for creating background tasks out of either the handle or the stream itself, for example to create a frame emitter out of an external event source.

In order for the stream to be consumed, it needs to be pinned first. This can be done by calling tokio::pin! on the stream before consuming it.

Example

use futures::StreamExt;
use intrepid::{Action, Frame, IntoFrame, Service};

#[tokio::main]
async fn main() {
    let action = |name: String| async move { format!("Hello, {}!", name).into_frame() };

    let actionable = action.as_into_actionable().into_actionable(());

    let (mut stream, mut handle) = actionable.into_stream();

    tokio::spawn(async move {
        handle.send("Alice".to_string()).await.unwrap();
        handle.send("Bob".to_string()).await.unwrap();
    });

    tokio::pin!(stream);

    while let Some(frame) = stream.next().await {
        println!("{:?}", frame);
    }
}

impl<ActionHandler, Args, State> Action<Candidate<ActionHandler, Args, State>>

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

pub fn new(action: ActionHandler) -> Self

Create an Actionable [Candidate] from a given ActionHandler.

pub fn with_state( self, state: State, ) -> Action<Ready<ActionHandler, Args, State>>

Create a new Actionable Ready from an action and a state.

impl<ActionHandler, Args> Action<Candidate<ActionHandler, Args, ()>>

where ActionHandler: Handler<Args, ()> + Clone + Send + 'static, Args: Clone + Send + 'static,

pub fn stateless(self) -> Action<Stateless<ActionHandler, Args>>

Create a new Actionable Stateless from an action, with no state.

Trait Implementations

impl<ActionState: Clone + Clone> Clone for Action<ActionState>

fn clone(&self) -> Action<ActionState>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<ActionHandler, Args> From<Stateless<ActionHandler, Args>> for Action<Stateless<ActionHandler, Args>>

where ActionHandler: Handler<Args, ()> + Clone + Send + 'static, Args: Clone + Send + 'static,

fn from(status: Stateless<ActionHandler, Args>) -> Self

Converts to this type from the input type.

impl<ActionHandler, Args, IntoFrame> Service<IntoFrame> for Action<Stateless<ActionHandler, Args>>

where IntoFrame: Into<Frame>, ActionHandler: Handler<Args, ()> + Clone + 'static, ActionHandler::Future: 'static, Args: Clone,

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.