Struct mpstthree::meshedchannels::MeshedChannels

pub struct MeshedChannels<S1, S2, R, N>
where
    S1: Session,
    S2: Session,
    R: Role,
    N: Name,
{ /* private fields */ }

The structure which encapsulates two binary session types, a stack and a name.

Arguments

• The first binary session. It must be filled with Send and/or Recv and end with End.

• The second binary session. It must be filled with Send and/or Recv and end with End.

• The stack of the MeshedChannels. It must be filled with a role, such as RoleA or RoleBtoAll and end with RoleEnd.

• The name of the role of the MeshedChannels. It must be one among: RoleA, RoleB or RoleC.

Example

use mpstthree::binary::struct_trait::{end::End, recv::Recv, send::Send, session::Session};

use mpstthree::meshedchannels::MeshedChannels;

use mpstthree::role::b::RoleB;
use mpstthree::role::c::RoleC;
use mpstthree::role::end::RoleEnd;

use mpstthree::name::a::NameA;

// Creating the binary sessions
type AtoB<N> = Send<N, End>;
type AtoC<N> = Recv<N, End>;

// Stacks
type StackA = RoleB<RoleC<RoleEnd>>;

// Creating the MP sessions
type EndpointA<N> = MeshedChannels<AtoB<N>, AtoC<N>, StackA, NameA>;

let _ = EndpointA::<i32>::new(); // Only used for example

Implementations

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Send<T, S1>, S2, RoleB<R>, NameA>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameA>

Send a payload of type T to role B

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Send<T, S2>, RoleC<R>, NameA>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameA>

Send a payload of type T to role C

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleB<R>, NameA>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameA>), Box<dyn Error>>

Receive a payload from role B

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleC<R>, NameA>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameA>), Box<dyn Error>>

Receive a payload from role C

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<OfferMpst<S1, S2, S3, S4, R1, R2, NameA>, End, RoleAlltoB<RoleEnd, RoleEnd>, NameA>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameA>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameA>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role B. Be careful: the left and right stacks must be the same.

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<End, OfferMpst<S1, S2, S3, S4, R1, R2, NameA>, RoleAlltoC<RoleEnd, RoleEnd>, NameA>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameA>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameA>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role C. Be careful: the left and right stacks must be the same.

impl<S0: Session, S1: Session, S2: Session, S3: Session, S4: Session, S5: Session, R0: Role, R1: Role, R2: Role, R3: Role, R4: Role, R5: Role> MeshedChannels<Send<Either<MeshedChannels<S2, <S0 as Session>::Dual, R0, NameB>, MeshedChannels<S4, <S1 as Session>::Dual, R1, NameB>>, End>, Send<Either<MeshedChannels<S3, S0, R2, NameC>, MeshedChannels<S5, S1, R3, NameC>>, End>, RoleAtoAll<R4, R5>, NameA>

pub fn choose_left( self ) -> MeshedChannels<<S2 as Session>::Dual, <S3 as Session>::Dual, R4, NameA>

Choose the left branch of a binary choice and send it to B and C

pub fn choose_right( self ) -> MeshedChannels<<S4 as Session>::Dual, <S5 as Session>::Dual, R5, NameA>

Choose the right branch of a binary choice and send it to B and C

impl MeshedChannels<End, End, RoleEnd, NameA>

pub fn close(self) -> Result<(), Box<dyn Error>>

Close the current connection

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Send<T, S1>, S2, RoleA<R>, NameB>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameB>

Send a payload of type T to role A

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Send<T, S2>, RoleC<R>, NameB>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameB>

Send a payload of type T to role C

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleA<R>, NameB>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameB>), Box<dyn Error>>

Receive a payload from role A

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleC<R>, NameB>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameB>), Box<dyn Error>>

Receive a payload from role C

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<OfferMpst<S1, S2, S3, S4, R1, R2, NameB>, End, RoleAlltoA<RoleEnd, RoleEnd>, NameB>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameB>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameB>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role A. Be careful: the left and right stacks must be the same.

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<End, OfferMpst<S1, S2, S3, S4, R1, R2, NameB>, RoleAlltoC<RoleEnd, RoleEnd>, NameB>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameB>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameB>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role C. Be careful: the left and right stacks must be the same.

impl<S0: Session, S1: Session, S2: Session, S3: Session, S4: Session, S5: Session, R0: Role, R1: Role, R2: Role, R3: Role, R4: Role, R5: Role> MeshedChannels<Send<Either<MeshedChannels<S2, <S0 as Session>::Dual, R0, NameA>, MeshedChannels<S4, <S1 as Session>::Dual, R1, NameA>>, End>, Send<Either<MeshedChannels<S0, S3, R2, NameC>, MeshedChannels<S1, S5, R3, NameC>>, End>, RoleBtoAll<R4, R5>, NameB>

pub fn choose_left( self ) -> MeshedChannels<<S2 as Session>::Dual, <S3 as Session>::Dual, R4, NameB>

Choose the right branch of a binary choice and send it to A and C

pub fn choose_right( self ) -> MeshedChannels<<S4 as Session>::Dual, <S5 as Session>::Dual, R5, NameB>

Choose the left branch of a binary choice and send it to A and C

impl MeshedChannels<End, End, RoleEnd, NameB>

pub fn close(self) -> Result<(), Box<dyn Error>>

Close the current connection

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Send<T, S1>, S2, RoleA<R>, NameC>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameC>

Send a payload of type T to role A

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Send<T, S2>, RoleB<R>, NameC>

pub fn send(self, payload: T) -> MeshedChannels<S1, S2, R, NameC>

Send a payload of type T to role B

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleA<R>, NameC>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameC>), Box<dyn Error>>

Receive a payload from role A

impl<S1: Session, S2: Session, R: Role, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleB<R>, NameC>

pub fn recv( self ) -> Result<(T, MeshedChannels<S1, S2, R, NameC>), Box<dyn Error>>

Receive a payload from role B

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<OfferMpst<S1, S2, S3, S4, R1, R2, NameC>, End, RoleAlltoA<RoleEnd, RoleEnd>, NameC>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameC>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameC>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role A. Be careful: the left and right stacks must be the same.

impl<'a, S1: Session, S2: Session, S3: Session, S4: Session, R1: Role, R2: Role> MeshedChannels<End, OfferMpst<S1, S2, S3, S4, R1, R2, NameC>, RoleAlltoB<RoleEnd, RoleEnd>, NameC>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>>

where F: FnOnce(MeshedChannels<S1, S2, R1, NameC>) -> Result<U, Box<dyn Error + 'a>>, G: FnOnce(MeshedChannels<S3, S4, R2, NameC>) -> Result<U, Box<dyn Error + 'a>>,

Receive a binary choice from role B. Be careful: the left and right stacks must be the same.

impl<S0: Session, S1: Session, S2: Session, S3: Session, S4: Session, S5: Session, R0: Role, R1: Role, R2: Role, R3: Role, R4: Role, R5: Role> MeshedChannels<Send<Either<MeshedChannels<<S0 as Session>::Dual, S2, R0, NameA>, MeshedChannels<<S1 as Session>::Dual, S4, R1, NameA>>, End>, Send<Either<MeshedChannels<S0, S3, R2, NameB>, MeshedChannels<S1, S5, R3, NameB>>, End>, RoleCtoAll<R4, R5>, NameC>

pub fn choose_left( self ) -> MeshedChannels<<S2 as Session>::Dual, <S3 as Session>::Dual, R4, NameC>

Choose the left branch of a binary choice and send it to A and B

pub fn choose_right( self ) -> MeshedChannels<<S4 as Session>::Dual, <S5 as Session>::Dual, R5, NameC>

Choose the right branch of a binary choice and send it to A and B

impl MeshedChannels<End, End, RoleEnd, NameC>

pub fn close(self) -> Result<(), Box<dyn Error>>

Close the current connection

impl<S1: Session, S2: Session, R: Role, N: Name> MeshedChannels<S1, S2, R, N>

pub fn cancel(self)

Cancel the session

Trait Implementations

impl<S1, S2, R, N> Debug for MeshedChannels<S1, S2, R, N>

where S1: Session + Debug, S2: Session + Debug, R: Role + Debug, N: Name + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S1: Session, S2: Session, R: Role, N: Name> Session for MeshedChannels<S1, S2, R, N>

type Dual = MeshedChannels<<S1 as Session>::Dual, <S2 as Session>::Dual, <R as Role>::Dual, N>

The session type dual to Self.