basu 0.1.1

Eventbus crate with sync and async features
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

# Basu
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/leonzchang/basu/blob/main/LICENSE)
[![crates.io](https://img.shields.io/crates/v/basu)](
https://crates.io/crates/basu)

A flexible event bus crate enables decoupling between different components of an application through the event-driven pattern.

Basu provides support for both asynchronous and synchronous event handling.

## Example

### Sync
Make sure you disable `default-features` of the basu crate on Cargo.toml:

```toml
[dependencies]
basu = { version = "0.1.0", default-features = false, features = ["sync"] }
```

### Async
To use Basu in your Rust project, add the following line to your `Cargo.toml` file:

```toml
[dependencies]
basu = "0.1.0"
```

###  Usage:
```rust
use basu::{BasuError, Event, EventBus, Handle};


struct MyEventHandler;

// Implement the Handle trait for your event handler structs
impl Handle<MyEvent> for MyEventHandler {
    async fn handle(&self, event: &Event<MyEvent>) -> Result<(), BasuError> {
        // Handle the event logic here
        Ok(())
    }
}

struct Data {
    message: String
}

#[tokio::main]
async fn main() {
    let event_bus = EventBus::new();

    let eveny_type = "my_event";
    // Subscribe to events by providing an event name and the corresponding event handler
    let handler = Box::new(MyEventHandler);
    let handler_id = event_bus.subscribe(eveny_type, handler)?;

    // Publish events
    let event = Event::new(Data {
        message: "hello".to_owned(),
    });
    event_bus.publish(eveny_type, &event)?;

    // Unsubscribe from events
    event_bus.unsubscribe(eveny_type, &handler_id)?;
}
```

## License
This project is licensed under the [MIT license](https://github.com/leonzchang/basu/blob/main/LICENSE).