rinex 0.22.0

RINEX file parsing, analysis and production
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

#[cfg(doc)]
use crate::prelude::Rinex;

use crate::prelude::{Constellation, ParsingError};

/// [Type] describes all supported [Rinex] formats.
#[derive(Default, Copy, Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Type {
    /// Describes Observation Data (OBS),
    /// Phase & Pseudo range measurements
    #[default]
    ObservationData,

    /// Describes Navigation Data (NAV)
    /// Ephemeris data, and other possible
    /// modern declinations
    NavigationData,

    /// Describes Meteorological data (MET)
    MeteoData,

    /// Clock Data (CLK)
    ClockData,

    /// Antenna Data (ATX or Antex) special RINEX format,
    /// contains sets of Antenna characterization coefficients.
    /// No database is furnished by this lib (way too big).
    /// Users interested in such calibrations / conversions / calculations,
    /// should use this parser as a mean to extract the antenna coefficients solely
    AntennaData,
}

impl std::fmt::Display for Type {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::ObservationData => write!(fmt, "OBS DATA"),
            Self::NavigationData => write!(fmt, "NAVIGATION DATA"),
            Self::MeteoData => write!(fmt, "METEO DATA"),
            Self::ClockData => write!(fmt, "CLOCK DATA"),
            Self::AntennaData => write!(fmt, "ANTEX"),
        }
    }
}

impl Type {
    /// Converts [Type] to standard descriptor
    pub fn to_standard_string(&self, constellation: Option<Constellation>) -> String {
        match *self {
            Self::ObservationData => String::from("OBSERVATION DATA"),
            Self::NavigationData => match constellation {
                Some(Constellation::Glonass) => String::from("Glonass NAV"),
                _ => String::from("NAV DATA"),
            },
            Self::MeteoData => String::from("METEOROLOGICAL DATA"),
            Self::ClockData => String::from("CLOCK DATA"),
            Self::AntennaData => String::from("ANTEX"),
        }
    }
}

impl std::str::FromStr for Type {
    type Err = ParsingError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.to_lowercase();
        if s.eq("navigation data") || s.contains("nav data") {
            Ok(Self::NavigationData)
        } else if s.eq("observation data") {
            Ok(Self::ObservationData)
        } else if s.eq("meteorological data") {
            Ok(Self::MeteoData)
        } else if s.eq("clock data") || s.eq("c") {
            Ok(Self::ClockData)
        } else if s.eq("antex") {
            Ok(Self::AntennaData)
        } else {
            Err(ParsingError::TypeParsing)
        }
    }
}