rust_util/
lib.rs

1#[macro_use] extern crate lazy_static;
2extern crate term;
3
4use std::error::Error;
5use std::io::{Error as IoError, ErrorKind};
6use std::fmt::{Display, Formatter, Result as FmtResult};
7
8pub mod util_io;
9pub mod util_os;
10pub mod util_env;
11pub mod util_cmd;
12pub mod util_msg;
13pub mod util_str;
14pub mod util_size;
15pub mod util_file;
16pub mod util_time;
17pub mod util_net;
18pub mod util_term;
19pub mod util_git;
20#[cfg(feature = "use_clap")]
21pub mod util_clap;
22pub mod util_tlv;
23pub mod util_runtime;
24
25/// iff!(condition, result_when_true, result_when_false)
26#[macro_export] macro_rules! iff {
27    ($c:expr, $t:expr, $f:expr) => ( if $c { $t } else { $f } )
28}
29#[macro_export] macro_rules! information {
30    ($($arg:tt)+) => ( rust_util::util_msg::when(rust_util::util_msg::MessageType::INFO, || {
31        rust_util::util_msg::print_info(&format!($($arg)+));
32    }); )
33}
34#[macro_export] macro_rules! success {
35    ($($arg:tt)+) => ( rust_util::util_msg::print_ok(&format!($($arg)+)); )
36}
37#[macro_export] macro_rules! warning {
38    ($($arg:tt)+) => ( rust_util::util_msg::print_warn(&format!($($arg)+)); )
39}
40#[macro_export] macro_rules! failure {
41    ($($arg:tt)+) => ( rust_util::util_msg::print_error(&format!($($arg)+)); )
42}
43#[macro_export] macro_rules! println_ex {
44    ($($arg:tt)+) => ( rust_util::util_msg::print_ex(&format!($($arg)+), true); )
45}
46#[macro_export] macro_rules! print_ex {
47    ($($arg:tt)+) => ( rust_util::util_msg::print_ex(&format!($($arg)+), false); )
48}
49#[macro_export] macro_rules! debugging {
50    ($($arg:tt)+) => ( rust_util::util_msg::when(rust_util::util_msg::MessageType::DEBUG, || {
51        rust_util::util_msg::print_debug(&format!($($arg)+))
52    }); )
53}
54#[macro_export] macro_rules! failure_and_exit {
55    ($($arg:tt)+) => ( {
56        rust_util::util_msg::print_error(&format!($($arg)+));
57        rust_util::util_runtime::invoke_callbacks();
58        std::process::exit(-1);
59    } )
60}
61#[macro_export] macro_rules! opt_value {
62    ($ex: expr) => ( match $ex { Some(o) => o, None => return, } )
63}
64
65pub type XResult<T> = Result<T, Box<dyn Error>>;
66
67pub fn new_box_error(m: &str) -> Box<dyn Error> {
68    Box::new(IoError::new(ErrorKind::Other, m))
69}
70
71pub fn new_box_ioerror(m: &str) -> Box<dyn Error> {
72    Box::new(IoError::new(ErrorKind::Other, m))
73}
74
75#[macro_export] macro_rules! opt_value_result {
76    ($ex: expr, $($arg:tt)+) => (
77        match $ex {
78            Some(o) => o,
79            None => return Err(rust_util::SimpleError::new(
80                format!("{}, file: {}, line: {}", format!($($arg)+), file!(), line!())
81            ).into()),
82        }
83    )
84}
85
86#[macro_export] macro_rules! opt_result {
87    ($ex: expr, $($arg:tt)+) => (
88        match $ex {
89            Ok(o) => o,
90            Err(e) => return Err(rust_util::SimpleError::new(
91                format!("{}, file: {}, line: {}", format!($($arg)+, e), file!(), line!())
92            ).into()),
93        }
94    )
95}
96#[macro_export] macro_rules! simple_error {
97    ($($arg:tt)+) => ( Err(rust_util::SimpleError::new(
98        format!("{}, file: {}, line: {}", format!($($arg)+), file!(), line!())
99    ).into()) )
100}
101
102#[derive(Debug)]
103pub struct SimpleError {
104    pub message: String,
105    pub source: Option<Box<dyn Error>>,
106}
107
108impl SimpleError {
109    pub fn new(message: String) -> Self {
110        Self { message, source: None }
111    }
112
113    pub fn new2(message: String, source: Box<dyn Error>) -> Self {
114        Self { message, source: Some(source) }
115    }
116}
117
118impl Display for SimpleError {
119    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
120        match &self.source {
121            None => write!(f, "SimpleErorr, message: {}", self.message),
122            Some(e) => write!(f, "SimpleErorr, message: {}, source erorr: {}", self.message, e),
123        }
124    }
125}
126
127impl Error for SimpleError {}
128