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

/*
==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--

Binn-IR

Copyright (C) 2018-2023  Anonymous

There are several releases over multiple years,
they are listed as ranges, such as: "2018-2023".

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--
*/

//! # Shortcuts for booleans

use crate::{Error, Result, Value};

/// # Shortcuts for booleans
impl Value {

    /// # If the value is a boolean, returns it
    ///
    /// Returns an error if the value is not a boolean.
    ///
    /// ## Examples
    ///
    /// ```
    /// use binn_ir::Value;
    ///
    /// assert!(Value::True.is_true()?);
    /// assert!(Value::False.is_true()? == false);
    /// assert!(Value::Null.is_true().is_err());
    /// # Ok::<_, binn_ir::Error>(())
    /// ```
    pub fn is_true(&self) -> Result<bool> {
        match self {
            Self::True => Ok(true),
            Self::False => Ok(false),
            _ => Err(err!("Value is not a boolean")),
        }
    }

}

impl From<bool> for Value {

    fn from(b: bool) -> Self {
        if b {
            Self::True
        } else {
            Self::False
        }
    }

}

impl TryFrom<&Value> for bool {

    type Error = Error;

    fn try_from(v: &Value) -> core::result::Result<Self, Self::Error> {
        match v {
            Value::True => Ok(true),
            Value::False => Ok(false),
            _ => Err(err!("Value is not a boolean")),
        }
    }

}

impl TryFrom<Value> for bool {

    type Error = Error;

    fn try_from(v: Value) -> core::result::Result<Self, Self::Error> {
        Self::try_from(&v)
    }

}