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

//! Meteo specific Header fields
use std::io::{BufWriter, Write};

use crate::prelude::FormattingError;

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

#[cfg(feature = "processing")]
use qc_traits::{FilterItem, MaskFilter, MaskOperand};

#[cfg(feature = "processing")]
use std::str::FromStr;

use crate::{meteo::Sensor, prelude::Observable};

/// Meteo specific header fields
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct HeaderFields {
    /// Observation types contained in this file
    pub codes: Vec<Observable>,
    /// Sensors that produced the following observables
    pub sensors: Vec<Sensor>,
}

impl HeaderFields {
    /// Formats [HeaderFields] into [BufWriter].
    pub(crate) fn format<W: Write>(&self, w: &mut BufWriter<W>) -> Result<(), FormattingError> {
        const NUM_OBSERVABLES_PER_LINE: usize = 9;

        write!(w, "{:6}", self.codes.len())?;
        let mut modulo = 0;

        for (nth, observable) in self.codes.iter().enumerate() {
            if nth > 0 && (nth % NUM_OBSERVABLES_PER_LINE) == 0 {
                write!(w, "      ")?;
            }

            write!(w, "    {}", observable)?;

            if (nth % NUM_OBSERVABLES_PER_LINE) == NUM_OBSERVABLES_PER_LINE - 1 {
                write!(w, "# / TYPES OF OBSERV\n      ")?;
            }

            modulo = nth % NUM_OBSERVABLES_PER_LINE;
        }

        if modulo != 7 {
            writeln!(
                w,
                "{:>width$}",
                "# / TYPES OF OBSERV",
                width = 79 - 6 - (modulo + 1) * 6
            )?;
        }

        for sensor in self.sensors.iter() {
            writeln!(w, "{}", sensor)?;
        }

        Ok(())
    }
}

#[cfg(feature = "processing")]
impl HeaderFields {
    pub(crate) fn mask_mut(&mut self, f: &MaskFilter) {
        match f.operand {
            MaskOperand::Equals => match &f.item {
                FilterItem::ComplexItem(complex) => {
                    // try to interprate as [Observable]
                    let observables = complex
                        .iter()
                        .filter_map(|f| {
                            if let Ok(ob) = Observable::from_str(f) {
                                Some(ob)
                            } else {
                                None
                            }
                        })
                        .collect::<Vec<_>>();
                    self.codes.retain(|c| observables.contains(&c));
                },
                _ => {},
            },
            MaskOperand::NotEquals => match &f.item {
                FilterItem::ComplexItem(complex) => {
                    // try to interprate as [Observable]
                    let observables = complex
                        .iter()
                        .filter_map(|f| {
                            if let Ok(ob) = Observable::from_str(f) {
                                Some(ob)
                            } else {
                                None
                            }
                        })
                        .collect::<Vec<_>>();
                    self.codes.retain(|c| !observables.contains(&c));
                },
                _ => {},
            },
            _ => {},
        }
    }
}