Struct TracingHandler 

pub struct TracingHandler<H> { /* private fields */ }

A tracing wrapper for choreographic handlers.

Implementations

impl<H> TracingHandler<H>

pub fn new(inner: H, protocol: &'static str, role: H::Role) -> Self

where H: ChoreoHandler,

Create a new tracing handler.

pub fn indexed( inner: H, protocol: &'static str, role: RoleName, index: u32, ) -> Self

Create a new tracing handler for an indexed role.

pub fn protocol(&self) -> &'static str

Get the protocol name.

pub fn role(&self) -> &RoleName

Get the role name.

pub fn role_index(&self) -> Option<u32>

Get the role index (if any).

pub fn inner(&self) -> &H

Get a reference to the inner handler.

pub fn inner_mut(&mut self) -> &mut H

Get a mutable reference to the inner handler.

pub fn into_inner(self) -> H

Unwrap and return the inner handler.

Trait Implementations

impl<H: ChoreoHandler> ChoreoHandler for TracingHandler<H>

type Role = <H as ChoreoHandler>::Role

The role type for this choreography

type Endpoint = <H as ChoreoHandler>::Endpoint

The endpoint type maintaining connection state

fn send<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, to: Self::Role, msg: &'life2 M, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send a message to a specific role

fn recv<'life0, 'life1, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, from: Self::Role, ) -> Pin<Box<dyn Future<Output = ChoreoResult<M>> + Send + 'async_trait>>

where M: 'async_trait + DeserializeOwned + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Receive a strongly-typed message from a specific role

fn choose<'life0, 'life1, 'async_trait>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, to: Self::Role, label: <Self::Role as RoleId>::Label, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Internal choice: broadcast a label selection

fn offer<'life0, 'life1, 'async_trait>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, from: Self::Role, ) -> Pin<Box<dyn Future<Output = ChoreoResult<<Self::Role as RoleId>::Label>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

External choice: receive a label selection

fn with_timeout<'life0, 'life1, 'async_trait, F, T>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, at: Self::Role, dur: Duration, body: F, ) -> Pin<Box<dyn Future<Output = ChoreoResult<T>> + Send + 'async_trait>>

where F: Future<Output = ChoreoResult<T>> + Send + 'async_trait, T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a future with a timeout

fn broadcast<'life0, 'life1, 'life2, 'life3, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, recipients: &'life2 [Self::Role], msg: &'life3 M, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Broadcast a message to multiple recipients

fn parallel_send<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, sends: &'life2 [(Self::Role, M)], ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send messages to multiple recipients in parallel