libcint 0.2.3

FFI binding and GTO wrapper for libcint (C library)
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

use crate::prelude::*;

/// Error for [`CInt`] operations.
#[derive(Debug, Clone)]
pub enum CIntErrorBase {
    IntegratorNotFound(String),
    IntegratorNotAvailable(String),
    RuntimeError(String),
    InvalidValue(String),
    UninitializedFieldError(UninitializedFieldError),
    ParseError(String),
    Miscellaneous(String),
}

#[derive(Debug)]
pub struct CIntError {
    pub kind: CIntErrorBase,
    pub backtrace: Option<Backtrace>,
}

/* #region CIntError impl */

impl Display for CIntErrorBase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(self, f)
    }
}

impl Display for CIntError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(self, f)
    }
}

impl Error for CIntErrorBase {}
impl Error for CIntError {}

impl From<UninitializedFieldError> for CIntError {
    fn from(err: UninitializedFieldError) -> Self {
        CIntError { kind: CIntErrorBase::UninitializedFieldError(err), backtrace: Some(Backtrace::capture()) }
    }
}

pub trait CIntResultAPI<T> {
    fn cint_unwrap(self) -> T;
}

impl<T> CIntResultAPI<T> for Result<T, CIntError> {
    fn cint_unwrap(self) -> T {
        match self {
            Ok(val) => val,
            Err(err) => {
                let CIntError { kind, backtrace } = err;

                if let Some(backtrace) = backtrace {
                    std::eprintln!("\n====== CInt Backtrace ======\n{:}", backtrace);
                }
                panic!("CInt Error: {:?}", kind)
            },
        }
    }
}

#[macro_export]
macro_rules! cint_trace {
    () => {
        concat!(file!(), ":", line!(), ":", column!(), ": ")
    };
}

#[macro_export]
macro_rules! cint_error {
    ($errtype: ident, $($arg:tt)*) => {{
        use $crate::prelude::*;
        let mut s = String::new();
        write!(s, cint_trace!()).unwrap();
        write!(s, concat!("CIntError ", stringify!($errtype), ": ")).unwrap();
        write!(s, $($arg)*).unwrap();
        CIntError { kind: CIntErrorBase::$errtype(s), backtrace: Some(Backtrace::capture()) }
    }};
}

#[macro_export]
macro_rules! cint_raise {
    ($errtype: ident, $($arg:tt)*) => {{
        use $crate::prelude::*;
        let mut s = String::new();
        write!(s, cint_trace!()).unwrap();
        write!(s, concat!("CIntError ", stringify!($errtype), ": ")).unwrap();
        write!(s, $($arg)*).unwrap();
        Err(CIntError { kind: CIntErrorBase::$errtype(s), backtrace: Some(Backtrace::capture()) })
    }};
}

/* #endregion */