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
//! # simple_event_map //! //! This allows you to register types that'll be broadcast to receivers //! //! ## An example //! ```rust //! # use simple_event_map::{EventMap, EventStream}; //! # use futures_lite::StreamExt as _; //! # futures_lite::future::block_on(async move { //! #[derive(Clone, Debug, PartialEq)] //! struct Message { data: String } //! //! let mut map = EventMap::new(); //! // nothing is registered by default //! assert_eq!(map.is_empty::<i32>(), true); //! assert_eq!(map.is_empty::<String>(), true); //! assert_eq!(map.is_empty::<Message>(), true); //! //! // register two subscriptions for the message //! // you can get a blocking iterator //! let mut m1 = map.register_iter::<Message>(); //! // or you can get an async stream //! let mut m2 = map.register_stream::<Message>(); //! //! let msg = Message{ data: String::from("hello world") }; //! // send the message, will return a bool if any messages were sent //! assert_eq!(map.send(msg.clone()), true); //! // we should have 2 still active //! assert_eq!(map.active::<Message>(), 2); //! //! assert_eq!(m1.next().unwrap(), msg); //! // m2 is a stream, so we have to await it (and use StreamExt::next) //! assert_eq!(m2.next().await.unwrap(), msg); //! //! // drop a subscription (will be cleaned up in the eventmap on next send) //! drop(m1); //! //! let msg = Message{ data: String::from("testing") }; //! assert_eq!(map.send(msg.clone()), true); //! // we only have 1 active now //! assert_eq!(map.active::<Message>(), 1); //! # }); //! ``` mod channel; pub use channel::Sender; mod stream; pub use stream::EventStream; mod iter; pub use iter::EventIter; mod event_map; pub use event_map::{EventMap, Senders};