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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Module for errors.
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(sounding_analysis::AnalysisError),
    /// Error forwarded from sounding-bufkit
    SoundingBufkit(sounding_bufkit::BufkitFileError),

    // Inherited errors from std
    /// Error forwarded from std
    IO(std::io::Error),

    // 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
    /// File not found in the index.
    NotInIndex,
    /// Not enough data to complete the task.
    NotEnoughData,
    /// Sounding was missing a valid time
    MissingValidTime,
    /// Missing station information.
    MissingStationData,
    /// An error that is known and hard coded into the library.
    KnownArchiveError(&'static str),
    /// There was an internal logic error.
    LogicError(&'static str),
    /// The site id didn't match the hint when adding.
    MismatchedIDs {
        /// The ID that was provided as a hint.
        hint: String,
        /// The ID that was parsed from the file.
        parsed: String,
    },
    /// The station numbers didn't match.
    MismatchedStationNumbers {
        /// The StationNumber number with the original request.
        hint: crate::StationNumber,
        /// The StationNumber parsed from the file.
        parsed: crate::StationNumber,
    },
    /// Parsed and expected initialization times didn't match.
    MismatchedInitializationTimes {
        /// The initialization time that was expected.
        hint: chrono::NaiveDateTime,
        /// The inizialization time that was parsed from the file.
        parsed: chrono::NaiveDateTime,
    },
}

impl Display for BufkitDataErr {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        use crate::errors::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),

            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),

            NotInIndex => write!(f, "no match in the index"),
            NotEnoughData => write!(f, "not enough data to complete task"),
            MissingValidTime => write!(f, "sounding missing a valid time"),
            MissingStationData => write!(f, "not enough information about the station"),
            KnownArchiveError(msg) => write!(f, "Known error: {}", msg),
            LogicError(msg) => write!(f, "internal logic error: {}", msg),
            MismatchedIDs { hint, parsed } => {
                write!(f, "mismatched ids parsed: {} != hint:{}", parsed, hint)
            }
            MismatchedStationNumbers { .. } => write!(f, "mismatched station numbers"),
            MismatchedInitializationTimes { .. } => write!(f, "mismatched initialization times"),
        }
    }
}

impl Error for BufkitDataErr {}

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

impl From<sounding_analysis::AnalysisError> for BufkitDataErr {
    fn from(err: sounding_analysis::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())
    }
}