trotcast 0.4.0

An mpmc broadcast impl
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

use core::{error::Error, fmt};

#[derive(Debug, Clone, PartialEq)]
pub enum TryRecvError {
    Empty,
    Disconnected,
}
impl fmt::Display for TryRecvError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TryRecvError::Disconnected => write!(f, "Channel Disconnected"),
            TryRecvError::Empty => write!(f, "Channel Empty"),
        }
    }
}

impl Error for TryRecvError {}

#[derive(Debug, Clone, PartialEq)]
pub enum RecvError {
    Disconnected,
}

impl fmt::Display for RecvError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RecvError::Disconnected => write!(f, "Channel Disconnected"),
        }
    }
}
impl Error for RecvError {}

#[derive(Clone, PartialEq)]
pub enum SendError<T> {
    Disconnected(T),
    Full(T),
}

impl<T> fmt::Display for SendError<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SendError::Disconnected(_) => write!(f, "Channel Disconnected"),
            SendError::Full(_) => write!(f, "Channel Full"),
        }
    }
}
impl<T> fmt::Debug for SendError<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SendError::Disconnected(_) => f.debug_struct("SendError::Disconnected").finish(),
            SendError::Full(_) => f.debug_struct("SendError::Full").finish(),
        }
    }
}

impl<T> Error for SendError<T> {}

#[derive(Clone, PartialEq)]
pub enum BlockingSendError<T> {
    Disconnected(T),
}

impl<T> fmt::Debug for BlockingSendError<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            BlockingSendError::Disconnected(_) => {
                f.debug_struct("BlockingSendError::Disconnected").finish()
            }
        }
    }
}

impl<T> fmt::Display for BlockingSendError<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            BlockingSendError::Disconnected(_) => write!(f, "Channel Disconnected"),
        }
    }
}

impl<T> Error for BlockingSendError<T> {}

pub enum InnerRecvError {
    Disconnected,
    Empty,
}