Struct breadboard::Breadboard

pub struct Breadboard { /* private fields */ }

A router builder.

Register your routes, then use hyper’s NewService trait to create the service.

See the crate-level documentation for examples.

Anatomy of a handler

A handler is a function that takes a single argument, Request<T>. T must implement serde::Deserialize.

The handler returns a type that implements IntoFuture. The future’s Item is a Response<T>, where T must implement serde::Serialize. The future’s Error can be anything that implements std::error::Error, Send, and Sync.

If you aren’t doing any work in your handler that requires use of futures, you can simply return a Result, as Result implements IntoFuture.

Implementations

impl Breadboard

pub fn new() -> Self

Start a new Breadboard.

pub fn route<A, F, R, D, S, E>(self, method: Method, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for a route with the given method.

pub fn get<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for GET requests for a route.

pub fn post<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for POST requests for a route.

pub fn put<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for PUT requests for a route.

pub fn delete<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for DELETE requests for a route.

pub fn head<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for HEAD requests for a route.

pub fn options<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for OPTIONS requests for a route.

pub fn connect<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for CONNECT requests for a route.

pub fn patch<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for PATCH requests for a route.

pub fn trace<A, F, R, D, S, E>(self, route: A, handler: F) -> Selfwhere
    A: AsRef<str>,
    F: Fn(Request<D>) -> R + Send + Sync + 'static,
    R: IntoFuture<Item = Response<S>, Error = E> + 'static,
    R::Future: Send,
    for<'de> D: Deserialize<'de> + Send + 'static,
    S: Serialize + 'static,
    E: Into<Box<dyn Error + Send + Sync>>,

Add a handler for TRACE requests for a route.

pub fn build(&self) -> Result<Service, BuildError>

fixme

Trait Implementations

impl Debug for Breadboard

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

Formats the value using the given formatter.

impl Default for Breadboard

fn default() -> Breadboard

Returns the “default value” for a type.

impl NewService for Breadboard

type ReqBody = Body

The Payload body of the http::Request.

type ResBody = Body

The Payload body of the http::Response.

type Error = RequestError

The error type that can be returned by Services.

type Service = Service

The resolved Service from new_service().

type Future = FutureResult<Service, BuildError>

The future returned from new_service of a Service.

type InitError = BuildError

The error type that can be returned when creating a new Service.

fn new_service(&self) -> Self::Future

Create a new Service.