10112017133

Committed 26 Jul 2024 01:23PM UTC coverage: 76.094% (-0.7%) from 76.797%

Build # 10112017133

Build Type

Pull #332

github

Committed by

web-flow

Commit Message

Merge eb2ec2a44 into 1ebd973b6

Pull Request Pull Request #332: feat: POC header comment API design

Run Details

108 of 146 new or added lines in 2 files covered. (73.97%)

904 of 1188 relevant lines covered (76.09%)

2.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.0

/fitsio/src/headers/header_value.rs

//! 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)
    }
}

1	//! Header values (values + comemnts)
2	//!
3
4	use std::fmt::Debug;
5
6	use super::ReadsKey;
7
8	/// Struct representing a FITS header value
9	pub struct HeaderValue<T> {
10	/// Value of the header card
11	pub value: T,
12
13	/// Optional comment of the header card
14	pub comment: Option<String>,
15	}
16
17	/// Allow printing of `HeaderValue`s
18	impl<T> Debug for HeaderValue<T>
19	where
20	T: Debug,
21	{
NEW 22	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
NEW 23	f.debug_struct("HeaderValue")	×
NEW 24	.field("value", &self.value)	×
NEW 25	.field("comment", &self.comment)	×
26	.finish()
27	}
28	}
29
30	/// Allow comparing of `HeaderValue`'s where the `value` is equatable
31	/// so that e.g. `HeaderValue<f64>` can be compared to `f64`
32	impl<T> PartialEq<T> for HeaderValue<T>
33	where
34	T: PartialEq,
35	{
36	fn eq(&self, other: &T) -> bool {	1✔
37	self.value == *other	1✔
38	}
39	}
40
41	/// Allow `HeaderValue` to be cloned
42	///
43	/// ```rust
44	/// # use fitsio::headers::HeaderValue;
45	/// let mut hv = HeaderValue {
46	/// value: 1u16,
47	/// comment: None,
48	/// };
49	/// let hv2 = hv.clone();
50	///
51	/// hv.value = 10;
52	/// assert_eq!(hv2.value, 1);
53	/// ```
54	impl<T> Clone for HeaderValue<T>
55	where
56	T: Clone,
57	{
NEW 58	fn clone(&self) -> Self {	×
59	HeaderValue {
NEW 60	value: self.value.clone(),	×
NEW 61	comment: self.comment.clone(),	×
62	}
63	}
64	}
65
66	/// Default value of `HeaderValue<T>`
67	///
68	/// ```rust
69	/// # use fitsio::headers::HeaderValue;
70	/// let hv = HeaderValue::<i32>::default();
71	/// assert_eq!(hv.value, 0);
72	/// ```
73	impl<T> Default for HeaderValue<T>
74	where
75	T: Default,
76	{
77	fn default() -> Self {	3✔
78	Self {
NEW 79	value: Default::default(),	×
80	comment: Default::default(),	3✔
81	}
82	}
83	}
84
85	impl<T> HeaderValue<T>
86	where
87	T: ReadsKey,
88	{
89	/// Map the _value_ of a [`HeaderValue`] to another form
90	/// ```rust
91	/// # use fitsio::headers::HeaderValue;
92	/// let hv = HeaderValue { value: 1, comment: None };
93	/// let hv2 = hv.map(\|value\| value * 2);
94	/// assert_eq!(hv2.value, 2);
95	/// ```
NEW 96	pub fn map<U, F>(self, f: F) -> HeaderValue<U>	×
97	where
98	F: FnOnce(T) -> U,
99	{
100	HeaderValue {
NEW 101	value: f(self.value),	×
NEW 102	comment: self.comment,	×
103	}
104	}
105
106	/// Monadic "bind" for [`HeaderValue`]
107	/// ```rust
108	/// # use fitsio::headers::HeaderValue;
109	/// let hv = HeaderValue { value: 1, comment: None };
110	/// let hv2 = hv.and_then(\|v\| HeaderValue {
111	/// value: v * 2,
112	/// comment: Some("ok".to_string()),
113	/// });
114	/// assert_eq!(hv2.value, 2);
115	/// assert_eq!(hv2.comment, Some("ok".to_string()));
116	/// ```
117	pub fn and_then<U, F>(self, f: F) -> HeaderValue<U>
118	where
119	F: FnOnce(T) -> HeaderValue<U>,
120	{
NEW 121	f(self.value)	×
122	}
123	}

simonrw / rust-fitsio / 10112017133

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous