fitsio 0.21.9

Rust implmentation of astronomy fits file handling
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Header values (values + comemnts)
//!

use std::fmt::Debug;

use super::ReadsKey;

/// Struct representing a FITS header value
pub struct HeaderValue<T> {
    /// Value of the header card
    pub value: T,

    /// Optional comment of the header card
    pub comment: Option<String>,
}

/// Allow printing of `HeaderValue`s
impl<T> Debug for HeaderValue<T>
where
    T: Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("HeaderValue")
            .field("value", &self.value)
            .field("comment", &self.comment)
            .finish()
    }
}

/// Allow comparing of `HeaderValue`'s where the `value` is equatable
/// so that e.g. `HeaderValue<f64>` can be compared to `f64`
impl<T> PartialEq<T> for HeaderValue<T>
where
    T: PartialEq,
{
    fn eq(&self, other: &T) -> bool {
        self.value == *other
    }
}

/// Allow `HeaderValue` to be cloned
///
/// ```rust
/// # use fitsio::headers::HeaderValue;
/// let mut hv = HeaderValue {
///   value: 1u16,
///   comment: None,
/// };
/// let hv2 = hv.clone();
///
/// hv.value = 10;
/// assert_eq!(hv2.value, 1);
/// ```
impl<T> Clone for HeaderValue<T>
where
    T: Clone,
{
    fn clone(&self) -> Self {
        HeaderValue {
            value: self.value.clone(),
            comment: self.comment.clone(),
        }
    }
}

/// Default value of `HeaderValue<T>`
///
/// ```rust
/// # use fitsio::headers::HeaderValue;
/// let hv = HeaderValue::<i32>::default();
/// assert_eq!(hv.value, 0);
/// ```
impl<T> Default for HeaderValue<T>
where
    T: Default,
{
    fn default() -> Self {
        Self {
            value: Default::default(),
            comment: Default::default(),
        }
    }
}

impl<T> HeaderValue<T>
where
    T: ReadsKey,
{
    /// Map the _value_ of a [`HeaderValue`] to another form
    /// ```rust
    /// # use fitsio::headers::HeaderValue;
    /// let hv = HeaderValue { value: 1, comment: None };
    /// let hv2 = hv.map(|value| value * 2);
    /// assert_eq!(hv2.value, 2);
    /// ```
    pub fn map<U, F>(self, f: F) -> HeaderValue<U>
    where
        F: FnOnce(T) -> U,
    {
        HeaderValue {
            value: f(self.value),
            comment: self.comment,
        }
    }

    /// Monadic "bind" for [`HeaderValue`]
    /// ```rust
    /// # use fitsio::headers::HeaderValue;
    /// let hv = HeaderValue { value: 1, comment: None };
    /// let hv2 = hv.and_then(|v| HeaderValue {
    ///     value: v * 2,
    ///     comment: Some("ok".to_string()),
    /// });
    /// assert_eq!(hv2.value, 2);
    /// assert_eq!(hv2.comment, Some("ok".to_string()));
    /// ```
    pub fn and_then<U, F>(self, f: F) -> HeaderValue<U>
    where
        F: FnOnce(T) -> HeaderValue<U>,
    {
        f(self.value)
    }
}