storyteller 0.7.0

Library focused on supporting user oriented output while supporting multiple output types (e.g. json, a progressbar, etc.)
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

use crate::{EventReporter, EventSender};
use std::error;
use std::fmt::{Debug, Display, Formatter};

/// A specialized type of reporter which uses a channel to transmit messages.
///
/// Use [`EventReporter::disconnect`] to disconnect the channel by dropping the `sender`.
/// If you want to finish up processing unprocessed events, you may do so by calling
/// the blocking [`FinishProcessing::finish_processing`].
///
/// The channel sender (and channel receiver for the `listener`), required to create a
/// `ChannelReporter` instance can be created by calling the [`event_channel()`]
/// function.
///
/// The [`EventListener`] associated with this reporter is the [`ChannelEventListener`].
///
/// [`EventReporter::disconnect`]: crate::EventReporter::disconnect
/// [`FinishProcessing::finish_processing`]: crate::FinishProcessing::finish_processing
/// [`event_channel()`]: crate::event_channel()
/// [`EventListener`]: crate::EventListener
/// [`ChannelEventListener`]: crate::ChannelEventListener
pub struct ChannelReporter<Event> {
    event_sender: EventSender<Event>,
}

impl<Event> ChannelReporter<Event> {
    /// Setup a reporter which uses a channel.
    ///
    /// The channel required to create an instance can be created by calling the [`crate::event_channel`]
    /// function.
    pub fn new(event_sender: EventSender<Event>) -> Self {
        Self { event_sender }
    }
}

impl<Event> EventReporter for ChannelReporter<Event> {
    type Event = Event;
    type Err = EventReporterError<Event>;

    fn report_event(&self, event: impl Into<Self::Event>) -> Result<(), Self::Err> {
        self.event_sender
            .send(event.into())
            .map_err(EventReporterError::SendError)
    }

    /// Disconnect the sender.
    #[allow(clippy::unit_arg)]
    fn disconnect(self) -> Result<(), Self::Err> {
        Ok(self.event_sender.disconnect())
    }
}

pub enum EventReporterError<Event> {
    SendError(crate::EventSendError<Event>),
}

impl<Event> Debug for EventReporterError<Event> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::SendError(_) => f.write_fmt(format_args!(
                "SendError(EventSendError({}))",
                std::any::type_name::<Event>()
            )),
        }
    }
}

impl<Event> Display for EventReporterError<Event>
where
    Event: Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::SendError(crate::EventSendError(ev)) => f.write_fmt(format_args!(
                "SendError(EventSendError({} = '{}'))",
                std::any::type_name::<Event>(),
                ev
            )),
        }
    }
}

impl<Event> error::Error for EventReporterError<Event> where Event: Display {}