Enum Frame 

pub enum Frame {
    Unit,
    Error(Bytes),
    Anonymous(Bytes),
    Message(MessageFrame),
}

A frame that can be processed by an action.

Variants

Unit

A unit frame, with nothing in it.

Error(Bytes)

An error frame.

Anonymous(Bytes)

An unaddressed chunk of bytes.

Message(MessageFrame)

An addressed frame.

Implementations

impl Frame

pub fn new(bytes: impl Into<Bytes>) -> Self

Create a new frame from a given set of bytes.

pub fn message( uri: impl AsRef<str>, data: impl Into<Frame>, meta: impl Into<Frame>, ) -> Self

Create a message frame.

pub fn len(&self) -> usize

The length of the frame in bytes.

pub fn is_empty(&self) -> bool

Check if the frame is empty.

pub fn as_bytes(&self) -> &[u8]

Get a reference to the frame as a slice of bytes.

pub fn into_bytes(self) -> Bytes

Convert the frame’s body into a vector of bytes.

Trait Implementations

impl AsRef<[u8]> for Frame

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Frame

fn clone(&self) -> Frame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Frame

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

Formats the value using the given formatter.

impl Default for Frame

fn default() -> Frame

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Frame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<State> Extractor<State> for Frame

type Error = Infallible

The error type for this extractor. Anything that can be converted into an extractor error can be used as an error type.

fn extract( frame: Frame, _: &Context<State>, ) -> Result<Self, <Frame as Extractor<State>>::Error>

Take an frame and a state and return a result containing the extracted value or the frame.

fn extract_from_frame_and_state( frame: Frame, context: &Context<State>, ) -> Result<Self>

where Self: Sized, Self::Error: Into<ExtractorError>,

Extract a value from a frame and state, returning a result containing the extracted value or an error coerced into a crate::Error.

impl From<()> for Frame

fn from(_: ()) -> Self

Converts to this type from the input type.

impl From<Box<dyn Error + Sync + Send>> for Frame

fn from(error: BoxError) -> Self

Converts to this type from the input type.

impl From<Bytes> for Frame

fn from(bytes: Bytes) -> Self

Converts to this type from the input type.

impl From<Error> for Frame

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Frame> for Bytes

fn from(frame: Frame) -> Bytes

Converts to this type from the input type.

impl From<Frame> for HttpFrameResponse

fn from(frame: Frame) -> Self

Converts to this type from the input type.

impl From<Frame> for String

fn from(value: Frame) -> Self

Converts to this type from the input type.

impl From<HttpFrameResponse> for Frame

fn from(frame: HttpFrameResponse) -> Self

Converts to this type from the input type.

impl<T> From<Option<T>> for Frame

where T: Into<Frame>,

fn from(option: Option<T>) -> Self

Converts to this type from the input type.

impl<T, E> From<Result<T, E>> for Frame

where T: Into<Frame>, E: Into<Frame>,

fn from(result: Result<T, E>) -> Self

Converts to this type from the input type.

impl From<String> for Frame

fn from(value: String) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Frame

where T: Into<Frame>,

fn from(value: Vec<T>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Frame

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl Handler<Frame, ()> for StatelessSystem

type Future = FrameFuture

Action futures must resolve into an Frame of some kind.

fn invoke(&self, frame: impl Into<Frame>, _: ()) -> 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<()>

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<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<State> Handler<Frame, State> for StatefulSystem<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 PartialEq for Frame

fn eq(&self, other: &Frame) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Frame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Frame