hypertask_engine 0.2.0

The core logic engine used to run hypertask
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

use std::error::Error;
use std::fmt;

#[derive(Debug)]
pub enum HyperTaskErrorDomain {
    Config,
    Context,
    Input,
    Mutation,
    Query,
    ScoreCalculator,
    Task,
}

impl fmt::Display for HyperTaskErrorDomain {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                HyperTaskErrorDomain::Config => "config",
                HyperTaskErrorDomain::Context => "context",
                HyperTaskErrorDomain::Input => "input",
                HyperTaskErrorDomain::Mutation => "mutation",
                HyperTaskErrorDomain::Query => "query",
                HyperTaskErrorDomain::ScoreCalculator => "scoreCalculator",
                HyperTaskErrorDomain::Task => "task",
            }
        )
    }
}

#[derive(Debug)]
pub enum HyperTaskErrorAction {
    Create,
    Delete,
    Parse,
    Read,
    Run,
    Write,
}

impl fmt::Display for HyperTaskErrorAction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                HyperTaskErrorAction::Create => "create",
                HyperTaskErrorAction::Delete => "delete",
                HyperTaskErrorAction::Parse => "parse",
                HyperTaskErrorAction::Read => "read",
                HyperTaskErrorAction::Run => "run",
                HyperTaskErrorAction::Write => "write",
            }
        )
    }
}

#[derive(Debug)]
pub struct HyperTaskError {
    domain: HyperTaskErrorDomain,
    action: HyperTaskErrorAction,
    meta: Option<String>,
    source: Option<Box<dyn Error + 'static>>,
}

pub type HyperTaskResult<T> = Result<T, HyperTaskError>;

impl HyperTaskError {
    pub fn new(domain: HyperTaskErrorDomain, action: HyperTaskErrorAction) -> Self {
        Self {
            domain,
            action,
            meta: None,
            source: None,
        }
    }

    pub fn msg(mut self, meta: &'static str) -> Self {
        self.meta = Some(meta.to_owned());
        self
    }

    pub fn with_msg<F: Fn() -> String>(mut self, meta_factory: F) -> Self {
        self.meta = Some(meta_factory());
        self
    }

    pub fn from<E: 'static + Error>(mut self, source: E) -> Self {
        self.source = Some(Box::new(source));
        self
    }
}

impl fmt::Display for HyperTaskError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "HyperTaskError[{}::{}]", self.domain, self.action)?;

        if let Some(meta_text) = &self.meta {
            write!(f, ": {}", meta_text)?
        }

        Ok(())
    }
}

impl Error for HyperTaskError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        if let Some(source_box) = &self.source {
            Some(source_box.as_ref())
        } else {
            None
        }
    }
}

impl From<HyperTaskError> for String {
    fn from(error: HyperTaskError) -> Self {
        format!("{}", error)
    }
}

pub fn print_error_chain(err: &(dyn Error + 'static)) {
    print_error_chain_recursive(err, 1)
}

pub fn print_error_chain_recursive(err: &(dyn Error + 'static), i: u32) {
    println!("Error {}: {}", i, err);

    if let Some(boxed_source) = err.source() {
        print_error_chain_recursive(boxed_source, i + 1);
    }
}