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

//! Module for errors.
use sounding_analysis::AnalysisError;
use sounding_bufkit::BufkitFileError;
use std::{error::Error, fmt::Display};

/// Error from the archive interface.
#[derive(Debug)]
pub enum BufkitDataErr {
    // Inherited errors from sounding stack
    /// Error forwarded from sounding-analysis
    SoundingAnalysis(AnalysisError),
    /// Error forwarded from sounding-bufkit
    SoundingBufkit(BufkitFileError),

    // Inherited errors from std
    /// Error forwarded from std
    IO(::std::io::Error),
    /// Error sending message...
    SenderError(::std::sync::mpsc::SendError<String>),

    // Other forwarded errors
    /// Database error
    Database(::rusqlite::Error),
    /// Error forwarded from the strum crate
    StrumError(strum::ParseError),
    /// General error with any cause information erased and replaced by a string
    GeneralError(String),

    // My own errors from this crate
    /// Invalid model name
    InvalidModelName(String),
    /// Site ID does not exist.
    InvalidSiteId(String),
    /// Not enough data to complete the task.
    NotEnoughData,
}

impl Display for BufkitDataErr {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        use crate::BufkitDataErr::*;

        match self {
            SoundingAnalysis(err) => write!(f, "error from sounding-analysis: {}", err),
            SoundingBufkit(err) => write!(f, "error from sounding-bufkit: {}", err),

            IO(err) => write!(f, "std lib io error: {}", err),
            SenderError(err) => write!(f, "error sending message across threads: {}", err),

            Database(err) => write!(f, "database error: {}", err),
            StrumError(err) => write!(f, "error forwarded from strum crate: {}", err),
            GeneralError(msg) => write!(f, "general error forwarded: {}", msg),

            InvalidModelName(mdl_nm) => write!(f, "invalid model name: {}", mdl_nm),
            InvalidSiteId(site_id) => write!(f, "invalid site id: {}", site_id),
            NotEnoughData => write!(f, "not enough data to complete task"),
        }
    }
}

impl Error for BufkitDataErr {}

impl From<BufkitFileError> for BufkitDataErr {
    fn from(err: BufkitFileError) -> BufkitDataErr {
        BufkitDataErr::SoundingBufkit(err)
    }
}

impl From<AnalysisError> for BufkitDataErr {
    fn from(err: AnalysisError) -> BufkitDataErr {
        BufkitDataErr::SoundingAnalysis(err)
    }
}

impl From<::std::io::Error> for BufkitDataErr {
    fn from(err: ::std::io::Error) -> BufkitDataErr {
        BufkitDataErr::IO(err)
    }
}

impl From<::rusqlite::Error> for BufkitDataErr {
    fn from(err: ::rusqlite::Error) -> BufkitDataErr {
        BufkitDataErr::Database(err)
    }
}

impl From<strum::ParseError> for BufkitDataErr {
    fn from(err: strum::ParseError) -> BufkitDataErr {
        BufkitDataErr::StrumError(err)
    }
}

impl From<Box<dyn Error>> for BufkitDataErr {
    fn from(err: Box<dyn Error>) -> BufkitDataErr {
        BufkitDataErr::GeneralError(err.to_string())
    }
}