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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::fmt;

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused whilst parsing the weather station
pub enum StationError {
    /// The station ID is not the correct length
    IncorrectLength,
    /// A character was found to be not alphabetic
    NonAlphabeticCharacter,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the observation time
pub enum ObservationTimeError {
    /// The observation time is not the correct length
    IncorrectLength,
    /// The observation date is not valid
    DateNotValid,
    /// The observation hour is not valid
    HourNotValid,
    /// The observation minute is not valid
    MinuteNotValid,
    /// The specified time zone is not within the ICAO METAR standard
    InvalidTimeZone,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the wind
pub enum WindError {
    /// The wind information is not the correct length
    IncorrectLength,
    /// The wind heading is not valid
    HeadingNotValid,
    /// The wind speed was not valid
    SpeedNotValid,
    /// The wind gusting speed was not valid
    GustingNotValid,
    /// An unknown unit was read
    UnitNotValid,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the wind varying
pub enum WindVaryingError {
    /// The wind heading is not valid
    HeadingNotValid,
    /// Mostly an internal error - informs the calling function that this is not a wind varying
    /// and should be attempted to be parsed as cloud/visibility information
    NotWindVarying,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the cloud and visibility information
pub enum CloudVisibilityError {
    /// The data parsing was attempted upon is unknown in type
    UnknownData,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the temperature
pub enum TemperatureError {
    /// The temperature is not valid
    TemperatureNotValid,
    /// The dewpoint is not valid
    DewpointNotValid,
    /// Mostly an internal error - informs the calling function that this is not a
    /// temperature/dewpoint pair and should be attempted to be parsed as cloud/visibility
    /// information
    NotTemperatureDewpointPair,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// An error caused when parsing the pressure
pub enum PressureError {
    /// The pressure is not valid
    PressureNotValid,
    /// The unit is not valid. Note that this is also returned when a unit is not specified,
    /// or when the pressure is not long enough to satisfy the requirements of any other unit.
    UnitNotValid,
}

impl fmt::Display for StationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::IncorrectLength => write!(f, "The station ID was not the correct length."),
            Self::NonAlphabeticCharacter => write!(f, "Found a non-alphabetic character."),
        }
    }
}

impl fmt::Display for ObservationTimeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::IncorrectLength => write!(f, "The observation time was not the correct length."),
            Self::DateNotValid => write!(f, "The date was invalid."),
            Self::HourNotValid => write!(f, "The hour was invalid."),
            Self::MinuteNotValid => write!(f, "The minute was invalid."),
            Self::InvalidTimeZone => write!(f, "The time zone was invalid (not Zulu)."),
        }
    }
}

impl fmt::Display for WindError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::IncorrectLength => write!(f, "The length of the wind information is incorrect."),
            Self::HeadingNotValid => write!(f, "The heading is invalid."),
            Self::SpeedNotValid => write!(f, "The speed is invalid."),
            Self::GustingNotValid => write!(f, "The gusting speed is invalid."),
            Self::UnitNotValid => write!(f, "The unit is not valid."),
        }
    }
}

impl fmt::Display for WindVaryingError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::HeadingNotValid => write!(f, "The heading is invalid."),
            Self::NotWindVarying => unreachable!(),
        }
    }
}

impl fmt::Display for CloudVisibilityError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::UnknownData => write!(f, "Unknown data for parsing."),
        }
    }
}

impl fmt::Display for TemperatureError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::TemperatureNotValid => write!(f, "The temperature is invalid."),
            Self::DewpointNotValid => write!(f, "The dewpoint is invalid."),
            Self::NotTemperatureDewpointPair => unreachable!(),
        }
    }
}

impl fmt::Display for PressureError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::PressureNotValid => write!(f, "The pressure is invalid."),
            Self::UnitNotValid => write!(f, "The unit is invalid."),
        }
    }
}