[−][src]Struct serde_with::TimestampSeconds
De/Serialize timestamps as seconds since the UNIX epoch
De/serialize timestamps as seconds since the UNIX epoch.
Subsecond precision is only supported for TimestampSecondsWithFrac
, but not for TimestampSeconds
.
You can configure the serialization format between integers, floats, and stringified numbers with the FORMAT
specifier and configure the deserialization with the STRICTNESS
specifier.
The STRICTNESS
specifier can either be formats::Strict
or formats::Flexible
and defaults to formats::Strict
.
formats::Strict
means that deserialization only supports the type given in FORMAT
, e.g., if FORMAT
is i64
deserialization from a f64
will error.
formats::Flexible
means that deserialization will perform a best effort to extract the correct timestamp and allows deserialization from any type.
For example, deserializing TimestampSeconds<f64, Flexible>
will discard any subsecond precision during deserialization from f64
and will parse a String
as an integer number.
This type also supports chrono::DateTime
with the chrono
-feature flag.
Timestamp Type | Converter | Available FORMAT s |
---|---|---|
std::time::SystemTime | TimestampSeconds | i64 , f64 , String |
std::time::SystemTime | TimestampSecondsWithFrac | f64 , String |
chrono::DateTime<Utc> | TimestampSeconds | i64 , f64 , String |
chrono::DateTime<Utc> | TimestampSecondsWithFrac | f64 , String |
chrono::DateTime<Local> | TimestampSeconds | i64 , f64 , String |
chrono::DateTime<Local> | TimestampSecondsWithFrac | f64 , String |
Examples
use std::time::{Duration, SystemTime}; #[serde_as] #[derive(Deserialize, Serialize)] struct Timestamps { #[serde_as(as = "TimestampSeconds<i64>")] st_i64: SystemTime, #[serde_as(as = "TimestampSeconds<f64>")] st_f64: SystemTime, #[serde_as(as = "TimestampSeconds<String>")] st_string: SystemTime, }; // Serialization // See how the values get rounded, since subsecond precision is not allowed. let ts = Timestamps { st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(), st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(), st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 999_999_999)).unwrap(), }; // Observe the different datatypes let expected = json!({ "st_i64": 12345, "st_f64": 12346.0, "st_string": "12346", }); assert_eq!(expected, serde_json::to_value(&ts).unwrap()); // Deserialization works too // Subsecond precision in numbers will be rounded away let json = json!({ "st_i64": 12345, "st_f64": 12345.5, "st_string": "12346", }); let expected = Timestamps { st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(), st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(), st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(), }; assert_eq!(expected, serde_json::from_value(json).unwrap());
chrono::DateTime<Utc>
and chrono::DateTime<Local>
are also supported when using the chrono
feature.
Like SystemTime
, it is a signed timestamp, thus can be de/serialized as an i64
.
use chrono::{DateTime, Local, TimeZone, Utc}; #[serde_as] #[derive(Deserialize, Serialize)] struct Timestamps { #[serde_as(as = "TimestampSeconds<i64>")] dt_i64: DateTime<Utc>, #[serde_as(as = "TimestampSeconds<f64>")] dt_f64: DateTime<Local>, #[serde_as(as = "TimestampSeconds<String>")] dt_string: DateTime<Utc>, }; // Serialization // See how the values get rounded, since subsecond precision is not allowed. let ts = Timestamps { dt_i64: Utc.timestamp(-12345, 0), dt_f64: Local.timestamp(-12345, 500_000_000), dt_string: Utc.timestamp(12345, 999_999_999), }; // Observe the different datatypes let expected = json!({ "dt_i64": -12345, "dt_f64": -12345.0, "dt_string": "12346", }); assert_eq!(expected, serde_json::to_value(&ts).unwrap()); // Deserialization works too // Subsecond precision in numbers will be rounded away let json = json!({ "dt_i64": -12345, "dt_f64": -12345.5, "dt_string": "12346", }); let expected = Timestamps { dt_i64: Utc.timestamp(-12345, 0), dt_f64: Local.timestamp(-12346, 0), dt_string: Utc.timestamp(12346, 0), }; assert_eq!(expected, serde_json::from_value(json).unwrap());
Trait Implementations
impl<FORMAT: Clone + Format, STRICTNESS: Clone + Strictness> Clone for TimestampSeconds<FORMAT, STRICTNESS>
[src]
pub fn clone(&self) -> TimestampSeconds<FORMAT, STRICTNESS>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<FORMAT: Copy + Format, STRICTNESS: Copy + Strictness> Copy for TimestampSeconds<FORMAT, STRICTNESS>
[src]
impl<FORMAT: Debug + Format, STRICTNESS: Debug + Strictness> Debug for TimestampSeconds<FORMAT, STRICTNESS>
[src]
impl<FORMAT: Default + Format, STRICTNESS: Default + Strictness> Default for TimestampSeconds<FORMAT, STRICTNESS>
[src]
pub fn default() -> TimestampSeconds<FORMAT, STRICTNESS>
[src]
impl<'de> DeserializeAs<'de, DateTime<Local>> for TimestampSeconds<i64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Local>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, DateTime<Local>> for TimestampSeconds<f64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Local>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, DateTime<Local>> for TimestampSeconds<String, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Local>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de, FORMAT> DeserializeAs<'de, DateTime<Local>> for TimestampSeconds<FORMAT, Flexible> where
FORMAT: Format,
[src]
FORMAT: Format,
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Local>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds<i64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Utc>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds<f64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Utc>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds<String, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Utc>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de, FORMAT> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds<FORMAT, Flexible> where
FORMAT: Format,
[src]
FORMAT: Format,
pub fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Utc>, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, SystemTime> for TimestampSeconds<i64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<SystemTime, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, SystemTime> for TimestampSeconds<f64, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<SystemTime, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de> DeserializeAs<'de, SystemTime> for TimestampSeconds<String, Strict>
[src]
pub fn deserialize_as<D>(deserializer: D) -> Result<SystemTime, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<'de, FORMAT> DeserializeAs<'de, SystemTime> for TimestampSeconds<FORMAT, Flexible> where
FORMAT: Format,
[src]
FORMAT: Format,
pub fn deserialize_as<D>(deserializer: D) -> Result<SystemTime, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<i64, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<f64, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<String, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
Auto Trait Implementations
impl<FORMAT, STRICTNESS> RefUnwindSafe for TimestampSeconds<FORMAT, STRICTNESS> where
FORMAT: RefUnwindSafe,
STRICTNESS: RefUnwindSafe,
FORMAT: RefUnwindSafe,
STRICTNESS: RefUnwindSafe,
impl<FORMAT, STRICTNESS> Send for TimestampSeconds<FORMAT, STRICTNESS> where
FORMAT: Send,
STRICTNESS: Send,
FORMAT: Send,
STRICTNESS: Send,
impl<FORMAT, STRICTNESS> Sync for TimestampSeconds<FORMAT, STRICTNESS> where
FORMAT: Sync,
STRICTNESS: Sync,
FORMAT: Sync,
STRICTNESS: Sync,
impl<FORMAT, STRICTNESS> Unpin for TimestampSeconds<FORMAT, STRICTNESS> where
FORMAT: Unpin,
STRICTNESS: Unpin,
FORMAT: Unpin,
STRICTNESS: Unpin,
impl<FORMAT, STRICTNESS> UnwindSafe for TimestampSeconds<FORMAT, STRICTNESS> where
FORMAT: UnwindSafe,
STRICTNESS: UnwindSafe,
FORMAT: UnwindSafe,
STRICTNESS: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,