Struct mpstthree::meshedchannels::MeshedChannels

pub struct MeshedChannels<S1, S2, R, N> where
    S1: Session,
    S2: Session,
    R: Role,
    N: Role,  {
    pub session1: S1,
    pub session2: S2,
    pub stack: R,
    pub name: N,
}

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

Example

use mpstthree::binary::struct_trait::{End, Recv, Send, Session};

use mpstthree::meshedchannels::MeshedChannels;

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

Fields

session1: S1

session2: S2

stack: R

name: N

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

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

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

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleAlltoB<RoleEnd, RoleEnd>, RoleA<RoleEnd>>

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleAlltoC<RoleEnd, RoleEnd>, RoleA<RoleEnd>>

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

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

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

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

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

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

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

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

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

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

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleAlltoA<RoleEnd, RoleEnd>, RoleB<RoleEnd>>

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleAlltoC<RoleEnd, RoleEnd>, RoleB<RoleEnd>>

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

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

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

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

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

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

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

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

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

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

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<Recv<T, S1>, S2, RoleAlltoA<RoleEnd, RoleEnd>, RoleC<RoleEnd>>

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

impl<S1: Session, S2: Session, T: Send> MeshedChannels<S1, Recv<T, S2>, RoleAlltoB<RoleEnd, RoleEnd>, RoleC<RoleEnd>>

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

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

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

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

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

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

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

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.