Struct Duration 

pub struct Duration {
    pub secs: i64,
    pub nanos: i32,
}

A positive duration with second and nanosecond precision

Supports arithmetic operations (+, -, +=, -=) and conversion to/from standard library types.

Use try_new to safely create a Duration from values that may be negative.

Examples

use rstime::Duration;

let d = Duration::try_new(5, 500_000_000).unwrap();
assert_eq!(d.total_seconds(), 5.5);

Fields

secs: i64

Seconds component (must be >= 0 for valid Duration)

nanos: i32

Nanoseconds component (0..1_000_000_000, must be >= 0)

Implementations

impl Duration

pub const ZERO: Duration

Zero duration

pub const SECOND: Duration

One second

pub const MINUTE: Duration

One minute (60 seconds)

pub const HOUR: Duration

One hour (3600 seconds)

pub const DAY: Duration

One day (86400 seconds)

pub fn try_new(secs: i64, nanos: i32) -> Option<Duration>

Try to create a duration from seconds and nanoseconds.

Returns None if the result would be negative (duration must be positive). Normalizes nanoseconds into the 0..1_000_000_000 range.

Examples

use rstime::Duration;

assert!(Duration::try_new(5, 500_000_000).is_some());
assert!(Duration::try_new(-1, 0).is_none());

pub fn new(secs: i64, nanos: i32) -> Duration

Create a duration from seconds and nanoseconds (panics if negative).

Use try_new for safe creation.

Panics

Panics if the resulting duration would be negative.

pub fn from_secs(secs: i64) -> Duration

Create from seconds only

Examples found in repository

examples/demo.rs (line 51)

fn main() {
    println!("=== rstime 时间库使用示例 ===\n");

    println!("1. 获取当前时间");
    let now = DateTime::now();
    println!("   现在: {}\n", now);

    println!("2. 格式化输出");
    let dt = DateTime::from_ymd_hms_milli(2026, 5, 10, 14, 5, 9, 37);
    println!("   ISO 8601:  {}", dt.format("{YYYY}-{MM}-{DD}T{HH}:{mm}:{ss}"));
    println!("   中文格式:  {}", dt.format("{YYYY}年{MM}月{DD}日 {HH}:{mm}:{ss}"));
    println!("   12小时制:  {}", dt.format("{hh}:{mm}:{ss} {AMPM}"));
    println!("   星期:      {}", dt.format("{WW}"));
    println!("   毫秒:      {}", dt.format("{SSS}"));
    println!();

    println!("3. 日期计算");
    let d1 = Date::new(2026, 1, 1);
    let d2 = d1 + TimeDelta::new(365 * 86400, 0);
    let diff = d2 - d1;
    println!("   {} + 365 天 = {}", d1, d2);
    println!("   相差 {} 天", diff.total_seconds() as i64 / 86400);
    println!();

    println!("4. 星期计算");
    let dates = [Date::new(2026, 1, 1), Date::new(2026, 5, 10), Date::new(2026, 12, 25)];
    for d in &dates {
        println!("   {} = {}", d, d.weekday());
    }
    println!();

    println!("5. 闰年判断");
    for year in [2024, 2025, 2000, 1900] {
        println!("   {}: {}", year, if Date::new(year, 1, 1).is_leap_year() { "闰年" } else { "平年" });
    }
    println!();

    println!("6. Unix 时间戳");
    let epoch = DateTime::from_unix(0);
    println!("   epoch:     {}", epoch);
    let ts = now.unix_timestamp();
    println!("   当前时间戳: {}", ts);
    let ts_ms = now.unix_timestamp_millis();
    println!("   毫秒时间戳: {}", ts_ms);
    println!();

    println!("7. 时间加法（跨天回绕）");
    let t = Time::from_hms(23, 30, 0);
    println!("   {} + 2h = {}", t, t + Duration::from_secs(7200));
    println!("   {} - 1h = {}", t, t - Duration::HOUR);
    println!();

    println!("8. 时钟功能");
    let today = Date::today();
    let time_now = Time::now();
    println!("   今天: {}", today);
    println!("   此刻: {}", time_now);
    println!();

    println!("9. 单调时钟（性能计时）");
    let timer = MonotonicClock::start();
    let _sum: u64 = (0..10_000_000).sum();
    let elapsed = timer.elapsed();
    println!("   累加 1000 万次耗时: {}ms", elapsed.total_millis());
    println!();

    println!("✅ 所有示例运行完成！");
}

pub fn from_millis(ms: i64) -> Duration

Create from milliseconds

pub fn from_nanos(ns: i64) -> Duration

Create from nanoseconds

pub fn from_std(d: StdDuration) -> Duration

Convert from std::time::Duration

pub fn to_std(self) -> Option<StdDuration>

Convert to std::time::Duration, returns None if negative

pub fn to_time_delta(self) -> TimeDelta

Convert to a TimeDelta

pub fn total_seconds(&self) -> f64

Total duration in seconds as a floating-point value

pub fn total_millis(&self) -> i64

Total duration in milliseconds

Examples found in repository

examples/test_clock.rs (line 30)

fn main() {
    println!("=== rstime 时钟测试 ===\n");

    println!("1. 系统时钟 - 当前时间");
    let clock = SystemClock;
    let now = clock.now();
    println!("   DateTime: {}", now);
    println!("   Date:     {}", clock.today());
    println!("   Time:     {}", clock.time_now());
    println!();

    println!("2. 便捷方法（无需实例化 Clock）");
    let today = rstime::Date::today();
    let time_now = rstime::Time::now();
    let datetime_now = rstime::DateTime::now();
    println!("   Date::today()     → {}", today);
    println!("   Time::now()       → {}", time_now);
    println!("   DateTime::now()   → {}", datetime_now);
    println!();

    println!("3. 单调时钟 - 性能计时");
    let timer = MonotonicClock::start();
    let mut _sum: u64 = 0;
    for i in 0..1_000_000 {
        _sum += i;
    }
    let elapsed = timer.elapsed();
    println!("   累加 100 万次: {}ms ({} 纳秒)", elapsed.total_millis(), elapsed.nanos);
    println!();

    println!("4. 单调时钟 - 重置");
    let mut timer = MonotonicClock::start();
    std::thread::sleep(std::time::Duration::from_millis(10));
    println!("   第一次: {}ms", timer.elapsed().total_millis());
    timer.reset();
    println!("   重置后: {}ms", timer.elapsed().total_millis());
    println!();

    println!("5. Duration 常量");
    println!("   ZERO:   {}ms", Duration::ZERO.total_millis());
    println!("   SECOND: {}ms", Duration::SECOND.total_millis());
    println!("   MINUTE: {}ms", Duration::MINUTE.total_millis());
    println!("   HOUR:   {}ms", Duration::HOUR.total_millis());
    println!("   DAY:    {}ms", Duration::DAY.total_millis());
    println!();

    println!("✅ 时钟测试完成！");
}

examples/demo.rs (line 66)

fn main() {
    println!("=== rstime 时间库使用示例 ===\n");

    println!("1. 获取当前时间");
    let now = DateTime::now();
    println!("   现在: {}\n", now);

    println!("2. 格式化输出");
    let dt = DateTime::from_ymd_hms_milli(2026, 5, 10, 14, 5, 9, 37);
    println!("   ISO 8601:  {}", dt.format("{YYYY}-{MM}-{DD}T{HH}:{mm}:{ss}"));
    println!("   中文格式:  {}", dt.format("{YYYY}年{MM}月{DD}日 {HH}:{mm}:{ss}"));
    println!("   12小时制:  {}", dt.format("{hh}:{mm}:{ss} {AMPM}"));
    println!("   星期:      {}", dt.format("{WW}"));
    println!("   毫秒:      {}", dt.format("{SSS}"));
    println!();

    println!("3. 日期计算");
    let d1 = Date::new(2026, 1, 1);
    let d2 = d1 + TimeDelta::new(365 * 86400, 0);
    let diff = d2 - d1;
    println!("   {} + 365 天 = {}", d1, d2);
    println!("   相差 {} 天", diff.total_seconds() as i64 / 86400);
    println!();

    println!("4. 星期计算");
    let dates = [Date::new(2026, 1, 1), Date::new(2026, 5, 10), Date::new(2026, 12, 25)];
    for d in &dates {
        println!("   {} = {}", d, d.weekday());
    }
    println!();

    println!("5. 闰年判断");
    for year in [2024, 2025, 2000, 1900] {
        println!("   {}: {}", year, if Date::new(year, 1, 1).is_leap_year() { "闰年" } else { "平年" });
    }
    println!();

    println!("6. Unix 时间戳");
    let epoch = DateTime::from_unix(0);
    println!("   epoch:     {}", epoch);
    let ts = now.unix_timestamp();
    println!("   当前时间戳: {}", ts);
    let ts_ms = now.unix_timestamp_millis();
    println!("   毫秒时间戳: {}", ts_ms);
    println!();

    println!("7. 时间加法（跨天回绕）");
    let t = Time::from_hms(23, 30, 0);
    println!("   {} + 2h = {}", t, t + Duration::from_secs(7200));
    println!("   {} - 1h = {}", t, t - Duration::HOUR);
    println!();

    println!("8. 时钟功能");
    let today = Date::today();
    let time_now = Time::now();
    println!("   今天: {}", today);
    println!("   此刻: {}", time_now);
    println!();

    println!("9. 单调时钟（性能计时）");
    let timer = MonotonicClock::start();
    let _sum: u64 = (0..10_000_000).sum();
    let elapsed = timer.elapsed();
    println!("   累加 1000 万次耗时: {}ms", elapsed.total_millis());
    println!();

    println!("✅ 所有示例运行完成！");
}

Trait Implementations

impl Add<Duration> for Time

fn add(self, delta: Duration) -> Time

Add a duration, wrapping around midnight

use rstime::{Time, Duration};

let t = Time::from_hms(23, 0, 0);
let t2 = t + Duration::HOUR * 2;

type Output = Time

The resulting type after applying the + operator.

impl Add for Duration

type Output = Duration

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Duration

Performs the + operation.

impl AddAssign for Duration

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl Clone for Duration

fn clone(&self) -> Duration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Duration

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

Formats the value using the given formatter.

impl Display for Duration

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

Formats the value using the given formatter.

impl From<Duration> for TimeDelta

fn from(d: Duration) -> TimeDelta

Converts to this type from the input type.

impl Hash for Duration

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Duration

fn cmp(&self, other: &Duration) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Duration

fn eq(&self, other: &Duration) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Duration

fn partial_cmp(&self, other: &Duration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Duration> for Time

fn sub(self, delta: Duration) -> Time

Subtract a duration, wrapping around midnight

type Output = Time

The resulting type after applying the - operator.

impl Sub for Duration

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Duration

Performs the - operation.

impl SubAssign for Duration

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl Copy for Duration

impl Eq for Duration

impl StructuralPartialEq for Duration