libutils 5.26.14

Common library types for faster development
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

//^
//^ HEAD
//^

//> HEAD -> MODULES
mod issue;
mod note;
mod shortcut;
mod toissue;

//> HEAD -> STD
use std::{
    process::{
        ExitCode, 
        Termination
    }, 
    time::Instant
};

//> HEAD -> TOISSUE
pub use toissue::ToIssue;

//> HEAD -> ISSUE
pub use issue::Issue;

//> HEAD -> CRATE
use crate::terminal::{
    TERMINAL,
    Problem
};

//> HEAD -> SHORTCUT
use shortcut::Attachment;

//> HEAD -> NOTE
pub use note::Note;


//^
//^ REPORT
//^

//> REPORT -> STRUCT
pub struct Report<Object: ToIssue> {
    name: &'static str = "",
    problems: Vec<Problem<Object>> = Vec::new()
}

//> REPORT -> IMPLEMENTATION
impl<Object: ToIssue> Report<Object> {
    #[inline]
    pub fn new(name: &'static str) -> Self {return Self {
        name: name,
        ..
    }}
    #[inline]
    pub fn warn(&mut self, object: Object) -> () {
        let problem = Problem {
            chain: Vec::from([self.name]),
            at: Instant::now(),
            object: object
        };
        TERMINAL.write().error(&problem);
        self.problems.push(problem);
    }
    #[inline]
    pub unsafe fn abort<Type>(self) -> Act<Type, Object> {return Act {
        problems: self.problems,
        result: None
    }}
    #[inline]
    pub fn fail<Type>(mut self, with: Object) -> Act<Type, Object> {
        let problem = Problem {
            chain: Vec::from([self.name]),
            at: Instant::now(),
            object: with
        };
        TERMINAL.write().error(&problem);
        self.problems.push(problem);
        return Act {
            problems: self.problems,
            result: None
        }
    }
    #[inline]
    pub fn succeed<Type>(self, value: Type) -> Act<Type, Object> {return Act {
        problems: self.problems,
        result: Some(value)
    }}
    //#[inline]
    //pub fn take<'valid, Inferior>(&'valid mut self, option: Option<Inferior>, object: Object) -> Attachment<'valid, Inferior, Object> {
    //    if option.is_none() {self.warn(object)}
    //    return Attachment {
    //        report: Some(self),
    //        result: option
    //    };
    //}
}


//^
//^ ACT
//^

//> ACT -> STRUCT
pub struct Act<Type, Object: ToIssue> {
    problems: Vec<Problem<Object>>,
    pub result: Option<Type>
}

//> ACT -> TERMINATION
impl<Object: ToIssue> Termination for Act<(), Object> {
    fn report(self) -> ExitCode {return match self.result {
        Some(()) => ExitCode::SUCCESS,
        None => self.problems.last().unwrap().object.to_issue().code
    }}
}

//> ACT -> ATTACH
impl<Type, Object: ToIssue> Act<Type, Object> {
    #[inline]
    pub fn attach<'valid>(self, report: &'valid mut Report<Object>) -> Attachment<'valid, Type, Object> {
        for mut problem in self.problems {
            problem.chain.push(report.name);
            report.problems.push(problem);
        };
        report.problems.sort_by(|first, second| first.at.cmp(&second.at));
        return Attachment {
            report: Some(report),
            result: self.result
        }
    }
}