climer 0.7.1

CLI timer app
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
134
135

use super::Output;
use super::Timer;
use crate::error::ClimerResult;
#[cfg(feature = "parser")]
use crate::time::parser::parse_time;
use crate::time::Time;

/// The builder struct for `Timer`.
#[derive(Default)]
pub struct TimerBuilder {
    time: Option<Time>,
    #[cfg(feature = "parser")]
    time_str: Option<String>,
    start_time: Option<Time>,
    quiet: bool,
    format: Option<String>,
    output_format: Option<String>,
    print_interval: Option<Time>,
    write: Option<String>,
    continue_after_finish: bool,
}

impl TimerBuilder {
    /// Set the `time` as a `Time`.
    pub fn time(mut self, time: Time) -> Self {
        self.time = Some(time);
        self
    }

    /// Set the `time` as a string.
    #[cfg(feature = "parser")]
    pub fn time_str<T>(mut self, time_str: T) -> Self
    where
        T: ToString,
    {
        self.time_str = Some(time_str.to_string());
        self
    }

    /// Set the `start_time` `Time`.
    pub fn start_time(mut self, start_time: Time) -> Self {
        self.start_time = Some(start_time);
        self
    }

    /// Set the `quiet` flag, used for printing to stdout.
    pub fn quiet(mut self, quiet: bool) -> Self {
        self.quiet = quiet;
        self
    }

    /// TODO: Unimplemented
    /// Set the `format` string, used for parsing the given time string.
    pub fn format<T>(mut self, format: T) -> Self
    where
        T: ToString,
    {
        self.format = Some(format.to_string());
        self
    }

    /// Set the interval in which output should be printed to stdout.
    pub fn print_interval(mut self, print_interval: Time) -> Self {
        self.print_interval = Some(print_interval);
        self
    }

    /// Set a file for the output to be written to, instead of stdout.
    pub fn write<T>(mut self, write: T) -> Self
    where
        T: ToString,
    {
        self.write = Some(write.to_string());
        self
    }

    /// Specify if timer should continue timing into negative time after it finishes.
    pub fn continue_after_finish(
        mut self,
        continue_after_finish: bool,
    ) -> Self {
        self.continue_after_finish = continue_after_finish;
        self
    }

    /// Build a `Timer`.
    pub fn build(mut self) -> ClimerResult<Timer> {
        let time = self.build_time()?;

        let start_time = self.start_time;
        let continue_after_finish = self.continue_after_finish;

        let output = self.build_output();
        let mut timer = Timer::new(time, output);

        if let Some(start_time) = start_time {
            timer.set_start_time(start_time);
        }

        timer.set_continue_after_finish(continue_after_finish);

        Ok(timer)
    }

    fn build_time(&mut self) -> ClimerResult<Option<Time>> {
        Ok(self.time.take().or(self.time_from_str()?))
    }

    #[cfg(feature = "parser")]
    fn time_from_str(&self) -> ClimerResult<Option<Time>> {
        if let Some(time_str) = self.time_str.as_ref() {
            Ok(Some(parse_time(time_str, self.format.as_ref())?))
        } else {
            Ok(None)
        }
    }

    #[cfg(not(feature = "parser"))]
    fn time_from_str(&self) -> ClimerResult<Option<Time>> {
        Ok(None)
    }

    /// Build the `Output` used by the `Timer`.
    fn build_output(self) -> Option<Output> {
        if self.quiet {
            None
        } else {
            Some(Output::new(
                self.output_format,
                self.print_interval,
                self.write,
            ))
        }
    }
}