use std::{
error::Error,
fmt::{self, Display, Formatter},
};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as _};
use time::{OffsetDateTime, UtcOffset, format_description::well_known::Rfc3339};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ObservationTime {
instant: OffsetDateTime,
wire: Box<str>,
}
impl ObservationTime {
pub fn try_new(value: OffsetDateTime) -> Result<Self, ObservationTimeError> {
let instant = value.to_offset(UtcOffset::UTC);
let wire = instant
.format(&Rfc3339)
.map_err(ObservationTimeError::Format)?;
Ok(Self {
instant,
wire: wire.into_boxed_str(),
})
}
pub fn parse(value: &str) -> Result<Self, ObservationTimeError> {
let instant =
OffsetDateTime::parse(value, &Rfc3339).map_err(ObservationTimeError::Parse)?;
Self::try_new(instant)
}
pub fn as_str(&self) -> &str {
&self.wire
}
pub const fn instant(&self) -> OffsetDateTime {
self.instant
}
}
impl Display for ObservationTime {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl Serialize for ObservationTime {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for ObservationTime {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = <Box<str>>::deserialize(deserializer)?;
Self::parse(&value).map_err(D::Error::custom)
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum ObservationTimeError {
Parse(time::error::Parse),
Format(time::error::Format),
}
impl Display for ObservationTimeError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::Parse(error) => write!(formatter, "parse observation time: {error}"),
Self::Format(error) => write!(formatter, "format observation time: {error}"),
}
}
}
impl Error for ObservationTimeError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Parse(error) => Some(error),
Self::Format(error) => Some(error),
}
}
}