Trait ferrite_session::prelude::Protocol

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

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

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::ClientEndpoint>, B::ClientEndpoint)

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

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

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

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

impl<C, F> Protocol for RecX<C, F> where
    C: Send + 'static,
    F: Protocol,
    F: 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: Send + 'static,
    F: SharedRecApp<SharedToLinear<LinearToShared<F>>>, 

type ClientEndpoint = SenderOnce<()>

type ProviderEndpoint = ReceiverOnce<()>

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

type ClientEndpoint = ReceiverOnce<Lock<F>>

type ProviderEndpoint = SenderOnce<Lock<F>>

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::Row, ProviderEndpointF>>

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

impl<Row> Protocol for InternalChoice<Row> where
    Row: ToRow + Send + 'static, 

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

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

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

type ClientEndpoint = ReceiverOnce<Wrap<T>>

type ProviderEndpoint = SenderOnce<Wrap<T>>

impl<T, A> Protocol for ReceiveValue<T, A> where
    T: Send + 'static,
    A: Protocol, 

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

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

impl<T, A> Protocol for SendValue<T, A> where
    T: Send + 'static,
    A: Protocol, 

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

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