ascom-alpaca 1.0.0-beta.10

Rust implementation of the ASCOM Alpaca API for astronomy devices
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

use std::time::SystemTime;

#[cfg(feature = "server")]
pub(crate) mod ser;

#[cfg(feature = "client")]
pub(crate) mod de;

/// A wrapper for the device-specific state with the common optional timestamp field.
#[derive(Default, Debug, Clone, derive_more::Deref, derive_more::DerefMut)]
#[cfg_attr(feature = "server", derive(serde::Serialize))]
#[cfg_attr(feature = "client", derive(serde::Deserialize))]
pub struct TimestampedDeviceState<T> {
    /// The timestamp of the last update to the state, if available.
    #[serde(
        rename = "TimeStamp",
        skip_serializing_if = "Option::is_none",
        with = "timestamp"
    )]
    pub timestamp: Option<SystemTime>,
    /// The device-specific state.
    #[deref]
    #[deref_mut]
    #[serde(flatten)]
    pub state: T,
}

impl<T> TimestampedDeviceState<T> {
    /// Create a new `TimestampedDeviceState` with the given state and the current timestamp.
    pub fn new(state: T) -> Self {
        Self {
            timestamp: Some(SystemTime::now()),
            state,
        }
    }
}

mod timestamp {
    use crate::api::time_repr::{Iso8601, TimeRepr};
    use std::time::SystemTime;

    #[cfg(feature = "server")]
    use serde::{Serialize, Serializer};

    #[cfg(feature = "client")]
    use serde::{Deserialize, Deserializer};

    #[cfg(feature = "server")]
    #[allow(clippy::ref_option)]
    pub(super) fn serialize<S: Serializer>(
        timestamp: &Option<SystemTime>,
        serializer: S,
    ) -> Result<S::Ok, S::Error> {
        TimeRepr::<Iso8601>::from(timestamp.unwrap_or_else(|| unreachable!())).serialize(serializer)
    }

    #[cfg(feature = "client")]
    pub(super) fn deserialize<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Option<SystemTime>, D::Error> {
        let timestamp = Option::<TimeRepr<Iso8601>>::deserialize(deserializer)?;
        Ok(timestamp.map(SystemTime::from))
    }
}