metar 0.9.3

A fast METAR parsing library in pure Rust
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use chumsky::prelude::*;

use crate::{
    parsers::{any_whitespace, some_whitespace},
    traits::Parsable,
    CloudLayer, VerticalVisibility, Visibility, Weather, Wind,
};

/// How is the weather expected to change in the near future?
#[derive(PartialEq, Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[allow(missing_docs)]
pub enum Trend {
    NoSignificantChanges,
    NoSignificantWeather,
    Becoming(TrendNewCondition),
    Temporarily(TrendNewCondition),
}

impl Parsable for Trend {
    fn parser<'src>() -> impl Parser<'src, &'src str, Self, extra::Err<crate::MetarError<'src>>> {
        choice((
            just("NOSIG").map(|_| Trend::NoSignificantChanges),
            just("NSW").map(|_| Trend::NoSignificantWeather),
            just("BECMG ")
                .then(TrendNewCondition::parser())
                .map(|(_, cond)| Trend::Becoming(cond)),
            just("TEMPO ")
                .then(TrendNewCondition::parser())
                .map(|(_, cond)| Trend::Temporarily(cond)),
        ))
    }
}

/// New conditions apply
#[derive(PartialEq, Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TrendNewCondition {
    /// The time from which conditions apply
    pub time: Vec<TrendTime>,
    /// New wind values, if specified
    pub wind: Option<Wind>,
    /// New visibility values, if specified
    pub visibility: Option<Visibility>,
    /// New weather conditions, if specified
    pub weather: Vec<Weather>,
    /// New cloud layers, if specified
    pub cloud: Vec<CloudLayer>,
    /// New vertical visibility, if specified
    pub vertical_visibility: Option<VerticalVisibility>,
}

impl Parsable for TrendNewCondition {
    fn parser<'src>() -> impl Parser<'src, &'src str, Self, extra::Err<crate::MetarError<'src>>> {
        group((
            TrendTime::parser()
                .separated_by(some_whitespace())
                .allow_trailing()
                .collect::<Vec<_>>()
                .or(empty().map(|()| vec![])),
            Wind::parser().map(Some).or(empty().map(|()| None)),
            Visibility::parser()
                .map(Some)
                .then_ignore(any_whitespace())
                .or(empty().map(|()| None)),
            choice((
                just("NSW").map(|_| vec![]).then_ignore(any_whitespace()),
                Weather::parser()
                    .separated_by(some_whitespace())
                    .allow_trailing()
                    .collect::<Vec<_>>(),
            )),
            CloudLayer::parser()
                .separated_by(some_whitespace())
                .allow_trailing()
                .collect::<Vec<_>>(),
            VerticalVisibility::parser()
                .then_ignore(any_whitespace())
                .map(Some)
                .or(empty().map(|()| None)),
        ))
        .map(
            |(time, wind, visibility, weather, cloud, vertical_visibility)| TrendNewCondition {
                time,
                wind,
                visibility,
                weather,
                cloud,
                vertical_visibility,
            },
        )
    }
}

/// The time at which conditions change
#[derive(PartialEq, Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TrendTime {
    /// From a particular time, in 24 hour format, eg. 1345
    From(u16),
    /// Until a particular time, in 24 hour format, eg. 1345
    Until(u16),
    /// At a particular time, in 24 hour format, eg. 1345
    At(u16),
}

impl Parsable for TrendTime {
    fn parser<'src>() -> impl Parser<'src, &'src str, Self, extra::Err<crate::MetarError<'src>>> {
        let time = text::digits(10)
            .exactly(4)
            .to_slice()
            .map(|d: &str| d.parse().unwrap());
        choice((
            just("FM").then(time).map(|(_, time)| TrendTime::From(time)),
            just("TL")
                .then(time)
                .map(|(_, time)| TrendTime::Until(time)),
            just("AT").then(time).map(|(_, time)| TrendTime::At(time)),
        ))
    }
}