Struct ntex::io::Io

impl Io

pub fn new(io: I) -> Io
where I: IoStream,

Create Io instance

pub fn with_memory_pool(io: I, pool: PoolRef) -> Io
where I: IoStream,

Create Io instance in specific memory pool.

impl<F> Io<F>

pub fn set_memory_pool(&self, pool: PoolRef)

Set memory pool

pub fn set_disconnect_timeout(&self, timeout: Seconds)

Set io disconnect timeout in millis

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

Clone current io object.

Current io object becomes closed.

impl<F> Io<F>

pub fn get_ref(&self) -> IoRef

Get instance of IoRef

impl<F, T> Io<Layer<F, T>>
where F: FilterLayer, T: Filter,

pub fn filter(&self) -> &F

Get referece to a filter

impl<F> Io<F>
where F: Filter,

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

Convert current io stream into sealed version

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

Map current filter with new one

impl<F> Io<F>

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

Read incoming io stream and decode codec item.

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

Wait until read becomes ready.

pub fn pause(&self)

Pause read task

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

Encode item, send to the peer. Fully flush write buffer.

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

Wake write task and instruct to flush data.

This is async version of .poll_flush() method.

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

Gracefully shutdown io stream

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

Polls for read readiness.

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

Return value The function returns:

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

pub fn poll_recv( &self, codec: &U, cx: &mut Context<'_> ) -> Poll<Result<::Item, RecvError>>
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>>

Wake write task and instruct to flush data.

If full is true then wake up dispatcher when all data is flushed otherwise wake up when size of write buffer is lower than buffer max size.

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

Gracefully shutdown io stream

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

Pause read task

Returns status updates

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

Wait for status updates

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

Register dispatch task

Methods from Deref<Target = IoRef>§

pub fn memory_pool(&self) -> PoolRef

Get memory pool

pub fn is_closed(&self) -> bool

Check if io stream is closed

pub fn wake(&self)

Wake dispatcher task

pub fn close(&self)

Gracefully close connection

Notify dispatcher and initiate io stream shutdown process.

pub fn force_close(&self)

Force close connection

Dispatcher does not wait for uncompleted responses. Io stream get terminated without any graceful period.

pub fn want_shutdown(&self)

Gracefully shutdown io stream

pub fn query<T>(&self) -> QueryItem<T>
where T: 'static,

Query filter specific data

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

Encode and write item to a buffer and wake up write task

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

Attempts to decode a frame from the read buffer

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

Attempts to decode a frame from the read buffer

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

Write bytes to a buffer and wake up write task

pub fn with_buf<F, R>(&self, f: F) -> Result<R, Error>
where F: FnOnce(&WriteBuf<'_>) -> R,

Get access to write buffer

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

Get mut access to source write buffer

pub fn with_read_buf<F, R>(&self, f: F) -> R
where F: FnOnce(&mut BytesVec) -> R,

Get mut access to source read buffer

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 tag(&self) -> &'static str

Get tag

pub fn set_tag(&self, tag: &'static str)

Set tag

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. Read more

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. Read more

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 From<Io<Sealed>> for IoBoxed

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

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. Read more

1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more

impl<F> PartialEq for Io<F>

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

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

1.0.0 · source§

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.

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> + 'static, C::Error: Error, S: Service<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response>, B: MessageBody,

type Response = ()

Responses given by the service.

type Error = DispatchError

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

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

Returns Ready when the service is able to process requests. Read more

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

Shutdown service. Read more

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

Process the request and return the response asynchronously. Read more

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

Map this service’s output to a different type, returning a new service of the resulting type. Read more

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

Map this service’s error to a different error, returning a new service. Read more

impl<F, Ctl, Pub> Service<Io<F>> for ServerHandler<Ctl, Pub>
where F: Filter, Ctl: ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>, Response = ControlAck> + 'static, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::Error: Debug, <Ctl as ServiceFactory<Control<<Pub as ServiceFactory<Message>>::Error>>>::InitError: Debug, Pub: ServiceFactory<Message, Response = ()> + 'static, <Pub as ServiceFactory<Message>>::Error: Debug, <Pub as ServiceFactory<Message>>::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<Ctl, Pub>> ) -> Result<<ServerHandler<Ctl, Pub> as Service<Io<F>>>::Response, <ServerHandler<Ctl, Pub> as Service<Io<F>>>::Error>

Process the request and return the response asynchronously. Read more

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

Returns Ready when the service is able to process requests. Read more

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

Shutdown service. Read more

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

Map this service’s output to a different type, returning a new service of the resulting type. Read more

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

Map this service’s error to a different error, returning a new service. Read more

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.

fn poll_ready( &self, cx: &mut Context<'_> ) -> Poll<Result<(), <SslAcceptorService as Service<Io<F>>>::Error>>

Returns Ready when the service is able to process requests. Read more

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

Process the request and return the response asynchronously. Read more

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

Shutdown service. Read more

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

Map this service’s output to a different type, returning a new service of the resulting type. Read more

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

Map this service’s error to a different error, returning a new service. Read more

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.

fn poll_ready( &self, cx: &mut Context<'_> ) -> Poll<Result<(), <TlsAcceptorService as Service<Io<F>>>::Error>>

Returns Ready when the service is able to process requests. Read more

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

Process the request and return the response asynchronously. Read more

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

Shutdown service. Read more

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

Map this service’s output to a different type, returning a new service of the resulting type. Read more

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

Map this service’s error to a different error, returning a new service. Read more

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.

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

Process the request and return the response asynchronously. Read more

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

Returns Ready when the service is able to process requests. Read more

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

Shutdown service. Read more

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

Map this service’s output to a different type, returning a new service of the resulting type. Read more

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

Map this service’s error to a different error, returning a new service. Read more

impl<F, S, B, C> ServiceFactory<Io<F>> for H1Service<F, S, B, C>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, Response = ControlAck> + '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 = ()

Errors potentially raised while building a service.

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

The kind of Service created by this factory.

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

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

impl<F, S, B, C> ServiceFactory<Io<F>> for H2Service<F, S, B, C>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response>, B: MessageBody, C: ServiceFactory<Control<H2Error>, Response = ControlAck> + '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 = ()

Errors potentially raised while building a service.

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

The kind of Service created by this factory.

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

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

impl<F, S, B, C1, C2> ServiceFactory<Io<F>> for HttpService<F, S, B, C1, C2>
where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response>, B: MessageBody, C1: ServiceFactory<Control<F, S::Error>, Response = ControlAck> + 'static, C1::Error: Error, C1::InitError: Debug, C2: ServiceFactory<Control<H2Error>, 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 = ()

Errors potentially raised while building a service.

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

The kind of Service created by this factory.

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

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

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

type Response = ()

Responses given by the created services.

type Error = ServerError<()>

Errors produced by the created services.

type Service = ServerHandler<Ctl, Pub>

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

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

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

impl<F, C> ServiceFactory<Io<F>, C> 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 kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

async fn create( &self, _: C ) -> Result<<SslAcceptor as ServiceFactory<Io<F>, C>>::Service, <SslAcceptor as ServiceFactory<Io<F>, C>>::InitError>

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

impl<F, C> ServiceFactory<Io<F>, C> 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 kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

async fn create( &self, _: C ) -> Result<<TlsAcceptor as ServiceFactory<Io<F>, C>>::Service, <TlsAcceptor as ServiceFactory<Io<F>, C>>::InitError>

Create and return a new service value asynchronously.

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

Create and return a new service value asynchronously and wrap into 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,

Map this service’s output to a different type, returning a new service of the resulting 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,

Map this service’s error to a different error, returning 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,

Map this factory’s init error to a different error, returning a new service.

impl TryFrom<Stream> for Io

type Error = Error

The type returned in the event of a conversion error.

fn try_from(sock: Stream) -> Result<Io, <Io as TryFrom<Stream>>::Error>

Performs the conversion.

impl<F> Eq for Io<F>

Auto Trait Implementations§

impl<F = Base> !UnwindSafe for Io<F>

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<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into 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<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom 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>::Error>

Performs the conversion.

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

type Error = >::Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more