except-plugin 0.0.1

exception-plugin is a common exception in Rust , which helps developers better control their programs
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
96
97
98
99
100
101
102
103
104
105

//! # UnSupported Operation Exception
//! ```txt
//! @author:syf20020816@Outlook.com
//! @date:2023/8/15
//! @version:0.0.1
//! @description:
//! ```

use std::error::Error;
use std::path::{PathBuf};
use std::fmt::{Debug, Display, Formatter};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use super::{UNSUPPORTED_OPERATION_MSG, Reasons,UnSupportedReasons,ReasonParamImpl, SuperBuilderImpl, ExceptionLevel, NewFrom, FromBuilder, CommonParamImpl, Exception, Exceptions, UnSupportedOpExceptionBuilder, ExceptionCode, DerefException};
use crate::{display_err_impl, exception_impl, common_param_impl, reason_param_impl};


/// # UnSupportedOperationException
/// - code: exception code
/// - msg: exception msg
/// - line: error line
/// - path: error file path
/// - level: exception level
/// - reason: reason for error
#[derive(Debug, Clone, PartialEq)]
pub struct UnSupportedOpException {
    code: u32,
    msg: String,
    line: u32,
    path: PathBuf,
    level: ExceptionLevel,
    reason: Reasons,
    timestamp: Duration,
}

impl Default for UnSupportedOpException {
    fn default() -> Self {
        UnSupportedOpException {
            code: ExceptionCode::UNSUPPORTED_OPERATION,
            msg: String::from(UNSUPPORTED_OPERATION_MSG),
            line: 0,
            path: PathBuf::new(),
            level: ExceptionLevel::Info,
            reason: Reasons::UnSupported(UnSupportedReasons::Other),
            timestamp: SystemTime::now().duration_since(UNIX_EPOCH).unwrap(),
        }
    }
}

impl NewFrom for UnSupportedOpException {
    type Builder = UnSupportedOpExceptionBuilder;
    fn new() -> Self::Builder {
        UnSupportedOpExceptionBuilder::new()
    }
    fn from_super(e: Box<dyn Exception>) -> Self where Self: Sized {
        UnSupportedOpException {
            code: e.code(),
            msg: String::from(e.msg()),
            level: e.level(),
            reason: Reasons::UnSupported(UnSupportedReasons::Other),
            path: PathBuf::new(),
            line: 0,
            timestamp: e.timestamp(),
        }
    }
}

impl FromBuilder for UnSupportedOpException {
    type Input = UnSupportedOpExceptionBuilder;
    type Output = UnSupportedOpException;
    fn from_builder(builder: &Self::Input) -> Self::Output {
        Self::Output {
            code: builder.code(),
            msg: String::from(builder.msg()),
            level: builder.level(),
            reason: builder.reason(),
            line: builder.line(),
            path: builder.path(),
            timestamp: builder.timestamp(),
        }
    }
}

display_err_impl!(UnSupportedOpException);

exception_impl!(UnSupportedOpException,Exceptions::UnSupportedOperation);

common_param_impl!(UnSupportedOpException);

reason_param_impl!(UnSupportedOpException);

impl DerefException for UnSupportedOpException {
    fn deref_mut_exception(&mut self) -> Self {
        UnSupportedOpException {
            code: self.code(),
            msg: String::from(self.msg()),
            line: self.line(),
            path: self.path(),
            level: self.level(),
            reason: self.reason(),
            timestamp: self.timestamp(),
        }
    }
}