[][src]Crate revent

Synchronous and recursive event system.


An event system is a collection of objects that can receive and send signals.

In revent we construct something called a Node containing an object of interest. This object can invoke objects in other nodes, which in turn can invoke other objects - including the originator - safely. This is done by suspending the &mut self to the contents of a node.


use revent::Node;

let number = Node::new(123);

number.emit(|n| {
    println!("{}", *n);
    *n = 100;
    println!("{}", *n);

See the documentation for Channel and Slot and Suspend for examples.


This library is intended to be used as a "suspendable RefCell" by a bunch of objects which wish to communicate with each other without using a central mediator object.

For instance, one can create a revent::Channel<dyn MyTrait> which contains objects of interest, where each object can inside its own handler do something along the lines of:

use revent::{Channel, Suspend};
trait MyTrait {
    fn function(&mut self, channel: &Channel<dyn MyTrait>);

struct MyObject;
impl MyTrait for MyObject {
    fn function(&mut self, channel: &Channel<dyn MyTrait>) {
        // Do something...
        self.suspend(|| {
            channel.emit(|x| {
        // Do something else...

The above allows the object to emit a signal on a channel it is part of, even calling itself recursively without mutably aliasing by suspending &mut self.



Container for multiple Nodes.


Node containing arbitrary data.


Container for a single optional Node.



Suspend an arbitrary reference from access.