pub struct TimestampSeconds<FORMAT: Format = i64, STRICTNESS: Strictness = Strict>(_);
Expand description

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 TypeConverterAvailable FORMATs
std::time::SystemTimeTimestampSecondsi64, f64, String
std::time::SystemTimeTimestampSecondsWithFracf64, String
chrono::DateTime<Utc>TimestampSecondsi64, f64, String
chrono::DateTime<Utc>TimestampSecondsWithFracf64, String
chrono::DateTime<Local>TimestampSecondsi64, f64, String
chrono::DateTime<Local>TimestampSecondsWithFracf64, 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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Deserialize this value from the given Serde deserializer.

Deserialize this value from the given Serde deserializer.

Deserialize this value from the given Serde deserializer.

Deserialize this value from the given Serde deserializer.

Serialize this value into the given Serde serializer.

Serialize this value into the given Serde serializer.

Serialize this value into the given Serde serializer.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.