serde-duration-ext 0.1.0

Serde support for std::time::Duration and chrono::Duration (chrono feature)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

# Serde support for Duration and chrono::Duration

## Installation

Add the following to your Cargo.toml:

```toml
[dependencies]
serde_duration_ext = "0.1.0"
```

Also you can enable the `chrono` feature to support chrono::Duration

```toml
[dependencies]
serde_duration_ext = { version = "0.1.0", features = ["chrono"] }
```

## Usage

```rust
use serde::{Serialize, Deserialize};
use serde_json;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Foo {
    #[serde(with = "serde_duration_ext")]
    duration: std::time::Duration,
}

fn main() {
    let foo = Foo {
        duration: std::time::Duration::from_secs(123),
    };
    let json = serde_json::to_string(&foo).unwrap();
    assert_eq!(json, r#"{"duration":"123s"}"#);

    let foo2: Foo = serde_json::from_str(&json).unwrap();
    assert_eq!(foo, foo2);
}
```

You can also use `chrono::Duration` if you enable the `chrono` feature.

```rust
use serde::{Serialize, Deserialize};
use serde_json;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Foo {
    #[serde(with = "serde_duration_ext::chrono")]
    duration: chrono::Duration,
}

fn main() {
    let foo = Foo {
        duration: chrono::Duration::seconds(123),
    };
    let json = serde_json::to_string(&foo).unwrap();
    assert_eq!(json, r#"{"duration":"123s"}"#);

    let foo2: Foo = serde_json::from_str(&json).unwrap();
    assert_eq!(foo, foo2);
}
```

Library also provides useful types such as `DurationUnit` and `TimeUnit`

```rust
use serde::{Serialize, Deserialize};
use serde_json;

use serde_duration_ext::DurationUnit;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Foo {
    duration: DurationUnit,
}

fn main() {
    let foo = Foo {
        duration: DurationUnit::from_secs(123),
    };
    let json = serde_json::to_string(&foo).unwrap();
    assert_eq!(json, r#"{"duration":"123s"}"#);

    let foo2: Foo = serde_json::from_str(&json).unwrap();
    assert_eq!(foo, foo2);
}
```