Trait tls_api::TlsConnector[−][src]

pub trait TlsConnector: Sized + Sync + Send + 'static {
    type Builder: TlsConnectorBuilder<Connector = Self>;
    type Underlying;
    type TlsStream: TlsStreamDyn;

    const IMPLEMENTED: bool;
    const SUPPORTS_ALPN: bool;
    const TYPE_DYN: &'static dyn TlsConnectorType;

    fn underlying_mut(&mut self) -> &mut Self::Underlying;

    fn info() -> ImplInfo;

    fn builder() -> Result<Self::Builder>;

    fn connect_with_socket<'a, S>(
        &'a self, 
        domain: &'a str, 
        stream: S
    ) -> BoxFuture<'a, Result<TlsStreamWithSocket<S>>>ⓘ
Notable traits for BoxFuture<'a, R>
impl<'a, R> Future for BoxFuture<'a, R>    type Output = R;

    where
        S: AsyncSocket;

    fn connect_impl_tls_stream<'a, S>(
        &'a self, 
        domain: &'a str, 
        stream: S
    ) -> BoxFuture<'a, Result<Self::TlsStream>>ⓘ
Notable traits for BoxFuture<'a, R>
impl<'a, R> Future for BoxFuture<'a, R>    type Output = R;

    where
        S: AsyncSocket;

    fn into_dyn(self) -> TlsConnectorBox { ... }

    fn connect_default<'a, S>(
        domain: &'a str, 
        stream: S
    ) -> BoxFuture<'a, Result<TlsStream>>ⓘ
Notable traits for BoxFuture<'a, R>
impl<'a, R> Future for BoxFuture<'a, R>    type Output = R;

    where
        S: AsyncSocket,
    { ... }

    fn connect<'a, S>(
        &'a self, 
        domain: &'a str, 
        stream: S
    ) -> BoxFuture<'a, Result<TlsStream>>ⓘ
Notable traits for BoxFuture<'a, R>
impl<'a, R> Future for BoxFuture<'a, R>    type Output = R;

    where
        S: AsyncSocket,
    { ... }
}

A builder for client-side TLS connections.

Associated Types

type Builder: TlsConnectorBuilder<Connector = Self>[src]

Type of the builder for this connector.

type Underlying[src]

Type of the underlying connector.

type TlsStream: TlsStreamDyn[src]

crate::TlsStream<tls_api::AsyncSocketBox>.

In the world of HKT this would be:

ⓘ
type TlsStream<S: TlsStreamDyn> : TlsStreamWithSocketDyn<S>;
Loading content...

Associated Constants

const IMPLEMENTED: bool[src]

Is it implemented? When false all operations return an error.

At the moment of writing, there are two crates which return false here:

  • tls-api-stub, dummy implementation is not meant to be instantiated
  • tls-api-security-framework, true only on macOS and iOS, false elsewhere

const SUPPORTS_ALPN: bool[src]

Whether this implementation supports ALPN negotiation.

const TYPE_DYN: &'static dyn TlsConnectorType[src]

Dynamic (without type parameter) version of the connector.

This function returns a connector type, which can be used to constructor connectors.

Loading content...

Required methods

fn underlying_mut(&mut self) -> &mut Self::Underlying[src]

Get the underlying builder.

API intentionally exposes the underlying acceptor builder to allow fine tuning not possible in common API.

fn info() -> ImplInfo[src]

Implementation info.

fn builder() -> Result<Self::Builder>[src]

New builder for the acceptor.

fn connect_with_socket<'a, S>(
    &'a self,
    domain: &'a str,
    stream: S
) -> BoxFuture<'a, Result<TlsStreamWithSocket<S>>>ⓘ

Notable traits for BoxFuture<'a, R>

impl<'a, R> Future for BoxFuture<'a, R> type Output = R;
 where
    S: AsyncSocket, [src]

Connect.

Returned future is resolved when the TLS-negotiation completes, and the stream is ready to send and receive.

This function returns a stream which provides access to the underlying socket.

Practically, connect is usually needed.

fn connect_impl_tls_stream<'a, S>(
    &'a self,
    domain: &'a str,
    stream: S
) -> BoxFuture<'a, Result<Self::TlsStream>>ⓘ

Notable traits for BoxFuture<'a, R>

impl<'a, R> Future for BoxFuture<'a, R> type Output = R;
 where
    S: AsyncSocket, [src]

Connect.

Returned future is resolved when the TLS-negotiation completes, and the stream is ready to send and receive.

This version returns a stream of type of the underlying implementation, which may provide access to the implementation details.

Practically, connect is usually needed.

Loading content...

Provided methods

fn into_dyn(self) -> TlsConnectorBox[src]

Dynamic (without type parameter) version of the connector.

fn connect_default<'a, S>(
    domain: &'a str,
    stream: S
) -> BoxFuture<'a, Result<TlsStream>>ⓘ

Notable traits for BoxFuture<'a, R>

impl<'a, R> Future for BoxFuture<'a, R> type Output = R;
 where
    S: AsyncSocket, [src]

Connect using default settings.

Shortcut.

fn connect<'a, S>(
    &'a self,
    domain: &'a str,
    stream: S
) -> BoxFuture<'a, Result<TlsStream>>ⓘ

Notable traits for BoxFuture<'a, R>

impl<'a, R> Future for BoxFuture<'a, R> type Output = R;
 where
    S: AsyncSocket, [src]

Connect.

Returned future is resolved when the TLS-negotiation completes, and the stream is ready to send and receive.

This is like the function you want to use.

Loading content...

Implementors

Loading content...