Uniqued Qc traits (#293)

Signed-off-by: Guillaume W. Bres <[email protected]>

Author: gwbres

crx2rnx/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crx2rnx"
-version = "2.4.1"
+version = "2.4.2"
 license = "MIT OR Apache-2.0"
 authors = ["Guillaume W. Bres <[email protected]>"]
 description = "RINEX data decompressor"
@@ -12,4 +12,4 @@ readme = "README.md"
 
 [dependencies]
 clap = { version = "4.4.13", features = ["derive", "color"] }
-rinex = { path = "../rinex", version = "=0.17.0-alpha-2", features = ["serde"] }
+rinex = { path = "../rinex", version = "=0.17.0-alpha-3", features = ["serde"] }

rinex-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rinex-cli"
-version = "0.12.0-alpha-2"
+version = "0.12.0-alpha-3"
 license = "MIT OR Apache-2.0"
 authors = ["Guillaume W. Bres <[email protected]>"]
 description = "Command line tool parse and analyze RINEX data"
@@ -53,6 +53,6 @@ cggtts = { version = "4.2.0", features = ["serde", "scheduler"], optional = true
 # cggtts = { path = "../../cggtts/cggtts", features = ["serde", "scheduler"], optional = true }
 # cggtts = { git = "https://github.com/gwbres/cggtts", branch = "main", features = ["serde", "scheduler"], optional = true }
 
-rinex = { path = "../rinex", version = "=0.17.0-alpha-2", features = ["full"] }
+rinex = { path = "../rinex", version = "=0.17.0-alpha-3", features = ["full"] }
 sp3 = { path = "../sp3", version = "=1.1.0-alpha-2", features = ["serde", "flate2"] }
-rinex-qc = { path = "../rinex-qc", version = "=0.2.0-alpha-2", features = ["sp3"] } 
+rinex-qc = { path = "../rinex-qc", version = "=0.2.0-alpha-3", features = ["sp3"] } 

rinex-cli/src/fops/merge.rs

@@ -1,10 +1,10 @@
 use crate::cli::Context;
 use crate::Error;
 use clap::ArgMatches;
-use rinex::prelude::{Rinex, RinexType};
-use rinex::Merge;
 use std::path::PathBuf;
 
+use rinex::prelude::{Merge, Rinex, RinexType};
+
 /*
  * Merges proposed (single) file and generates resulting output, into the workspace
  */

rinex-cli/src/main.rs

@@ -13,13 +13,13 @@ use preprocessing::preprocess;
 mod report;
 use report::Report;
 
-use rinex_qc::prelude::{QcContext, QcExtraPage};
 use std::path::Path;
 use walkdir::WalkDir;
 
 extern crate gnss_rs as gnss;
 
-use rinex::prelude::Rinex;
+use rinex::prelude::{MergeError, Rinex};
+use rinex_qc::prelude::{QcContext, QcExtraPage};
 use sp3::prelude::SP3;
 
 use cli::{Cli, Context, RemoteReferenceSite, Workspace};
@@ -52,8 +52,8 @@ pub enum Error {
     MissingMeteoRinex,
     #[error("missing Clock RINEX")]
     MissingClockRinex,
-    #[error("merge ops failure")]
-    MergeError(#[from] rinex::merge::Error),
+    #[error("file merge error: {0}")]
+    MergeError(#[from] MergeError),
     #[error("positioning solver error")]
     PositioningSolverError(#[from] positioning::Error),
     #[cfg(feature = "csv")]

rinex-qc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rinex-qc"
-version = "0.2.0-alpha-2"
+version = "0.2.0-alpha-3"
 license = "MIT OR Apache-2.0"
 authors = ["Guillaume W. Bres <[email protected]>"]
 description = "RINEX and more broadly, GNSS data processing"
@@ -49,7 +49,7 @@ plotly = "0.9"
 
 gnss-rs = { version = "2.3.1", features = ["serde"] }
 
-rinex = { path = "../rinex", version = "=0.17.0-alpha-2", features = ["full"] }
+rinex = { path = "../rinex", version = "=0.17.0-alpha-3", features = ["full"] }
 sp3 = { path = "../sp3", version = "=1.1.0-alpha-2", features = ["qc", "processing", "serde"], optional = true }
 
 gnss-qc-traits = { version = "0.0.2", features = ["processing"] }

rinex-qc/src/context.rs

@@ -11,7 +11,6 @@ use std::{
 };
 
 use rinex::{
-    merge::{Error as RinexMergeError, Merge as RinexMerge},
     prelude::{Almanac, GroundPosition, Rinex, TimeScale},
     types::Type as RinexType,
     Error as RinexError,
@@ -48,10 +47,8 @@ pub enum Error {
     NonSupportedFileFormat,
     #[error("failed to determine filename")]
     FileNameDetermination,
-    #[error("invalid rinex format")]
+    #[error("invalid rinex: {0}")]
     RinexError(#[from] RinexError),
-    #[error("failed to extend rinex context")]
-    RinexMergeError(#[from] RinexMergeError),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

rinex/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rinex"
-version = "0.17.0-alpha-2"
+version = "0.17.0-alpha-3"
 license = "MIT OR Apache-2.0"
 authors = ["Guillaume W. Bres <[email protected]>"]
 description = "Package to parse and analyze RINEX data"

rinex/src/antex/record.rs

@@ -7,7 +7,7 @@ use super::{
     antenna::SvAntennaParsingError, Antenna, AntennaSpecific, Calibration, CalibrationMethod,
     Cospar, RxAntenna, SvAntenna,
 };
-use crate::{carrier, linspace::Linspace, merge, merge::Merge, Carrier, Epoch};
+use crate::{carrier, linspace::Linspace, Carrier, Epoch};
 
 #[cfg(feature = "serde")]
 use serde::Serialize;
@@ -385,45 +385,40 @@ pub(crate) fn parse_antenna(
     Ok((antenna, inner))
 }
 
-impl Merge for Record {
-    /// Merges `rhs` into `Self` without mutable access at the expense of more memcopies
-    fn merge(&self, rhs: &Self) -> Result<Self, merge::Error> {
-        let mut lhs = self.clone();
-        lhs.merge_mut(rhs)?;
-        Ok(lhs)
-    }
-    /// Merges `rhs` into `Self`
-    fn merge_mut(&mut self, rhs: &Self) -> Result<(), merge::Error> {
-        for (antenna, subset) in rhs.iter() {
-            for (carrier, freqdata) in subset.iter() {
-                /*
-                 * determine whether self contains this antenna & signal or not
-                 */
-                let mut has_ant = false;
-                let mut has_signal = false;
-                for (lhs_ant, subset) in self.iter_mut() {
-                    if lhs_ant == antenna {
-                        has_ant |= true;
-                        for (lhs_carrier, _) in subset.iter_mut() {
-                            if lhs_carrier == carrier {
-                                has_signal |= true;
-                                break;
-                            }
-                        }
-                        if !has_signal {
-                            subset.insert(*carrier, freqdata.clone());
+#[cfg(feature = "qc")]
+use qc_traits::MergeError;
+
+#[cfg(feature = "qc")]
+pub(crate) fn merge_mut(lhs: &mut Record, rhs: &Record) -> Result<(), MergeError> {
+    for (antenna, subset) in rhs.iter() {
+        for (carrier, freqdata) in subset.iter() {
+            /*
+             * determine whether lhs contains this antenna & signal or not
+             */
+            let mut has_ant = false;
+            let mut has_signal = false;
+            for (lhs_ant, subset) in lhs.iter_mut() {
+                if lhs_ant == antenna {
+                    has_ant |= true;
+                    for (lhs_carrier, _) in subset.iter_mut() {
+                        if lhs_carrier == carrier {
+                            has_signal |= true;
+                            break;
                         }
                     }
+                    if !has_signal {
+                        subset.insert(*carrier, freqdata.clone());
+                    }
                 }
-                if !has_ant {
-                    let mut inner = HashMap::<Carrier, FrequencyDependentData>::new();
-                    inner.insert(*carrier, freqdata.clone());
-                    self.push((antenna.clone(), inner));
-                }
+            }
+            if !has_ant {
+                let mut inner = HashMap::<Carrier, FrequencyDependentData>::new();
+                inner.insert(*carrier, freqdata.clone());
+                lhs.push((antenna.clone(), inner));
             }
         }
-        Ok(())
     }
+    Ok(())
 }
 
 #[cfg(test)]

rinex/src/clock/record.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 use std::collections::BTreeMap;
 use strum_macros::EnumString;
 
-use crate::{epoch, merge, merge::Merge, prelude::SV, prelude::*, version::Version};
+use crate::{epoch, prelude::SV, prelude::*, version::Version};
 
 #[cfg(feature = "processing")]
 use qc_traits::{DecimationFilter, DecimationFilterType, FilterItem, MaskFilter, MaskOperand};
@@ -310,39 +310,32 @@ pub(crate) fn fmt_epoch(epoch: &Epoch, key: &ClockKey, prof: &ClockProfile) -> S
     lines
 }
 
+#[cfg(feature = "qc")]
 use crate::merge::merge_mut_option;
 
-impl Merge for Record {
-    /// Merges `rhs` into `Self` without mutable access at the expense of more memcopies
-    fn merge(&self, rhs: &Self) -> Result<Self, merge::Error> {
-        let mut lhs = self.clone();
-        lhs.merge_mut(rhs)?;
-        Ok(lhs)
-    }
-    /// Merges `rhs` into `Self`
-    fn merge_mut(&mut self, rhs: &Self) -> Result<(), merge::Error> {
-        for (rhs_epoch, rhs_content) in rhs.iter() {
-            if let Some(lhs_content) = self.get_mut(rhs_epoch) {
-                for (rhs_key, rhs_prof) in rhs_content.iter() {
-                    if let Some(lhs_prof) = lhs_content.get_mut(rhs_key) {
-                        // enhance only, if possible
-                        merge_mut_option(&mut lhs_prof.drift, &rhs_prof.drift);
-                        merge_mut_option(&mut lhs_prof.drift_dev, &rhs_prof.drift_dev);
-                        merge_mut_option(&mut lhs_prof.drift_change, &rhs_prof.drift_change);
-                        merge_mut_option(
-                            &mut lhs_prof.drift_change_dev,
-                            &rhs_prof.drift_change_dev,
-                        );
-                    } else {
-                        lhs_content.insert(rhs_key.clone(), rhs_prof.clone());
-                    }
+#[cfg(feature = "qc")]
+use qc_traits::MergeError;
+
+#[cfg(feature = "qc")]
+pub(crate) fn merge_mut(lhs: &mut Record, rhs: &Record) -> Result<(), MergeError> {
+    for (rhs_epoch, rhs_content) in rhs.iter() {
+        if let Some(lhs_content) = lhs.get_mut(rhs_epoch) {
+            for (rhs_key, rhs_prof) in rhs_content.iter() {
+                if let Some(lhs_prof) = lhs_content.get_mut(rhs_key) {
+                    // enhance only, if possible
+                    merge_mut_option(&mut lhs_prof.drift, &rhs_prof.drift);
+                    merge_mut_option(&mut lhs_prof.drift_dev, &rhs_prof.drift_dev);
+                    merge_mut_option(&mut lhs_prof.drift_change, &rhs_prof.drift_change);
+                    merge_mut_option(&mut lhs_prof.drift_change_dev, &rhs_prof.drift_change_dev);
+                } else {
+                    lhs_content.insert(rhs_key.clone(), rhs_prof.clone());
                 }
-            } else {
-                self.insert(*rhs_epoch, rhs_content.clone());
             }
+        } else {
+            lhs.insert(*rhs_epoch, rhs_content.clone());
         }
-        Ok(())
     }
+    Ok(())
 }
 
 #[cfg(feature = "processing")]

rinex/src/header.rs

@@ -14,7 +14,7 @@ use crate::{
     marker::{GeodeticMarker, MarkerType},
     merge::{
         merge_mut_option, merge_mut_unique_map2d, merge_mut_unique_vec, merge_mut_vec,
-        merge_time_of_first_obs, merge_time_of_last_obs, Error as MergeError, Merge,
+        merge_time_of_first_obs, merge_time_of_last_obs,
     },
     meteo,
     meteo::HeaderFields as MeteoHeader,
@@ -2035,8 +2035,11 @@ impl Header {
     }
 }
 
+#[cfg(feature = "qc")]
+use qc_traits::{Merge, MergeError};
+
+#[cfg(feature = "qc")]
 impl Merge for Header {
-    /// Merges `rhs` into `Self` without mutable access, at the expense of memcopies
     fn merge(&self, rhs: &Self) -> Result<Self, MergeError> {
         if self.rinex_type != rhs.rinex_type {
             return Err(MergeError::FileTypeMismatch);
@@ -2045,7 +2048,6 @@ impl Merge for Header {
         lhs.merge_mut(rhs)?;
         Ok(lhs)
     }
-    /// Merges `rhs` into `Self` in place
     fn merge_mut(&mut self, rhs: &Self) -> Result<(), MergeError> {
         if self.rinex_type != rhs.rinex_type {
             return Err(MergeError::FileTypeMismatch);
@@ -2130,7 +2132,7 @@ impl Merge for Header {
                 let mut mixed_antex = lhs.pcv_type.is_relative() && !rhs.pcv_type.is_relative();
                 mixed_antex |= !lhs.pcv_type.is_relative() && rhs.pcv_type.is_relative();
                 if mixed_antex {
-                    return Err(MergeError::AntexAbsoluteRelativeMismatch);
+                    return Err(MergeError::Other);
                 }
                 //TODO: merge_mut_option(&mut lhs.reference_sn, &rhs.reference_sn);
             }
@@ -2175,16 +2177,19 @@ impl Merge for Header {
         if let Some(lhs) = &mut self.ionex {
             if let Some(rhs) = &rhs.ionex {
                 if lhs.reference != rhs.reference {
-                    return Err(MergeError::IonexReferenceMismatch);
+                    return Err(MergeError::ReferenceFrameMismatch);
                 }
+
                 if lhs.grid != rhs.grid {
-                    return Err(MergeError::IonexMapGridMismatch);
+                    return Err(MergeError::Other);
                 }
+
                 if lhs.map_dimension != rhs.map_dimension {
-                    return Err(MergeError::IonexMapDimensionsMismatch);
+                    return Err(MergeError::DimensionMismatch);
                 }
+
                 if lhs.base_radius != rhs.base_radius {
-                    return Err(MergeError::IonexBaseRadiusMismatch);
+                    return Err(MergeError::Other);
                 }
 
                 //TODO: this is not enough, need to take into account and rescale..
@@ -2204,10 +2209,12 @@ impl Merge for Header {
                 }
             }
         }
+
         // add special comment
-        let now = Epoch::now()?;
+        let now = Epoch::now().unwrap_or_default();
         let merge_comment = Self::merge_comment(now);
         self.comments.push(merge_comment);
+
         Ok(())
     }
 }