fits-header 0.1.0

Pure-Rust, MSVC-safe FITS header reader/writer: parse every card from a FITS file, CRUD single or multiple header keywords, then serialize back to a valid FITS object.
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

//! Record selectors.

/// Selects a record by keyword.
///
/// A bare name is **strict**: `get`/`set`/`remove` error with
/// [`FitsError::AmbiguousKeyword`](crate::FitsError::AmbiguousKeyword) if the keyword is
/// duplicated. The `(name, occurrence)` form targets exactly one record (0-based).
///
/// # Examples
///
/// ```
/// # use fits_header::Header;
/// let mut h = Header::new();
/// h.append("GAIN", 100).unwrap();
/// h.append("GAIN", 200).unwrap();
///
/// assert!(h.get::<i64>("GAIN").is_err()); // ambiguous bare name
/// assert_eq!(h.get::<i64>(("GAIN", 1)).unwrap(), Some(200)); // explicit occurrence
/// ```
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Key {
    /// The sole occurrence of a keyword (strict).
    Name(String),
    /// The n-th (0-based) occurrence of a keyword.
    Occurrence(String, usize),
}

impl Key {
    /// The keyword this key refers to.
    pub fn name(&self) -> &str {
        match self {
            Key::Name(n) | Key::Occurrence(n, _) => n,
        }
    }

    /// The selected occurrence index, if any.
    pub fn occurrence(&self) -> Option<usize> {
        match self {
            Key::Name(_) => None,
            Key::Occurrence(_, n) => Some(*n),
        }
    }
}

impl From<&str> for Key {
    fn from(name: &str) -> Self {
        Key::Name(name.to_string())
    }
}

impl From<String> for Key {
    fn from(name: String) -> Self {
        Key::Name(name)
    }
}

impl From<&String> for Key {
    fn from(name: &String) -> Self {
        Key::Name(name.clone())
    }
}

impl From<(&str, usize)> for Key {
    fn from((name, n): (&str, usize)) -> Self {
        Key::Occurrence(name.to_string(), n)
    }
}

impl From<(String, usize)> for Key {
    fn from((name, n): (String, usize)) -> Self {
        Key::Occurrence(name, n)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn conversions_and_accessors() {
        let k: Key = "GAIN".into();
        assert_eq!(k, Key::Name("GAIN".to_string()));
        assert_eq!(k.name(), "GAIN");
        assert_eq!(k.occurrence(), None);

        let k: Key = ("GAIN".to_string()).into();
        assert_eq!(k.name(), "GAIN");
        let k: Key = (&"GAIN".to_string()).into();
        assert_eq!(k.name(), "GAIN");

        let k: Key = ("GAIN", 1).into();
        assert_eq!(k, Key::Occurrence("GAIN".to_string(), 1));
        assert_eq!(k.name(), "GAIN");
        assert_eq!(k.occurrence(), Some(1));
        let k: Key = ("GAIN".to_string(), 2).into();
        assert_eq!(k.occurrence(), Some(2));
    }
}