libutils 5.27.17

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

//^
//^ HEAD
//^

//> HEAD -> SUPER
use super::{
    toissue::ToIssue,
    Report,
    shortcut::Attachment
};

//> HEAD -> CRATE
use crate::terminal::Problem;

//> HEAD -> CORE
use core::hash::{
    Hash,
    Hasher
};

//> HEAD -> STD
use std::{
    hash::DefaultHasher,
    process::{
        ExitCode,
        Termination
    }
};


//^
//^ ACT
//^

//> ACT -> STRUCT
pub struct Act<Type, Object: ToIssue, const NAME: &'static str> {
    pub problems: Vec<Problem<Object>>,
    pub result: Option<Type>
}

//> ACT -> TERMINATION
impl<Object: ToIssue> Termination for Act<(), Object, "Main"> {
    fn report(self) -> ExitCode {return match self.result {
        Some(()) => ExitCode::SUCCESS,
        None => match self.problems.last() {
            None => unreachable!(),
            Some(problem) => {
                let mut state = DefaultHasher::new();
                problem.object.to_issue().hash(&mut state);
                ExitCode::from(state.finish() as u8)
            }
        }
    }}
}

//> ACT -> IMPLEMENTATION
impl<Type, Object: ToIssue, const NAME: &'static str> Act<Type, Object, NAME> {
    #[inline]
    pub fn attach<'valid, const OTHER: &'static str>(self, report: &'valid mut Report<Object, OTHER>) -> Attachment<'valid, Type, Object, OTHER> {
        for mut problem in self.problems {
            problem.chain.push(OTHER);
            report.problems.push(problem);
        };
        report.problems.sort_by(|first, second| first.at.cmp(&second.at));
        return Attachment {
            report: Some(report),
            result: self.result
        }
    }
    #[inline]
    pub fn map<Return, Closure: FnOnce(Type) -> Return>(self, closure: Closure) -> Act<Return, Object, NAME> {return Act {
        problems: self.problems,
        result: self.result.map(closure)
    }}
}