sp3 1.4.1

IGS SP3 file parser
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

use crate::errors::ParsingError;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

#[derive(Default, Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Campaign {
    /// Part of a demonstration campaign.
    Demo,

    /// Multi-GNSS project product
    MGX,

    /// Operational IGS product
    #[default]
    OPS,

    /// Reprocessing campaign (with number of campaign iteration)
    Reprocessing(u8),

    /// Tide Gauche Benchmark Monitoring (TIGA)
    TGA,

    /// Part of a test campaign
    Test,
}

impl std::str::FromStr for Campaign {
    type Err = ParsingError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "DEM" => Ok(Self::Demo),
            "TST" => Ok(Self::Test),
            "TGA" => Ok(Self::TGA),
            "OPS" => Ok(Self::OPS),
            "MGX" => Ok(Self::MGX),
            value => {
                if value.starts_with('R') {
                    let rnn = value[1..]
                        .parse::<u8>()
                        .or(Err(ParsingError::InvalidCampaignName))?;

                    Ok(Self::Reprocessing(rnn))
                } else {
                    Err(ParsingError::InvalidCampaignName)
                }
            },
        }
    }
}

impl std::fmt::Display for Campaign {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Demo => write!(f, "DEM"),
            Self::MGX => write!(f, "MGX"),
            Self::OPS => write!(f, "OPS"),
            Self::TGA => write!(f, "TGA"),
            Self::Test => write!(f, "TST"),
            Self::Reprocessing(value) => write!(f, "R{:02}", value),
        }
    }
}