kincir 0.2.0

A Rust message streaming library inspired by Watermill
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

use thiserror::Error;

/// Errors that can occur during in-memory broker operations
#[derive(Debug, Error, Clone)]
pub enum InMemoryError {
    #[error("Topic not found: {topic}")]
    TopicNotFound { topic: String },
    
    #[error("Queue full for topic: {topic}")]
    QueueFull { topic: String },
    
    #[error("Not subscribed to any topic")]
    NotSubscribed,
    
    #[error("Broker shutdown")]
    BrokerShutdown,
    
    #[error("Maximum number of topics reached: {max}")]
    MaxTopicsReached { max: usize },
    
    #[error("Invalid topic name: {topic}")]
    InvalidTopicName { topic: String },
    
    #[error("Subscriber already exists for topic: {topic}")]
    SubscriberAlreadyExists { topic: String },
    
    #[error("Channel send error: {message}")]
    ChannelSendError { message: String },
    
    #[error("Channel receive error: {message}")]
    ChannelReceiveError { message: String },
}

impl InMemoryError {
    pub fn topic_not_found(topic: impl Into<String>) -> Self {
        Self::TopicNotFound { topic: topic.into() }
    }
    
    pub fn queue_full(topic: impl Into<String>) -> Self {
        Self::QueueFull { topic: topic.into() }
    }
    
    pub fn max_topics_reached(max: usize) -> Self {
        Self::MaxTopicsReached { max }
    }
    
    pub fn invalid_topic_name(topic: impl Into<String>) -> Self {
        Self::InvalidTopicName { topic: topic.into() }
    }
    
    pub fn subscriber_already_exists(topic: impl Into<String>) -> Self {
        Self::SubscriberAlreadyExists { topic: topic.into() }
    }
    
    pub fn channel_send_error(message: impl Into<String>) -> Self {
        Self::ChannelSendError { message: message.into() }
    }
    
    pub fn channel_receive_error(message: impl Into<String>) -> Self {
        Self::ChannelReceiveError { message: message.into() }
    }
}

// Implement Send + Sync for error handling in async contexts
unsafe impl Send for InMemoryError {}
unsafe impl Sync for InMemoryError {}