Trait cut::Protocol

pub trait Protocol: 'static + SealedProtocol + Send {
    type ProviderEndpoint: 'static + Send;
    type ClientEndpoint: 'static + Send;
    fn create_endpoints() -> (Self::ProviderEndpoint, Self::ClientEndpoint);
    fn forward(
        client_end: Self::ClientEndpoint, 
        provider_end: Self::ProviderEndpoint
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>;
}

Associated Types

type ProviderEndpoint: 'static + Send

type ClientEndpoint: 'static + Send

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, Global>>

Implementations on Foreign Types

impl<F> Protocol for Lock<F> where
    F: Protocol + SharedRecApp<SharedToLinear<LinearToShared<F>>>,
    <F as SharedRecApp<SharedToLinear<LinearToShared<F>>>>::Applied: Protocol, 

type ClientEndpoint = ReceiverOnce<Lock<F>>

type ProviderEndpoint = SenderOnce<Lock<F>>

fn create_endpoints(
) -> (<Lock<F> as Protocol>::ProviderEndpoint, <Lock<F> as Protocol>::ClientEndpoint)

fn forward(
    client_end: <Lock<F> as Protocol>::ClientEndpoint,
    provider_end: <Lock<F> as Protocol>::ProviderEndpoint
) -> Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>

Implementors

impl Protocol for Release

type ClientEndpoint = ()

type ProviderEndpoint = ()

impl Protocol for End

type ClientEndpoint = ReceiverOnce<()>

type ProviderEndpoint = SenderOnce<()>

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: 'static + Send,
    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 SharedToLinear<LinearToShared<F>> where
    F: 'static + Send + 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: 'static + ToRow + Send, 

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: 'static + ToRow + Send, 

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

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

impl<T> Protocol for Wrap<T> where
    T: Wrapper + 'static + Send, 

type ClientEndpoint = ReceiverOnce<Wrap<T>>

type ProviderEndpoint = SenderOnce<Wrap<T>>

impl<T, A> Protocol for ReceiveValue<T, A> where
    T: 'static + Send,
    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: 'static + Send,
    A: Protocol, 

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

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