Struct Path 

pub struct Path<T>(pub T)
where
    T: DeserializeOwned;

A path extractor that captures a given type from a frame. This is used to extract path captures from a message frame’s URI, turning them into local types. It obeys a few rules:

• It must be used with a list-friendly type, such as Path<(String,)>. This is because, under the hood, it grabs a list of all path captures and then deserializes them into the given types. That means it’s always expecting some kind of list type. If all the types are uniform, you can use a Vec or an array.
• If it’s a tuple, the number of types must match the number of captures in the path. If it’s a list, the number of types must be equal to or less than the number of captures in the path.
• The given type must be deserializable from the captures. This means that the type must implement DeserializeOwned or ‘Deserialize’.

If any of these rules are broken, the extractor will fail to extract with a runtime rejection.

Example

use intrepid::{Path, Frame, System, Action};

#[tokio::main]
async fn main() -> intrepid::Result<()> {
   let system = System::routed().on("/uri/:id", |Path((id,)): Path<(uuid::Uuid,)>| async { id });

   let id = uuid::Uuid::new_v4();
   let response = system.call(Frame::message(format!("/uri/{id}")).await?;

   assert_eq!(response, id);
}

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Path<T>

where T: DeserializeOwned + Clone,

fn clone(&self) -> Path<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Path<T>

where T: DeserializeOwned + Debug,

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

Formats the value using the given formatter.

impl<State, T> Extractor<State> for Path<T>

where T: DeserializeOwned, State: Debug + Clone + Send + Sync + 'static,

type Error = PathError

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: &Context<State>) -> Result<Self, Self::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<T> PartialEq for Path<T>

where T: DeserializeOwned + PartialEq,

fn eq(&self, other: &Path<T>) -> 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<T> Eq for Path<T>

where T: DeserializeOwned + Eq,

impl<T> StructuralPartialEq for Path<T>

where T: DeserializeOwned,