Struct mpstthree::meshedchannels::MeshedChannels

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

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

use mpstthree::meshedchannels::MeshedChannels;

use mpstthree::binary::struct_trait::session::Session; // Only used for example
use mpstthree::role::a::RoleA;
use mpstthree::role::b::RoleB;
use mpstthree::role::c::RoleC;
use mpstthree::role::end::RoleEnd;

// 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, RoleA<RoleEnd>>;

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>, RoleA<RoleEnd>>

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

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>, RoleA<RoleEnd>>

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

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>, RoleA<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleA<RoleEnd>>), 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>, RoleA<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleA<RoleEnd>>), 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, RoleA<RoleEnd>>, End, RoleAlltoB<RoleEnd, RoleEnd>, RoleA<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleA<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleA<RoleEnd>>) -> 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, RoleA<RoleEnd>>, RoleAlltoC<RoleEnd, RoleEnd>, RoleA<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleA<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleA<RoleEnd>>) -> 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, RoleB<RoleEnd>>, MeshedChannels<S4, <S1 as Session>::Dual, R1, RoleB<RoleEnd>>>, End>, Send<Either<MeshedChannels<S3, S0, R2, RoleC<RoleEnd>>, MeshedChannels<S5, S1, R3, RoleC<RoleEnd>>>, End>, RoleAtoAll<R4, R5>, RoleA<RoleEnd>>

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

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, RoleA<RoleEnd>>

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

impl MeshedChannels<End, End, RoleEnd, RoleA<RoleEnd>>

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>, RoleB<RoleEnd>>

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

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>, RoleB<RoleEnd>>

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

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>, RoleB<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleB<RoleEnd>>), 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>, RoleB<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleB<RoleEnd>>), 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, RoleB<RoleEnd>>, End, RoleAlltoA<RoleEnd, RoleEnd>, RoleB<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleB<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleB<RoleEnd>>) -> 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, RoleB<RoleEnd>>, RoleAlltoC<RoleEnd, RoleEnd>, RoleB<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleB<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleB<RoleEnd>>) -> 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, RoleA<RoleEnd>>, MeshedChannels<S4, <S1 as Session>::Dual, R1, RoleA<RoleEnd>>>, End>, Send<Either<MeshedChannels<S0, S3, R2, RoleC<RoleEnd>>, MeshedChannels<S1, S5, R3, RoleC<RoleEnd>>>, End>, RoleBtoAll<R4, R5>, RoleB<RoleEnd>>

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

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, RoleB<RoleEnd>>

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

impl MeshedChannels<End, End, RoleEnd, RoleB<RoleEnd>>

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>, RoleC<RoleEnd>>

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

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>, RoleC<RoleEnd>>

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

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>, RoleC<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleC<RoleEnd>>), 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>, RoleC<RoleEnd>>

pub fn recv(
    self
) -> Result<(T, MeshedChannels<S1, S2, R, RoleC<RoleEnd>>), 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, RoleC<RoleEnd>>, End, RoleAlltoA<RoleEnd, RoleEnd>, RoleC<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleC<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleC<RoleEnd>>) -> 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, RoleC<RoleEnd>>, RoleAlltoB<RoleEnd, RoleEnd>, RoleC<RoleEnd>>

pub fn offer<F, G, U>(self, f: F, g: G) -> Result<U, Box<dyn Error + 'a>> where
    F: FnOnce(MeshedChannels<S1, S2, R1, RoleC<RoleEnd>>) -> Result<U, Box<dyn Error + 'a>>,
    G: FnOnce(MeshedChannels<S3, S4, R2, RoleC<RoleEnd>>) -> 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, RoleA<RoleEnd>>, MeshedChannels<<S1 as Session>::Dual, S4, R1, RoleA<RoleEnd>>>, End>, Send<Either<MeshedChannels<S0, S3, R2, RoleB<RoleEnd>>, MeshedChannels<S1, S5, R3, RoleB<RoleEnd>>>, End>, RoleCtoAll<R4, R5>, RoleC<RoleEnd>>

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

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, RoleC<RoleEnd>>

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

impl MeshedChannels<End, End, RoleEnd, RoleC<RoleEnd>>

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

Close the current connection

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

pub fn cancel(self)

Cancel the session

Trait Implementations

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

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

Formats the value using the given formatter.