pub fn connect_std(stream: net::TcpStream,
                       addr: &SocketAddr,
                       handle: &Handle)
        -> ConnectFuture
    {
        let inner = match mio::net::TcpStream::connect_stream(stream, addr) {
            Ok(tcp) => TcpStream::new(tcp, handle),
            Err(e) => ConnectFutureState::Error(e),
        };
        ConnectFuture { inner: inner }
    }
/// Creates a new `TcpStream` from the pending socket inside the given
/// `std::net::TcpStream`, connecting it to the address specified.
///
/// This constructor allows configuring the socket before it's actually
/// connected, and this function will transfer ownership to the returned
/// `TcpStream` if successful. An unconnected `TcpStream` can be created
/// with the `net2::TcpBuilder` type (and also configured via that route).
///
/// The platform specific behavior of this function looks like:
///
/// * On Unix, the socket is placed into nonblocking mode and then a
///   `connect` call is issued.
///
/// * On Windows, the address is stored internally and the connect operation
///   is issued when the returned `TcpStream` is registered with an event
///   loop. Note that on Windows you must `bind` a socket before it can be
///   connected, so if a custom `TcpBuilder` is used it should be bound
///   (perhaps to `INADDR_ANY`) before this method is called.
Creates a new `TcpStream` from the pending socket inside the given
`std::net::TcpStream`, connecting it to the address specified.

This constructor allows configuring the socket before it's actually
connected, and this function will transfer ownership to the returned
`TcpStream` if successful. An unconnected `TcpStream` can be created
with the `net2::TcpBuilder` type (and also configured via that route).

The platform specific behavior of this function looks like.

On Unix, the socket is placed into nonblocking mode and then a
`connect` call is issued.

On Windows, the address is stored internally and the connect operation
is issued when the returned `TcpStream` is registered with an event
loop.
Creates a new ` TcpStream ` from the pending socket inside the given ` std :: net :: TcpStream ` connecting it to the address specified . This constructor allows configuring the socket before it ' s actually connected and this function will transfer ownership to the returned ` TcpStream ` if successful . An unconnected ` TcpStream ` can be created with the ` net2 :: TcpBuilder ` type ( and also configured via that route ) . The platform specific behavior of this function looks like . On Unix the socket is placed into nonblocking mode and then a ` connect ` call is issued . On Windows the address is stored internally and the connect operation is issued when the returned ` TcpStream ` is registered with an event loop .
pub fn connect_std(stream: net::TcpStream,
                       addr: &SocketAddr,
                       handle: &Handle)
        -> ConnectFuture
    {
        let inner = match mio::net::TcpStream::connect_stream(stream, addr) {
            Ok(tcp) => TcpStream::new(tcp, handle),
            Err(e) => ConnectFutureState::Error(e),
        };
        ConnectFuture { inner: inner }
    }
pub fn connect_std ( stream : net :: TcpStream , addr : & SocketAddr , handle : & Handle ) -> ConnectFuture { let inner = match mio :: net :: TcpStream :: connect_stream ( stream , addr ) { Ok ( tcp ) => TcpStream :: new ( tcp , handle ) , Err ( e ) => ConnectFutureState :: Error ( e ) , } ; ConnectFuture { inner : inner } }
Creates a new `TcpStream` from the pending socket inside the given
`std::net::TcpStream`, connecting it to the address specified.
Creates a new ` TcpStream ` from the pending socket inside the given ` std :: net :: TcpStream ` connecting it to the address specified .
stream
net::TcpStream
addr
&SocketAddr
handle
&Handle
stream
net::TcpStream
addr
&SocketAddr
handle
&Handle