Struct Duration

pub struct Duration { /* private fields */ }

Duration represents a span of time.

Negative durations are not supported. Duration is not meant to be used for math operations.

Implementations

impl Duration

pub const MAX: Duration

The largest value that can be represented by the Duration type.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::MAX, Duration::from_micros(u64::MAX));

pub const ZERO: Duration

A duration of zero time.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::ZERO, Duration::from_micros(0));

pub const fn from_secs(secs: u64) -> Duration

Creates a duration from the specified number of seconds.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1), Duration::from_millis(1000));

pub const fn from_millis(millis: u64) -> Duration

Creates a duration from the specified number of milliseconds.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1), Duration::from_millis(1000));

pub const fn from_micros(micros: u64) -> Duration

Creates a duration from the specified number of microseconds.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1), Duration::from_micros(1000000));

pub const fn as_secs(&self) -> u64

Returns the total amount of seconds, rounded down.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_millis(1980).as_secs(), 1);

pub const fn as_millis(&self) -> u64

Returns the total amount of milliseconds, rounded down.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_millis(1980).as_millis(), 1980);

pub const fn as_micros(&self) -> u64

Returns the total amount of microseconds.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_millis(1980).as_micros(), 1980000);

pub fn checked_add(self, rhs: Duration) -> Option<Duration>

Adds one Duration to another, returning a new Duration or None in the event of an overflow.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(
    Duration::from_secs(1).checked_add(Duration::from_secs(1)),
    Some(Duration::from_secs(2))
);
assert_eq!(Duration::MAX.checked_add(Duration::from_secs(1)), None);

pub fn checked_sub(self, rhs: Duration) -> Option<Duration>

Subtracts one Duration from another, returning a new Duration or None in the event of an underflow.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(
    Duration::from_secs(2).checked_sub(Duration::from_secs(1)),
    Some(Duration::from_secs(1))
);
assert_eq!(Duration::from_secs(1).checked_sub(Duration::from_secs(2)), None);

pub fn checked_mul(self, rhs: u32) -> Option<Duration>

Multiplies one Duration by a scalar u32, returning a new Duration or None in the event of an overflow.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1).checked_mul(2), Some(Duration::from_secs(2)));
assert_eq!(Duration::MAX.checked_mul(2), None);

pub fn checked_div(self, rhs: u32) -> Option<Duration>

Divides one Duration by a scalar u32, returning a new Duration or None if rhs == 0.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1).checked_div(2), Some(Duration::from_millis(500)));
assert_eq!(Duration::from_secs(1).checked_div(0), None);

pub fn abs_diff(self, rhs: Duration) -> Duration

Returns the absolute difference between self and rhs.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1).abs_diff(Duration::from_secs(2)), Duration::from_secs(1));
assert_eq!(Duration::from_secs(2).abs_diff(Duration::from_secs(1)), Duration::from_secs(1));

Trait Implementations

impl Add<Duration> for Instant

fn add(self, rhs: Duration) -> <Instant as Add<Duration>>::Output

Panics

This function may panic if the resulting instant overflows. See Instant::checked_add for a version without panic.

Examples

use veecle_osal_api::time::{Duration, Instant, TimeAbstraction};
use veecle_osal_std::time::Time;

let now = Time::now();

assert!(now + Duration::from_secs(1) > now);

use veecle_osal_api::time::{Duration, Instant, TimeAbstraction};
use veecle_osal_std::time::Time;

let now = Time::now();

let _ = now + Duration::MAX;

type Output = Instant

The resulting type after applying the + operator.

impl Add for Duration

fn add(self, rhs: Duration) -> <Duration as Add>::Output

Panics

This function may panic if the resulting duration overflows. See Duration::checked_add for a version without panic.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1) + Duration::from_secs(1), Duration::from_secs(2));

use veecle_osal_api::time::Duration;

let _ = Duration::MAX + Duration::from_secs(1);

type Output = Duration

The resulting type after applying the + operator.

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<(), Error>

Examples

use veecle_osal_api::time::Duration;

let duration = Duration::from_millis(1980);
assert_eq!(format!("{duration:?}"), "1s.980000us");

impl Default for Duration

fn default() -> Duration

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Duration

fn deserialize<__D>( __deserializer: __D, ) -> Result<Duration, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<u32> for Duration

fn div(self, rhs: u32) -> <Duration as Div<u32>>::Output

Panics

This function may panic if the duration is divided by zero. See Duration::checked_div for a version without panic.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1) / 2, Duration::from_millis(500));

use veecle_osal_api::time::Duration;

let _ = Duration::from_secs(1) / 0;

type Output = Duration

The resulting type after applying the / operator.

impl From<Duration> for Duration

fn from(value: Duration) -> Duration

Examples

use veecle_osal_api::time::Duration;

assert_eq!(
    core::time::Duration::from(Duration::from_secs(1)),
    core::time::Duration::from_secs(1)
);

impl Mul<u32> for Duration

fn mul(self, rhs: u32) -> <Duration as Mul<u32>>::Output

Panics

This function may panic if the resulting duration overflows. See Duration::checked_mul for a version without panic.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(1) * 2, Duration::from_secs(2));

use veecle_osal_api::time::Duration;

let _ = Duration::MAX * 2;

type Output = Duration

The resulting type after applying the * operator.

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 Serialize for Duration

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Duration> for Instant

fn sub(self, rhs: Duration) -> <Instant as Sub<Duration>>::Output

Panics

This function may panic if the resulting instant underflows. See Instant::checked_sub for a version without panic.

Examples

use veecle_osal_api::time::{Duration, Instant, TimeAbstraction};
use veecle_osal_std::time::Time;

let begin = Time::now();

std::thread::sleep(core::time::Duration::from_millis(1));

let end = Time::now();

assert!(end - Duration::from_millis(1) < end);

use veecle_osal_api::time::{Duration, Instant, TimeAbstraction};
use veecle_osal_std::time::Time;

let now = Time::now();

let _ = now - Duration::MAX;

type Output = Instant

The resulting type after applying the - operator.

impl Sub for Duration

fn sub(self, rhs: Duration) -> <Duration as Sub>::Output

Panics

This function may panic if the resulting duration underflows. See Duration::checked_sub for a version without panic.

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::from_secs(2) - Duration::from_secs(1), Duration::from_secs(1));

use veecle_osal_api::time::Duration;

let _ = Duration::from_secs(1) - Duration::from_secs(2);

type Output = Duration

The resulting type after applying the - operator.

impl TryFrom<Duration> for Duration

fn try_from( value: Duration, ) -> Result<Duration, <Duration as TryFrom<Duration>>::Error>

Examples

use veecle_osal_api::time::Duration;

assert_eq!(Duration::try_from(core::time::Duration::from_secs(1)), Ok(Duration::from_secs(1)));

type Error = TryFromIntError

The type returned in the event of a conversion error.

impl Copy for Duration

impl Eq for Duration

impl StructuralPartialEq for Duration