Struct PingStream 

pub struct PingStream {
    pub ping_count: u64,
    pub pong_count: u64,
    /* private fields */
}

An actor that continuously sends PingMsg to a target over the network. Target should be a PongerAct.

Fields

ping_count: u64

Sent Ping messages

pong_count: u64

Received Pong messages

Implementations

impl PingStream

pub fn new(target: ActorPath, period: Duration) -> Self

creates a PingStream actor that sends PingMsg to target every period Target should be a PongerAct.

pub fn start_pinging(&mut self)

method to start pinging

pub fn stop_pinging(&mut self)

method to stop pinging

Trait Implementations

impl Actor for PingStream

type Message = !

The type of local messages the actor accepts

fn receive_local(&mut self, _: Self::Message) -> HandlerResult

Handle an incoming local message

fn receive_network(&mut self, msg: NetMessage) -> HandlerResult

Handle an incoming network message

impl ComponentDefinition for PingStream

fn setup(&mut self, self_component: Arc<Component<Self>>)

Prepare the component for being run

fn execute(&mut self, _max_events: usize, _skip: usize) -> ExecuteResult

Execute events on the component’s ports

fn ctx_mut(&mut self) -> &mut ComponentContext<Self>

Return a mutable reference the component’s context field

fn ctx(&self) -> &ComponentContext<Self>

Return a reference the component’s context field

fn type_name() -> &'static str

Return the name of the component’s type

fn spawn_local<F>( &mut self, f: impl FnOnce(ComponentDefinitionAccess<Self>) -> F, )

where Self: 'static, F: Future<Output = Result<Handled, HandlerError>> + Send + 'static,

Run a Future on this component, allowing it mutable access to the component’s internal state on every poll.

fn spawn_off<R>( &self, future: impl Future<Output = R> + Send + 'static, ) -> Receiver<R>

where R: Send + 'static,

Run a Future on this system’s executor pool and return a handle to the result

impl ComponentLifecycle for PingStream

fn on_start(&mut self) -> HandlerResult

Gets invoked every time a component receives a Start event

fn on_stop(&mut self) -> Result<Handled, HandlerError>

where Self: 'static,

Gets invoked every time a component receives a Stop event

fn on_kill(&mut self) -> Result<Handled, HandlerError>

where Self: 'static,

Gets invoked every time a component receives a Kill event

impl DynamicPortAccess for PingStream

fn get_provided_port_as_any(&mut self, port_id: TypeId) -> Option<&mut dyn Any>

Internal API. Dynamically obtain a mutable reference to a ProvidedPort if self provides a port of the type indicated by the passed port_id.

fn get_required_port_as_any(&mut self, port_id: TypeId) -> Option<&mut dyn Any>

Internal API. Dynamically obtain a mutable reference to a RequiredPort if self requires a port of the type indicated by the passed port_id.