use ::jiff_1::{
civil::{Date, DateTime, Time},
SignedDuration, Span, Timestamp, ZonedDateTime,
};
use crate::Configuration;
impl Configuration for Timestamp {
type Builder = Option<Self>;
}
impl Configuration for ZonedDateTime {
type Builder = Option<Self>;
}
impl Configuration for Date {
type Builder = Option<Self>;
}
impl Configuration for Time {
type Builder = Option<Self>;
}
impl Configuration for DateTime {
type Builder = Option<Self>;
}
impl Configuration for Span {
type Builder = Option<Self>;
}
impl Configuration for SignedDuration {
type Builder = Option<Self>;
}
macro_rules! optional_module {
($(#[$attr:meta])* $T:ty, $serialize_fn:path, $deserialize_fn:path) => {
$(#[$attr])*
pub mod optional {
use serde::{Deserializer, Serializer};
use crate::std_impls::OptionBuilder;
pub fn serialize<S>(
value: &OptionBuilder<Option<$T>>,
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let opt = match value {
OptionBuilder::Unspecified
| OptionBuilder::None
| OptionBuilder::Some(None) => None,
OptionBuilder::Some(Some(val)) => Some(*val),
};
$serialize_fn(&opt, serializer)
}
pub fn deserialize<'de, D>(d: D) -> Result<OptionBuilder<Option<$T>>, D::Error>
where
D: Deserializer<'de>,
{
let opt: Option<$T> = $deserialize_fn(d)?;
Ok(opt.map(Some).into())
}
}
};
}
macro_rules! forward_option_builder {
(fn $($seg:ident)::+, $T:ty) => {
optional_module!(
$T,
::jiff_1::fmt::serde::$($seg)::+::optional,
serde::Deserialize::deserialize
);
};
($($seg:ident)::+, $T:ty) => {
optional_module!(
$T,
::jiff_1::fmt::serde::$($seg)::+::optional::serialize,
::jiff_1::fmt::serde::$($seg)::+::optional::deserialize
);
};
}
pub mod duration {
pub mod friendly {
pub mod compact {
forward_option_builder!(fn duration::friendly::compact, ::jiff_1::SignedDuration);
}
}
}
pub mod span {
pub mod friendly {
pub mod compact {
forward_option_builder!(fn span::friendly::compact, ::jiff_1::Span);
}
}
}
pub mod timestamp {
pub mod second {
forward_option_builder!(timestamp::second, ::jiff_1::Timestamp);
}
pub mod millisecond {
forward_option_builder!(timestamp::millisecond, ::jiff_1::Timestamp);
}
pub mod microsecond {
forward_option_builder!(timestamp::microsecond, ::jiff_1::Timestamp);
}
pub mod nanosecond {
forward_option_builder!(timestamp::nanosecond, ::jiff_1::Timestamp);
pub mod optional_i128 {
use ::jiff_1::Timestamp;
use serde::{Deserialize, Deserializer};
pub use super::optional::serialize;
use crate::std_impls::OptionBuilder;
#[derive(Deserialize)]
#[serde(transparent)]
struct NanosecondTimestamp(
#[serde(
deserialize_with = "::jiff_1::fmt::serde::timestamp::nanosecond::required::deserialize"
)]
Timestamp,
);
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<OptionBuilder<Option<Timestamp>>, D::Error>
where
D: Deserializer<'de>,
{
let timestamp = Option::<NanosecondTimestamp>::deserialize(deserializer)?;
Ok(timestamp.map(|value| Some(value.0)).into())
}
}
}
}
pub mod unsigned_duration {
forward_option_builder!(unsigned_duration, std::time::Duration);
pub mod days_are_24_hours;
pub mod friendly {
pub mod compact {
forward_option_builder!(unsigned_duration::friendly::compact, std::time::Duration);
}
}
}