Enum toad::server::Run

pub enum Run<P, E>where
    P: PlatformTypes,{
    Unmatched(Addrd<Req<P>>),
    Matched(Addrd<Message<P>>),
    Error(Error<E>),
}

A request was received and needs to be handled by Running your code.

This data structure allows you to declare a re-runnable block of code that will be invoked with every incoming request.

use toad::server::ap::Hydrate;
use toad::server::{respond, Error, Run};
use toad::std::{dtls, PlatformTypes as Std};

let run: Run<Std<dtls::Y>, ()> = Run::Error(Error::Other(()));
run.maybe(|ap| {
     let (_, Hydrate { req, .. }) = ap.try_unwrap_ok_hydrated().unwrap();
     if req.data().path() == Ok(Some("hello")) {
       let name = req.data().payload_str().unwrap_or("you nameless scoundrel");
       respond::ok(format!("hi there, {}!", name).into()).hydrate(req)
     } else {
       respond::respond(toad::resp::code::NOT_FOUND, [].into()).hydrate(req)
     }
   });

Variants

Unmatched(Addrd<Req<P>>)

Request has not been matched yet

Matched(Addrd<Message<P>>)

Request has a response

Error(Error<E>)

An Error occurred

Implementations

impl<P, E> Run<P, E>where P: PlatformTypes, E: Debug,

pub fn handle(ap: Ap<Complete, P, (), E>) -> Self

Lift an Ap to Run

pub fn maybe<F>(self, f: F) -> Selfwhere F: FnMut(Ap<Hydrated, P, (), E>) -> Ap<Complete, P, (), E>,

Use a function to potentially respond to a request

Each “maybe” branch corresponds roughly to a route / RESTful CoAP resource.

Trait Implementations

impl<P, E: Debug> Debug for Run<P, E>where P: PlatformTypes + Debug,

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

Formats the value using the given formatter.

impl<P, E> PartialEq<Run<P, E>> for Run<P, E>where P: PlatformTypes, E: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

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