basu 0.1.7

Eventbus crate with sync and async features
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
69
70
71
72
73
74
75
76
77
78
79
80
81

# Basu
<p align="center">
  <img src=".github/basu.png" alt="basu">
</p>

[![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)
[![docs.rs](https://img.shields.io/badge/docs-docs.rs-green)](https://docs.rs/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

### Feature
- Sync:
    - To use sync Basu, make sure you disable `default-features` of the basu crate on `Cargo.toml`:
        ```toml
        [dependencies]
        basu = { version = "0.1", default-features = false, features = ["sync"] }
        ```

- Async:
    - To use async Basu in your Rust project, add the following line to `Cargo.toml`:
        ```toml
        [dependencies]
        basu = "0.1"
        ```

###  Usage:
To run the example, add the following line to `Cargo.toml`:
```toml
[dependencies]
tokio = { version = "1", default-features = false, features = [ "macros", "rt-multi-thread"] }
basu = "0.1"
```

Then, on your `main.rs`:
```rust
use basu::{async_trait, error::BasuError, event::Event, EventBus, Handle};

#[derive(Debug)]
struct Data {
    message: String,
}

struct MyEventHandler;

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

#[tokio::main]
async fn main() -> Result<(), BasuError> {
    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).await;

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

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

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