Struct coap_handler_implementations::wkc::ConstantSingleRecordReport

pub struct ConstantSingleRecordReport<'a, H: Handler> { /* private fields */ }

Wrapper around arbitrary Handlers to make them report some attributes. The path is often configured empty, relying on the tree builder to augment it with the actual path.

This helps integrating handler implementations that do not manually implement Reporting.

Any Reporting the handler might implement is overridden by this.

Implementations

impl<'a, H: Handler> ConstantSingleRecordReport<'a, H>

pub fn new(handler: H, attributes: &'a [Attribute]) -> Self

Wrap a handler with attributes reported at its single path

pub fn new_with_path( handler: H, attributes: &'a [Attribute], path: &'a [&'a str] ) -> Self

Wrap a handler with attributes and additional path components

Compared to .new(), this is primarily useful for handlers that do perform own path processing (and are thus instanciated .below() some path), but whose root resource is not the resource below which is put. This is a typical case: To use relative references, it is convenient to make a handler go .below(&["path"]), but then expect an extra / segment (an empty component in the path list) at the end – and then deal out relative references like 1 or ./2 to go to /path/2. Such handlers put &[""] in the path argument.

Trait Implementations

impl<'a, H: Handler> Handler for ConstantSingleRecordReport<'a, H>

type RequestData = <H as Handler>::RequestData

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

type ExtractRequestError = <H as Handler>::ExtractRequestError

Error type for extract_request_data().

type BuildResponseError<M: MinimalWritableMessage> = <H as Handler>::BuildResponseError<M>

Error type for writing response data.

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

Process an incoming request.

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

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

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

Build a response for the request

impl<'a, H: Handler> Reporting for ConstantSingleRecordReport<'a, H>

type Record<'b> = ConstantSliceRecord<'b> where Self: 'b

type Reporter<'b> = Once<ConstantSliceRecord<'b>> where Self: 'b

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