Trait Protocol 

pub trait Protocol:
    SealedProtocol
    + Send
    + 'static {
    type ProviderEndpoint: Send + 'static;
    type ClientEndpoint: Send + 'static;

    // Required methods
    fn create_endpoints() -> (Self::ProviderEndpoint, Self::ClientEndpoint);
    fn forward(
        client_end: Self::ClientEndpoint,
        provider_end: Self::ProviderEndpoint,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>>;
}

Required Associated Types

type ProviderEndpoint: Send + 'static

type ClientEndpoint: Send + 'static

Required Methods

fn create_endpoints() -> (Self::ProviderEndpoint, Self::ClientEndpoint)

fn forward( client_end: Self::ClientEndpoint, provider_end: Self::ProviderEndpoint, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Protocol for End

type ClientEndpoint = ReceiverOnce<()>

type ProviderEndpoint = SenderOnce<()>

impl Protocol for Release

type ClientEndpoint = ()

type ProviderEndpoint = ()

impl Protocol for Z

type ClientEndpoint = ()

type ProviderEndpoint = ()

impl<A, B> Protocol for ReceiveChannel<A, B>

where A: Protocol, B: Protocol,

type ClientEndpoint = (SenderOnce<<A as Protocol>::ClientEndpoint>, <B as Protocol>::ClientEndpoint)

type ProviderEndpoint = (ReceiverOnce<<A as Protocol>::ClientEndpoint>, <B as Protocol>::ProviderEndpoint)

impl<A, B> Protocol for SendChannel<A, B>

where A: Protocol, B: Protocol,

type ClientEndpoint = (ReceiverOnce<<A as Protocol>::ClientEndpoint>, <B as Protocol>::ClientEndpoint)

type ProviderEndpoint = (SenderOnce<<A as Protocol>::ClientEndpoint>, <B as Protocol>::ProviderEndpoint)

impl<C, F> Protocol for RecX<C, F>

where C: Send + 'static, F: Protocol + RecApp<(RecX<C, F>, C)>,

type ClientEndpoint = ReceiverOnce<RecEndpoint<F, (RecX<C, F>, C)>>

type ProviderEndpoint = SenderOnce<RecEndpoint<F, (RecX<C, F>, C)>>

impl<F> Protocol for Lock<F>

where F: Protocol + SharedRecApp<SharedToLinear<LinearToShared<F>>>, F::Applied: Protocol,

type ClientEndpoint = ReceiverOnce<Lock<F>>

type ProviderEndpoint = SenderOnce<Lock<F>>

impl<F> Protocol for SharedToLinear<LinearToShared<F>>

where F: Send + 'static + SharedRecApp<SharedToLinear<LinearToShared<F>>>,

type ClientEndpoint = SenderOnce<()>

type ProviderEndpoint = ReceiverOnce<()>

impl<N> Protocol for S<N>

where N: Protocol,

type ClientEndpoint = ()

type ProviderEndpoint = ()

impl<Row> Protocol for ExternalChoice<Row>

where Row: ToRow + Send + 'static,

type ClientEndpoint = SenderOnce<AppSum<'static, <Row as ToRow>::Row, ProviderEndpointF>>

type ProviderEndpoint = ReceiverOnce<AppSum<'static, <Row as ToRow>::Row, ProviderEndpointF>>

impl<Row> Protocol for InternalChoice<Row>

where Row: ToRow + Send + 'static,

type ClientEndpoint = ReceiverOnce<AppSum<'static, <Row as ToRow>::Row, ClientEndpointF>>

type ProviderEndpoint = SenderOnce<AppSum<'static, <Row as ToRow>::Row, ClientEndpointF>>

impl<T, A> Protocol for ReceiveValue<T, A>

where T: Send + 'static, A: Protocol,

type ClientEndpoint = SenderOnce<(Value<T>, <A as Protocol>::ProviderEndpoint)>

type ProviderEndpoint = ReceiverOnce<(Value<T>, <A as Protocol>::ProviderEndpoint)>

impl<T, A> Protocol for SendValue<T, A>

where T: Send + 'static, A: Protocol,

type ClientEndpoint = ReceiverOnce<(Value<T>, <A as Protocol>::ClientEndpoint)>

type ProviderEndpoint = SenderOnce<(Value<T>, <A as Protocol>::ClientEndpoint)>

impl<T> Protocol for Wrap<T>

where T: Wrapper + Send + 'static,

type ClientEndpoint = ReceiverOnce<Wrap<T>>

type ProviderEndpoint = SenderOnce<Wrap<T>>