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

use mlir_sys::MlirLogicalResult;

/// A logical result of success or failure.
#[derive(Clone, Copy, Debug)]
pub struct LogicalResult {
    raw: MlirLogicalResult,
}

impl LogicalResult {
    /// Creates a success result.
    pub const fn success() -> Self {
        Self {
            raw: MlirLogicalResult { value: 1 },
        }
    }

    /// Creates a failure result.
    pub const fn failure() -> Self {
        Self {
            raw: MlirLogicalResult { value: 0 },
        }
    }

    /// Returns `true` if a result is success.
    pub const fn is_success(&self) -> bool {
        self.raw.value != 0
    }

    /// Returns `true` if a result is failure.
    #[allow(dead_code)]
    pub const fn is_failure(&self) -> bool {
        self.raw.value == 0
    }

    /// Creates a logical result from a raw object.
    pub const fn from_raw(result: MlirLogicalResult) -> Self {
        Self { raw: result }
    }

    /// Converts a logical result into a raw object.
    pub const fn to_raw(self) -> MlirLogicalResult {
        self.raw
    }
}

impl From<bool> for LogicalResult {
    fn from(ok: bool) -> Self {
        if ok {
            Self::success()
        } else {
            Self::failure()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn success() {
        assert!(LogicalResult::success().is_success());
    }

    #[test]
    fn failure() {
        assert!(LogicalResult::failure().is_failure());
    }
}