parse string to std::time::Duration

Support

The duration-str support multiple Duration: * https://doc.rust-lang.org/stable/std/time/struct.Duration.html * https://docs.rs/chrono/latest/chrono/struct.Duration.html * https://docs.rs/time/latest/time/struct.Duration.html#

Notice ⚠️

The default duration unit is second.Also use below duration unit

Duration Unit List

Parse string to Duration . The String duration unit support for one of:["y","mon","w","d","h","m","s", "ms", "µs", "ns"]

| unit | Description | unit list option(one of) | example | | ---- | ----------- |----------------------------------------------------------------------------------------------------| ------- | | y | Year | ["y" , "year" , "Y" , "YEAR" , "Year"] | 1y | | mon | Month | ["mon" , "MON" , "Month" , "month" , "MONTH"] | 1mon | | w | Week | ["w" , "W" , "Week" ,"WEEK" , "week"] | 1w | | d | Day | ["d" , "D" , "Day" , "DAY" , "day"] | 1d | | h | Hour | ["h" , "hr" , "H" , "Hour" , "HOUR" , "hour"] | 1h | | m | Minute | ["m" , "M" , "Minute" , "MINUTE" , "minute" , "min" , "MIN"] | 1m | | s | Second | ["s" , "S" , "Second" , "SECOND" , "second" , "sec" , "SEC"] | 1s | | ms | Millisecond | ["ms" , "MS" , "Millisecond" , "MilliSecond" , "MILLISECOND" , "millisecond" , "mSEC"] | 1ms | | µs | Microsecond | ["µs" , "µS" , "µsecond" , "Microsecond" , "MicroSecond" , "MICROSECOND" , "microsecond" , "µSEC"] | 1µs | | ns | Nanosecond | ["ns" , "NS" , "Nanosecond" , "NanoSecond" , "NANOSECOND" , "nanosecond" , "nSEC"] | 1ns |

Also,duration_str support time duration simple evaluation(+,*). See example:

example

toml [dependencies] duration-str = "{latest version}"

```rust use duration_str::parse; use std::time::Duration;

fn main() { let duration = parse("1d").unwrap(); assert_eq!(duration, Duration::new(24 * 60 * 60, 0));

let duration = parse("3m+31").unwrap(); //the default duration unit is second.
assert_eq!(duration, Duration::new(211, 0));

let duration = parse("3m + 31").unwrap(); //the default duration unit is second.
assert_eq!(duration, Duration::new(211, 0));

let duration = parse("3m + 13s + 29ms").unwrap();
assert_eq!(duration, Duration::new(193, 29 * 1000 * 1000 + 0 + 0));

let duration = parse("3m + 1s + 29ms +17µs").unwrap();
assert_eq!(
    duration,
    Duration::new(181, 29 * 1000 * 1000 + 17 * 1000 + 0)
);

let duration = parse("1m*10").unwrap(); //the default duration unit is second.
assert_eq!(duration, Duration::new(600, 0));

let duration = parse("1m*10ms").unwrap();
assert_eq!(duration, Duration::new(0, 600 * 1000 * 1000));

let duration = parse("1m * 1ns").unwrap();
assert_eq!(duration, Duration::new(0, 60));

let duration = parse("1m * 1m").unwrap();
assert_eq!(duration, Duration::new(3600, 0));

} ```

deserialize in struct

deserialize to std::time::Duration

```rust use durationstr::deserializeduration; use serde::*; use std::time::Duration;

[derive(Debug, Deserialize)]

struct Config { #[serde(deserializewith = "deserializeduration")] time_ticker: Duration, }

fn main() { let json = r#"{"timeticker":"1m+30"}"#; let config: Config = serdejson::fromstr(json).unwrap(); asserteq!(config.time_ticker, Duration::new(60 + 30, 0));

let json = r#"{"time_ticker":"1m+30s"}"#;
let config: Config = serde_json::from_str(json).unwrap();
assert_eq!(config.time_ticker, Duration::new(60 + 30, 0));

} ```

• option filed deserialize

```rust use durationstr::deserializeoption_duration; use serde::*; use std::time::Duration;

[derive(Debug, Deserialize, PartialEq)]

struct Config { #[serde(default, deserializewith = "deserializeoptionduration")] timeticker: Option, name: String, }

fn main() { let json = r#"{"timeticker":null,"name":"foo"}"#; let config: Config = serdejson::from_str(json).unwrap();

assert_eq!(
    config,
    Config {
        time_ticker: None,
        name: "foo".into()
    }
);

let json = r#"{"name":"foo"}"#;
let config: Config = serde_json::from_str(json).unwrap();
assert_eq!(
    config,
    Config {
        time_ticker: None,
        name: "foo".into()
    }
);

} `` Also you can usedeserializedurationchronoordeserializedurationtime` function

E.g:

```rust use chrono::Duration; use durationstr::deserializeduration_chrono; use serde::*;

[derive(Debug, Deserialize)]

struct Config { #[serde(deserializewith = "deserializedurationchrono")] timeticker: Duration, }

fn main() { let json = r#"{"timeticker":"1m+30"}"#; let config: Config = serdejson::fromstr(json).unwrap(); asserteq!(config.time_ticker, Duration::seconds(60 + 30)); } ```