Struct coap_handler_implementations::WellKnownCore

pub struct WellKnownCore<H: Reporting + Handler>(/* private fields */);

Available on crate feature leaky_names only.

Expand description

Wrapper around a reporting handler that makes all reported resources discoverable at the path /.well-known/core.

This can be constructed via crate::ReportingHandlerBuilder::with_wkc(), typically after having gathered all resource in one handler.

Trait Implementations§

impl<H: Reporting + Handler> Handler for WellKnownCore<H>

type RequestData = WkcData<<H as Handler>::RequestData>

Type constructed in extract_request_data() passed on to build_response(). Read more

type ExtractRequestError = <H as Handler>::ExtractRequestError

Error type for extract_request_data(). Read more

type BuildResponseError<M: MinimalWritableMessage> = WkcBuildResponseError<<M as MinimalWritableMessage>::UnionError, <H as Handler>::BuildResponseError<M>>

Error type for writing response data. Read more

fn extract_request_data<M: ReadableMessage>( &mut self, req: &M ) -> Result<Self::RequestData, Self::ExtractRequestError>

Process an incoming request. Read more

fn estimate_length(&mut self, req: &Self::RequestData) -> usize

Estimate an upper bound for the number of bytes in the response Read more

fn build_response<M: MutableWritableMessage>( &mut self, m: &mut M, req: Self::RequestData ) -> Result<(), Self::BuildResponseError<M>>

Build a response for the request Read more

impl<H: Reporting + Handler> Reporting for WellKnownCore<H>

For reporting, a WellKnownCore handler simply passes on its inner description; the exposed .well-known/core resource is not listed.

Utilizing this (when in having a WellKnownCore handler around the resources, then adding more resources using HandlerBuilder::at(), and wrapping the result in a WellKnownCore again) is wasteful in terms of computation (as the inner one will never be hit), but can be convenient for composition in examples.

type Record<'res> = <H as Reporting>::Record<'res> where H: 'res

type Reporter<'res> = <H as Reporting>::Reporter<'res> where H: 'res

fn report(&self) -> Self::Reporter<'_>

Auto Trait Implementations§

impl<H> RefUnwindSafe for WellKnownCore<H>
where H: RefUnwindSafe,

impl<H> Send for WellKnownCore<H>
where H: Send,

impl<H> Sync for WellKnownCore<H>
where H: Sync,

impl<H> Unpin for WellKnownCore<H>
where H: Unpin,

impl<H> UnwindSafe for WellKnownCore<H>
where H: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<'a, OldRD, OldH> HandlerBuilder<'a, OldRD> for OldH
where OldH: Handler<RequestData = OldRD>,

fn at<H>(self, path: &'a [&'a str], handler: H) -> ForkingHandler<'a, H, Self>
where H: Handler + Sized,

Divert requests arriving at path into the given handler. Read more

fn at_with_attributes<H>( self, path: &'a [&'a str], attributes: &'a [Attribute], handler: H ) -> ForkingHandler<'a, ConstantSingleRecordReport<'a, H>, Self>
where H: Handler + Sized,

Divert requests arriving at path into the given handler, and announce them with the given attributes in .well-known/core. Read more

fn below<H>( self, path: &'a [&'a str], handler: H ) -> ForkingTreeHandler<'a, H, Self>

Divert requests arriving with an Uri-Path starting with path to the given handler. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<'a, OldRD, OldH> ReportingHandlerBuilder<'a, OldRD> for OldH
where OldH: Handler<RequestData = OldRD> + Reporting,

fn with_wkc(self) -> WellKnownCore<Self>

Add a /.well-known/core resource that exposes the information the previous (stack of) handler(s) exposes throught the Reporting trait.

impl<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.