moc 0.19.2

Library made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
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

//! Module containing operations between n MOCs generating a MOC.

use crate::moc::{
  range::op::multi_op::{kway_and_it, kway_or_it, kway_xor_it},
  RangeMOCIntoIterator,
};

use super::{
  common::{InternalMoc, FMOC, SMOC, TMOC},
  store,
};

#[derive(Copy, Clone)]
pub(crate) enum OpN {
  Intersection,
  Union,
  SymmetricDifference,
}

impl OpN {
  fn perform_op_on_smoc(self, mocs: Vec<&SMOC>) -> Result<SMOC, String> {
    let it = Box::new(mocs.iter().map(|moc_ref| moc_ref.into_range_moc_iter()));
    match self {
      OpN::Intersection => Ok(kway_and_it(it)),
      OpN::Union => Ok(kway_or_it(it)),
      OpN::SymmetricDifference => Ok(kway_xor_it(it)),
    }
  }

  fn perform_op_on_tmoc(self, mocs: Vec<&TMOC>) -> Result<TMOC, String> {
    let it = Box::new(mocs.iter().map(|moc_ref| moc_ref.into_range_moc_iter()));
    match self {
      OpN::Intersection => Ok(kway_and_it(it)),
      OpN::Union => Ok(kway_or_it(it)),
      OpN::SymmetricDifference => Ok(kway_xor_it(it)),
    }
  }

  fn perform_op_on_fmoc(self, mocs: Vec<&FMOC>) -> Result<FMOC, String> {
    let it = Box::new(mocs.iter().map(|moc_ref| moc_ref.into_range_moc_iter()));
    match self {
      OpN::Intersection => Ok(kway_and_it(it)),
      OpN::Union => Ok(kway_or_it(it)),
      OpN::SymmetricDifference => Ok(kway_xor_it(it)),
    }
  }

  /// Performs the given operation on the given MOCs and store the resulting MOC in the store.
  pub(crate) fn exec(&self, indices: &[usize]) -> Result<usize, String> {
    store::opn(indices, move |mocs| match mocs.first() {
      Some(InternalMoc::Space(_)) => {
        let mocs: Vec<&SMOC> = mocs
          .iter()
          .map(|moc| {
            if let InternalMoc::Space(moc) = moc {
              Ok(moc)
            } else {
              Err(String::from(
                "Multi operations must apply on a same MOC type",
              ))
            }
          })
          .collect::<Result<_, _>>()?;
        self.perform_op_on_smoc(mocs).map(InternalMoc::Space)
      }
      Some(InternalMoc::Time(_)) => {
        let mocs: Vec<&TMOC> = mocs
          .iter()
          .map(|moc| {
            if let InternalMoc::Time(moc) = moc {
              Ok(moc)
            } else {
              Err(String::from(
                "Multi operations must apply on a same MOC type",
              ))
            }
          })
          .collect::<Result<_, _>>()?;
        self.perform_op_on_tmoc(mocs).map(InternalMoc::Time)
      }
      Some(InternalMoc::Frequency(_)) => {
        let mocs: Vec<&FMOC> = mocs
          .iter()
          .map(|moc| {
            if let InternalMoc::Frequency(moc) = moc {
              Ok(moc)
            } else {
              Err(String::from(
                "Multi operations must apply on a same MOC type",
              ))
            }
          })
          .collect::<Result<_, _>>()?;
        self.perform_op_on_fmoc(mocs).map(InternalMoc::Frequency)
      }
      Some(InternalMoc::TimeSpace(_)) => Err(String::from("No opN operations for ST-MOCs")),
      Some(InternalMoc::FreqSpace(_)) => Err(String::from("No opN operations for SF-MOCs")),
      None => Err(String::from("Empty MOC list")),
    })
  }
}