Struct serde_with::DurationSeconds

pub struct DurationSeconds<FORMAT: Format = u64, STRICTNESS: Strictness = Strict>(_);

De/Serialize Durations as number of seconds.

De/serialize durations as number of seconds with subsecond precision. Subsecond precision is only supported for DurationSecondsWithFrac, but not for DurationSeconds. 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 u64 deserialization from a f64 will error. formats::Flexible means that deserialization will perform a best effort to extract the correct duration and allows deserialization from any type. For example, deserializing DurationSeconds<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::Duration with the chrono-feature flag.

Duration Type	Converter	Available FORMATs
std::time::Duration	DurationSeconds	u64, f64, String
std::time::Duration	DurationSecondsWithFrac	f64, String
chrono::Duration	DurationSeconds	i64, f64, String
chrono::Duration	DurationSecondsWithFrac	f64, String

Examples

use std::time::Duration;

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Durations {
    #[serde_as(as = "DurationSeconds<u64>")]
    d_u64: Duration,
    #[serde_as(as = "DurationSeconds<f64>")]
    d_f64: Duration,
    #[serde_as(as = "DurationSeconds<String>")]
    d_string: Duration,
};

// Serialization
// See how the values get rounded, since subsecond precision is not allowed.

let d = Durations {
    d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds
    d_f64: Duration::new(12345, 500_000_000),
    d_string: Duration::new(12345, 999_999_999),
};
// Observe the different datatypes
let expected = json!({
    "d_u64": 12345,
    "d_f64": 12346.0,
    "d_string": "12346",
});
assert_eq!(expected, serde_json::to_value(&d).unwrap());

// Deserialization works too
// Subsecond precision in numbers will be rounded away

let json = json!({
    "d_u64": 12345,
    "d_f64": 12345.5,
    "d_string": "12346",
});
let expected = Durations {
    d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds
    d_f64: Duration::new(12346, 0),
    d_string: Duration::new(12346, 0),
};
assert_eq!(expected, serde_json::from_value(json).unwrap());

chrono::Duration is also supported when using the chrono feature. It is a signed duration, thus can be de/serialized as an i64 instead of a u64.

use chrono::Duration;

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Durations {
    #[serde_as(as = "DurationSeconds<i64>")]
    d_i64: Duration,
    #[serde_as(as = "DurationSeconds<f64>")]
    d_f64: Duration,
    #[serde_as(as = "DurationSeconds<String>")]
    d_string: Duration,
};

// Serialization
// See how the values get rounded, since subsecond precision is not allowed.

let d = Durations {
    d_i64: Duration::seconds(-12345),
    d_f64: Duration::seconds(-12345) + Duration::milliseconds(500),
    d_string: Duration::seconds(12345) + Duration::nanoseconds(999_999_999),
};
// Observe the different datatypes
let expected = json!({
    "d_i64": -12345,
    "d_f64": -12345.0,
    "d_string": "12346",
});
assert_eq!(expected, serde_json::to_value(&d).unwrap());

// Deserialization works too
// Subsecond precision in numbers will be rounded away

let json = json!({
    "d_i64": -12345,
    "d_f64": -12345.5,
    "d_string": "12346",
});
let expected = Durations {
    d_i64: Duration::seconds(-12345),
    d_f64: Duration::seconds(-12346),
    d_string: Duration::seconds(12346),
};
assert_eq!(expected, serde_json::from_value(json).unwrap());

Trait Implementations

impl<FORMAT: Clone + Format, STRICTNESS: Clone + Strictness> Clone for DurationSeconds<FORMAT, STRICTNESS>

fn clone(&self) -> DurationSeconds<FORMAT, STRICTNESS>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<FORMAT: Debug + Format, STRICTNESS: Debug + Strictness> Debug for DurationSeconds<FORMAT, STRICTNESS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<FORMAT: Default + Format, STRICTNESS: Default + Strictness> Default for DurationSeconds<FORMAT, STRICTNESS>

fn default() -> DurationSeconds<FORMAT, STRICTNESS>

Returns the “default value” for a type.

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<u64, Strict>

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<f64, Strict>

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, Duration> for DurationSeconds<String, Strict>

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'de, FORMAT> DeserializeAs<'de, Duration> for DurationSeconds<FORMAT, Flexible> where
    FORMAT: Format, 

fn deserialize_as<D>(deserializer: D) -> Result<Duration, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<u64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<FORMAT: Copy + Format, STRICTNESS: Copy + Strictness> Copy for DurationSeconds<FORMAT, STRICTNESS>