Struct spirit_tokio::handlers::HandleSocket

pub struct HandleSocket<F>(pub F);

A Transformation to handle the whole socket.

This is a newtype that turns a closure taking a socket and the Fragment describing it and returns a future of something that can be done with it.

This is appropriate for UDP-like sockets and if you want to accept the connections on a TCP-like socket manually.

If you want to handle separate connections from a TCP listening socket but don't want to care about accepting them (and want to leave some other bookkeeping, like the limits of connections, to this crate), then you want the HandleListener instead.

Trait Implementations

impl<F: Clone> Clone for HandleSocket<F>

fn clone(&self) -> HandleSocket<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for HandleSocket<F>

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

Formats the value using the given formatter.

impl<Socket, InputInstaller, SubFragment, F, R> Transformation<Socket, InputInstaller, SubFragment> for HandleSocket<F> where
    F: FnMut(Socket, &SubFragment) -> Result<R, Error>,
    R: 'static,
    SubFragment: Debug,
    R: IntoFuture<Item = (), Error = ()>, 

type OutputResource = R

The type of resource after the transformation.

type OutputInstaller = FutureInstaller<R>

The type of installer after the transformation.

fn installer(&mut self, _: InputInstaller, name: &str) -> Self::OutputInstaller

Creates the installer.

fn transform(
    &mut self,
    sock: Socket,
    cfg: &SubFragment,
    name: &str
) -> Result<R, Error>

Transforms one instance of the resource.