# boolobject.rs - source
Source of the Rust file `/home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/pyo3-0.13.2/src/types/boolobject.rs`.
Keywords: rust, rustlang, rust-lang

     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

    // Copyright (c) 2017-present PyO3 Project and Contributors
    use crate::{
        ffi, AsPyPointer, FromPyObject, IntoPy, PyAny, PyObject, PyResult, PyTryFrom, Python,
        ToPyObject,
    };

    /// Represents a Python `bool`.
    #[repr(transparent)]
    pub struct PyBool(PyAny);

    pyobject_native_type!(PyBool, ffi::PyObject, ffi::PyBool_Type, ffi::PyBool_Check);

    impl PyBool {
        /// Depending on `val`, returns `true` or `false`.
        #[inline]
        pub fn new(py: Python, val: bool) -> &PyBool {
            unsafe { py.from_borrowed_ptr(if val { ffi::Py_True() } else { ffi::Py_False() }) }
        }

        /// Gets whether this boolean is `true`.
        #[inline]
        pub fn is_true(&self) -> bool {
            self.as_ptr() == unsafe { crate::ffi::Py_True() }
        }
    }

    /// Converts a Rust `bool` to a Python `bool`.
    impl ToPyObject for bool {
        #[inline]
        fn to_object(&self, py: Python) -> PyObject {
            unsafe {
                PyObject::from_borrowed_ptr(
                    py,
                    if *self {
                        ffi::Py_True()
                    } else {
                        ffi::Py_False()
                    },
                )
            }
        }
    }

    impl IntoPy<PyObject> for bool {
        #[inline]
        fn into_py(self, py: Python) -> PyObject {
            PyBool::new(py, self).into()
        }
    }

    /// Converts a Python `bool` to a Rust `bool`.
    ///
    /// Fails with `TypeError` if the input is not a Python `bool`.
    impl<'source> FromPyObject<'source> for bool {
        fn extract(obj: &'source PyAny) -> PyResult<Self> {
            Ok(<PyBool as PyTryFrom>::try_from(obj)?.is_true())
        }
    }

    #[cfg(test)]
    mod test {
        use crate::types::{PyAny, PyBool};
        use crate::Python;
        use crate::ToPyObject;

        #[test]
        fn test_true() {
            let gil = Python::acquire_gil();
            let py = gil.python();
            assert!(PyBool::new(py, true).is_true());
            let t: &PyAny = PyBool::new(py, true).into();
            assert_eq!(true, t.extract().unwrap());
            assert_eq!(true.to_object(py), PyBool::new(py, true).into());
        }

        #[test]
        fn test_false() {
            let gil = Python::acquire_gil();
            let py = gil.python();
            assert!(!PyBool::new(py, false).is_true());
            let t: &PyAny = PyBool::new(py, false).into();
            assert_eq!(false, t.extract().unwrap());
            assert_eq!(false.to_object(py), PyBool::new(py, false).into());
        }
    }