async_pub_sub 0.2.1

A library aiming at making async pub-sub easier in Rust
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::pin::Pin;
use std::ops::{Deref, DerefMut};
use futures::{Stream, future::BoxFuture};

use crate::Result;

/// A trait for types that can publish messages to subscribers.
///
/// This trait defines the core functionality for a publisher in a publisher-subscriber pattern.
pub trait Publisher {
    /// The type of messages that this publisher can send.
    /// Must implement Send and have a static lifetime.
    type Message: Send + 'static;

    /// Returns the name of the publisher.
    ///
    /// # Returns
    /// A string slice containing the publisher's name.
    fn get_name(&self) -> &'static str;

    /// Publishes a message to all subscribers.
    ///
    /// # Arguments
    /// * `message` - The message to publish
    ///
    /// # Returns
    /// A future that resolves to a Result indicating success or failure of the publish operation.
    fn publish(&self, message: Self::Message) -> BoxFuture<Result<()>>;

    /// Creates a new message stream for a subscriber.
    ///
    /// # Arguments
    /// * `subscriber_name` - The name of the subscriber requesting the stream
    ///
    /// # Returns
    /// A Result containing a pinned box with the message stream if successful.
    fn get_message_stream(
        &mut self,
        subscriber_name: &'static str,
    ) -> Result<Pin<Box<dyn Stream<Item = Self::Message> + Send + Sync + 'static>>>;
}

// Add blanket implementation for types that can be dereferenced into a Publisher
impl<T> Publisher for T 
where 
    T: Deref + DerefMut,
    T::Target: Publisher,
{
    type Message = <T::Target as Publisher>::Message;

    fn get_name(&self) -> &'static str {
        self.deref().get_name()
    }

    fn publish(&self, message: Self::Message) -> BoxFuture<Result<()>> {
        self.deref().publish(message)
    }

    fn get_message_stream(
        &mut self,
        subscriber_name: &'static str,
    ) -> Result<Pin<Box<dyn Stream<Item = Self::Message> + Send + Sync + 'static>>> {
        self.deref_mut().get_message_stream(subscriber_name)
    }
}

/// A trait for types that wrap a publisher.
///
/// This trait provides a default implementation for publisher operations
/// by delegating to an internal publisher instance.
pub trait PublisherWrapper<Message>
where
    Message: Send + 'static,
{
    /// Gets a reference to the wrapped publisher.
    ///
    /// # Returns
    /// A reference to the wrapped publisher implementation.
    fn get_publisher(&self) -> &dyn Publisher<Message = Message>;

    /// Gets a mutable reference to the wrapped publisher.
    ///
    /// # Returns
    /// A mutable reference to the wrapped publisher implementation.
    fn get_publisher_mut(&mut self) -> &mut dyn Publisher<Message = Message>;

    /// Returns the name of the wrapped publisher.
    ///
    /// # Returns
    /// A static string slice containing the publisher's name.
    fn get_name(&self) -> &'static str {
        Publisher::get_name(self.get_publisher())
    }

    /// Publishes a message using the wrapped publisher.
    ///
    /// # Arguments
    /// * `message` - The message to publish
    ///
    /// # Returns
    /// A future that resolves to a Result indicating success or failure of the publish operation.
    fn publish(&self, message: Message) -> futures::future::BoxFuture<Result<()>> {
        Publisher::publish(self.get_publisher(), message)
    }

    /// Creates a new message stream using the wrapped publisher.
    ///
    /// # Arguments
    /// * `subscriber_name` - The name of the subscriber requesting the stream
    ///
    /// # Returns
    /// A Result containing a pinned box with the message stream if successful.
    fn get_message_stream(
        &mut self,
        subscriber_name: &'static str,
    ) -> Result<std::pin::Pin<Box<dyn futures::Stream<Item = Message> + Send + Sync + 'static>>>
    {
        Publisher::get_message_stream(self.get_publisher_mut(), subscriber_name)
    }
}

impl<T> PublisherWrapper<T::Message> for T
where
    T: Publisher,
{
    fn get_publisher(&self) -> &dyn Publisher<Message = T::Message> {
        self
    }

    fn get_publisher_mut(&mut self) -> &mut dyn Publisher<Message = T::Message> {
        self
    }
}