Struct Io 

pub struct Io<F = Base>(/* private fields */);

Interface object to the underlying I/O stream

Implementations

impl Io

pub fn new<I, T>(io: I, cfg: T) -> Io

where I: IoStream, T: Into<SharedCfg>,

Creates a new Io instance.

impl<F> Io<F>

pub fn get_ref(&self) -> IoRef

Get an instance of IoRef.

pub fn take(&self) -> Io<F>

Takes the current I/O object.

After this call, the I/O object is no longer valid for use.

pub fn set_config<T>(&self, cfg: T)

where T: Into<SharedCfg>,

Updates the shared I/O configuration.

impl<F, T> Io<Layer<F, T>>

where F: FilterLayer, T: Filter,

pub fn filter(&self) -> &F

Returns a reference to a filter.

impl<F> Io<F>

where F: Filter,

pub fn seal(self) -> Io<Sealed>

Convert the current I/O stream into a sealed version.

pub fn boxed(self) -> IoBoxed

Convert the current I/O stream into a boxed version.

pub fn add_filter<U>(self, nf: U) -> Io<Layer<U, F>>

where U: FilterLayer,

Adds a new processing layer to the current filter chain.

pub fn map_filter<U, R>(self, f: U) -> Io<R>

where U: FnOnce(F) -> R, R: Filter,

Wraps the current layer with a wrapper.

impl<F> Io<F>

pub async fn recv<U>( &self, codec: &U, ) -> Result<Option<<U as Decoder>::Item>, Either<<U as Decoder>::Error, Error>>

where U: Decoder,

Reads from the incoming I/O stream and decodes a codec item.

pub async fn read(&self, dst: &mut [u8]) -> Result<(), Error>

Reads bytes from this I/O stream into the specified buffer.

If there is not enough data available, waits for incoming data. Returns an error of kind io::ErrorKind::UnexpectedEof if the stream is disconnected before dst is completely filled.

pub async fn read_ready(&self) -> Result<Option<()>, Error>

Waits until the I/O stream is ready for reading.

pub async fn read_notify(&self) -> Result<Option<()>, Error>

Waits until the I/O stream receives new data.

pub fn pause(&self)

Pauses the read task.

pub async fn send<U>( &self, item: <U as Encoder>::Item, codec: &U, ) -> Result<(), Either<<U as Encoder>::Error, Error>>

where U: Encoder,

Encodes an item and sends it to the peer, fully flushing the write buffer.

pub async fn flush(&self, full: bool) -> Result<(), Error>

Wakes the write task and requests a flush of buffered data.

This is the async version of .poll_flush() method.

pub async fn shutdown(&self) -> Result<(), Error>

Gracefully shuts down the I/O stream.

pub fn poll_read_ready( &self, cx: &mut Context<'_>, ) -> Poll<Result<Option<()>, Error>>

Polls for read readiness.

If the I/O stream is not currently ready for reading, this method will store a clone of the Waker from the provided Context. When the I/O stream becomes ready for reading, wake() will be called on the waker.

Returns

The function returns:

• Poll::Pending if the I/O stream is not ready for reading.
• Poll::Ready(Ok(Some(()))) if the I/O stream is ready for reading.
• Poll::Ready(Ok(None)) if the I/O stream is disconnected.
• Poll::Ready(Err(e)) if an error is encountered.

pub fn poll_read_notify( &self, cx: &mut Context<'_>, ) -> Poll<Result<Option<()>, Error>>

Polls the I/O stream for availability of incoming data.

pub fn poll_recv<U>( &self, codec: &U, cx: &mut Context<'_>, ) -> Poll<Result<<U as Decoder>::Item, RecvError<U>>>

where U: Decoder,

Decode codec item from incoming bytes stream.

Wake read task and request to read more data if data is not enough for decoding. If error get returned this method does not register waker for later wake up action.

pub fn poll_recv_decode<U>( &self, codec: &U, cx: &mut Context<'_>, ) -> Result<Decoded<<U as Decoder>::Item>, RecvError<U>>

where U: Decoder,

Decode codec item from incoming bytes stream.

Wake read task and request to read more data if data is not enough for decoding. If error get returned this method does not register waker for later wake up action.

pub fn poll_flush( &self, cx: &mut Context<'_>, full: bool, ) -> Poll<Result<(), Error>>

Wakes the write task and instructs it to flush data.

If full is true, wakes the dispatcher when all data has been flushed; otherwise, it wakes when the write buffer size falls below the low-watermark size.

pub fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<Result<(), Error>>

Gracefully shuts down the I/O stream.

pub fn poll_read_pause(&self, cx: &mut Context<'_>) -> Poll<IoStatusUpdate>

Pauses the read task.

Returns status updates.

pub fn poll_status_update(&self, cx: &mut Context<'_>) -> Poll<IoStatusUpdate>

Polls for available status updates.

pub fn poll_dispatch(&self, cx: &mut Context<'_>)

Registers a dispatch task.

Methods from Deref<Target = IoRef>

pub fn id(&self) -> Id

Gets the ID.

pub fn tag(&self) -> &'static str

Gets the I/O tag.

pub fn cfg(&self) -> &IoConfig

Gets the configuration.

pub fn shared(&self) -> SharedCfg

Gets the shared configuration.

pub fn is_closed(&self) -> bool

Checks whether the I/O stream is closed.

pub fn is_wr_backpressure(&self) -> bool

Checks whether write back-pressure is enabled.

pub fn close(&self)

Gracefully closes the connection.

Initiates the I/O stream shutdown process.

pub fn terminate(&self)

Force-closes the connection.

The dispatcher does not wait for incomplete responses. The I/O stream is terminated without any graceful period.

pub fn query<T>(&self) -> QueryItem<T>

where T: 'static,

Queries filter-specific data.

pub fn encode<U>( &self, item: <U as Encoder>::Item, codec: &U, ) -> Result<(), <U as Encoder>::Error>

where U: Encoder,

Encodes the item into the write buffer.

pub fn encode_slice(&self, src: &[u8]) -> Result<(), Error>

Encodes the slice into the write buffer.

pub fn encode_bytes<B>(&self, src: B) -> Result<(), Error>

where BytePage: From<B>,

Writes bytes to the write buffer.

pub fn decode<U>( &self, codec: &U, ) -> Result<Option<<U as Decoder>::Item>, <U as Decoder>::Error>

where U: Decoder,

Attempts to decode a frame from the read buffer.

pub fn decode_item<U>( &self, codec: &U, ) -> Result<Decoded<<U as Decoder>::Item>, <U as Decoder>::Error>

where U: Decoder,

Attempts to decode a frame from the read buffer.

pub fn send_buf(&self) -> Result<(), Error>

Sends the write buffer to the I/O layer.

Requires the underlying runtime to implement .write(); otherwise, no action is taken.

pub fn with_buf<F, R>(&self, f: F) -> Result<R, Error>

where F: FnOnce(&mut FilterBuf<'_>) -> R,

Get access to filter buffer

pub fn with_read_buf<F, R>(&self, f: F) -> R

where F: FnOnce(&mut BytesMut) -> R,

Get mut access to read buffer

pub fn with_write_buf<F, R>(&self, f: F) -> Result<R, Error>

where F: FnOnce(&mut BytePages) -> R,

Get mut access to source write buffer

pub fn with_read_src_buf<F, R>(&self, f: F) -> R

where F: FnOnce(&mut BytesMut) -> R,

Get mut access to src read buffer

pub fn with_write_dst_buf<F, R>(&self, f: F) -> R

where F: FnOnce(&mut BytePages) -> R,

Get mut access to dest write buffer

pub fn resize_read_buf(&self, buf: &mut BytesMut)

Make sure buffer has enough free space

pub fn notify_dispatcher(&self)

Wakeup dispatcher

pub fn notify_timeout(&self)

Wakeup dispatcher and send keep-alive error

pub fn timer_handle(&self) -> TimerHandle

Current timer handle

pub fn start_timer(&self, timeout: Seconds) -> TimerHandle

Start timer

pub fn stop_timer(&self)

Stop timer

pub fn on_disconnect(&self) -> OnDisconnect

Notify when io stream get disconnected

Trait Implementations

impl<F> AsRef<IoRef> for Io<F>

fn as_ref(&self) -> &IoRef

Converts this type into a shared reference of the (usually inferred) input type.

impl<F> Debug for Io<F>

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

Formats the value using the given formatter.

impl<F> Deref for Io<F>

type Target = IoRef

The resulting type after dereferencing.

fn deref(&self) -> &<Io<F> as Deref>::Target

Dereferences the value.

impl<F> Drop for Io<F>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<F> Eq for Io<F>

impl<I> From<I> for Io

where I: IoStream,

fn from(io: I) -> Io

Converts to this type from the input type.

impl<F> From<Io<F>> for IoBoxed

where F: Filter,

fn from(io: Io<F>) -> IoBoxed

Converts to this type from the input type.

impl<F> From<Io<F>> for TokioIoBoxed

where F: Filter,

fn from(io: Io<F>) -> TokioIoBoxed

Converts to this type from the input type.

impl From<IoBoxed> for Io<Sealed>

fn from(value: IoBoxed) -> Io<Sealed>

Converts to this type from the input type.

impl<F> Hash for Io<F>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F> PartialEq for Io<F>

fn eq(&self, other: &Io<F>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<F, Pub, Ctl> Service<Io<F>> for ServerHandler<Pub, Ctl>

where F: Filter, Ctl: ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg, Response = ControlAck> + 'static, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg>>::Error: Debug, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg>>::InitError: Debug, Pub: ServiceFactory<Message, SharedCfg, Response = ()> + 'static, <Pub as ServiceFactory<Message, SharedCfg>>::Error: Debug, <Pub as ServiceFactory<Message, SharedCfg>>::InitError: Debug,

type Response = ()

Responses given by the service.

type Error = ServerError<()>

Errors produced by the service when polling readiness or executing call.

async fn call( &self, req: Io<F>, _: ServiceCtx<'_, ServerHandler<Pub, Ctl>>, ) -> Result<<ServerHandler<Pub, Ctl> as Service<Io<F>>>::Response, <ServerHandler<Pub, Ctl> as Service<Io<F>>>::Error>

Processes a request and returns the response asynchronously.

async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error>

Returns when the service is ready to process requests.

async fn shutdown(&self)

Shuts down the service.

fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>

Polls the service from the current async task.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<Self, F, Req, Res>, Req>

where Self: Sized, F: Fn(Self::Response) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<Self, F, E>, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

impl<F> Service<Io<F>> for SslAcceptorService

where F: Filter,

type Response = Io<Layer<SslFilter, F>>

Responses given by the service.

type Error = Box<dyn Error>

Errors produced by the service when polling readiness or executing call.

async fn ready( &self, _: ServiceCtx<'_, SslAcceptorService>, ) -> Result<(), <SslAcceptorService as Service<Io<F>>>::Error>

Returns when the service is ready to process requests.

async fn call( &self, io: Io<F>, _: ServiceCtx<'_, SslAcceptorService>, ) -> Result<<SslAcceptorService as Service<Io<F>>>::Response, <SslAcceptorService as Service<Io<F>>>::Error>

Processes a request and returns the response asynchronously.

async fn shutdown(&self)

Shuts down the service.

fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>

Polls the service from the current async task.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<Self, F, Req, Res>, Req>

where Self: Sized, F: Fn(Self::Response) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<Self, F, E>, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

impl<F> Service<Io<F>> for TlsAcceptorService

where F: Filter,

type Response = Io<Layer<TlsServerFilter, F>>

Responses given by the service.

type Error = Error

Errors produced by the service when polling readiness or executing call.

async fn ready( &self, _: ServiceCtx<'_, TlsAcceptorService>, ) -> Result<(), <TlsAcceptorService as Service<Io<F>>>::Error>

Returns when the service is ready to process requests.

async fn call( &self, io: Io<F>, _: ServiceCtx<'_, TlsAcceptorService>, ) -> Result<<TlsAcceptorService as Service<Io<F>>>::Response, <TlsAcceptorService as Service<Io<F>>>::Error>

Processes a request and returns the response asynchronously.

async fn shutdown(&self)

Shuts down the service.

fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>

Polls the service from the current async task.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<Self, F, Req, Res>, Req>

where Self: Sized, F: Fn(Self::Response) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<Self, F, E>, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

impl<F, S, B, C> Service<Io<F>> for H1ServiceHandler<F, S, B, C>

where F: Filter, C: Service<Control<F, S::Error>, Response = ControlAck<F>> + 'static, C::Error: Error, S: Service<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, B: MessageBody,

type Response = ()

Responses given by the service.

type Error = DispatchError

Errors produced by the service when polling readiness or executing call.

async fn ready(&self, _: ServiceCtx<'_, Self>) -> Result<(), Self::Error>

Returns when the service is ready to process requests.

fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>

Polls the service from the current async task.

async fn shutdown(&self)

Shuts down the service.

async fn call( &self, io: Io<F>, _: ServiceCtx<'_, Self>, ) -> Result<(), Self::Error>

Processes a request and returns the response asynchronously.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<Self, F, Req, Res>, Req>

where Self: Sized, F: Fn(Self::Response) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<Self, F, E>, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

impl<F: Filter> Service<Io<F>> for WsTransportService

type Response = Io<Layer<WsTransport, F>>

Responses given by the service.

type Error = Error

Errors produced by the service when polling readiness or executing call.

fn call( &self, io: Io<F>, _: ServiceCtx<'_, Self>, ) -> impl Future<Output = Result<Self::Response, Self::Error>>

Processes a request and returns the response asynchronously.

async fn ready(&self, ctx: ServiceCtx<'_, Self>) -> Result<(), Self::Error>

Returns when the service is ready to process requests.

async fn shutdown(&self)

Shuts down the service.

fn poll(&self, cx: &mut Context<'_>) -> Result<(), Self::Error>

Polls the service from the current async task.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<Self, F, Req, Res>, Req>

where Self: Sized, F: Fn(Self::Response) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<Self, F, E>, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

impl<F, Pub, Ctl> ServiceFactory<Io<F>, SharedCfg> for Server<Pub, Ctl>

where F: Filter, Ctl: ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg, Response = ControlAck> + 'static, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg>>::Error: Debug, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message, SharedCfg>>::Error>, SharedCfg>>::InitError: Debug, Pub: ServiceFactory<Message, SharedCfg, Response = ()> + 'static, <Pub as ServiceFactory<Message, SharedCfg>>::Error: Debug, <Pub as ServiceFactory<Message, SharedCfg>>::InitError: Debug,

type Response = ()

Responses given by the created services.

type Error = ServerError<()>

Errors produced by the created services.

type Service = ServerHandler<Pub, Ctl>

The type of Service produced by this factory.

type InitError = ()

Possible errors encountered during service construction.

async fn create( &self, cfg: SharedCfg, ) -> Result<<Server<Pub, Ctl> as ServiceFactory<Io<F>, SharedCfg>>::Service, <Server<Pub, Ctl> as ServiceFactory<Io<F>, SharedCfg>>::InitError>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.

impl<F> ServiceFactory<Io<F>, SharedCfg> for SslAcceptor

where F: Filter,

type Response = Io<Layer<SslFilter, F>>

Responses given by the created services.

type Error = Box<dyn Error>

Errors produced by the created services.

type Service = SslAcceptorService

The type of Service produced by this factory.

type InitError = ()

Possible errors encountered during service construction.

fn create( &self, cfg: SharedCfg, ) -> impl Future<Output = Result<<SslAcceptor as ServiceFactory<Io<F>, SharedCfg>>::Service, <SslAcceptor as ServiceFactory<Io<F>, SharedCfg>>::InitError>>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.

impl<F> ServiceFactory<Io<F>, SharedCfg> for TlsAcceptor

where F: Filter,

type Response = Io<Layer<TlsServerFilter, F>>

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Service = TlsAcceptorService

The type of Service produced by this factory.

type InitError = ()

Possible errors encountered during service construction.

fn create( &self, cfg: SharedCfg, ) -> impl Future<Output = Result<<TlsAcceptor as ServiceFactory<Io<F>, SharedCfg>>::Service, <TlsAcceptor as ServiceFactory<Io<F>, SharedCfg>>::InitError>>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.

impl<F, S, B, C1, C2> ServiceFactory<Io<F>, SharedCfg> for HttpService<F, S, B, C1, C2>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C1: ServiceFactory<Control<F, S::Error>, SharedCfg, Response = ControlAck<F>> + 'static, C1::Error: Error, C1::InitError: Debug, C2: ServiceFactory<Control<H2Error>, SharedCfg, Response = ControlAck> + 'static, C2::Error: Error, C2::InitError: Debug,

type Response = ()

Responses given by the created services.

type Error = DispatchError

Errors produced by the created services.

type InitError = ()

Possible errors encountered during service construction.

type Service = HttpServiceHandler<F, <S as ServiceFactory<Request, SharedCfg>>::Service, B, <C1 as ServiceFactory<Control<F, <S as ServiceFactory<Request, SharedCfg>>::Error>, SharedCfg>>::Service, C2>

The type of Service produced by this factory.

async fn create(&self, cfg: SharedCfg) -> Result<Self::Service, Self::InitError>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.

impl<F, S, B, C> ServiceFactory<Io<F>, SharedCfg> for H1Service<F, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, SharedCfg, Response = ControlAck<F>> + 'static, C::Error: Error, C::InitError: Debug,

type Response = ()

Responses given by the created services.

type Error = DispatchError

Errors produced by the created services.

type InitError = ()

Possible errors encountered during service construction.

type Service = H1ServiceHandler<F, <S as ServiceFactory<Request, SharedCfg>>::Service, B, <C as ServiceFactory<Control<F, <S as ServiceFactory<Request, SharedCfg>>::Error>, SharedCfg>>::Service>

The type of Service produced by this factory.

async fn create(&self, cfg: SharedCfg) -> Result<Self::Service, Self::InitError>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.

impl<F, S, B, C> ServiceFactory<Io<F>, SharedCfg> for H2Service<F, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<H2Error>, SharedCfg, Response = ControlAck> + 'static, C::Error: StdError, C::InitError: Debug,

type Response = ()

Responses given by the created services.

type Error = DispatchError

Errors produced by the created services.

type InitError = ()

Possible errors encountered during service construction.

type Service = H2ServiceHandler<F, <S as ServiceFactory<Request, SharedCfg>>::Service, B, C>

The type of Service produced by this factory.

async fn create(&self, cfg: SharedCfg) -> Result<Self::Service, Self::InitError>

Creates a new service asynchronously and returns it.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Asynchronously creates a new service and wraps it in a container.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Returns a new service that maps this service’s output to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Transforms this service’s error into another error, producing a new service.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn boxed( self, ) -> BoxServiceFactory<Cfg, Req, Self::Response, Self::Error, Self::InitError>

where Cfg: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.