Struct Duration 

pub struct Duration {
    micros: u64,
}

Duration represents a span of time.

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

Fields

micros: u64

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));

const MICROS_PER_SECOND: u64 = 1_000_000u64

Factor of microseconds per second.

const MILLIS_PER_SECOND: u64 = 1_000u64

Factor of milliseconds per second.

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: Self) -> 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));

pub(crate) fn max_no_overflow_alias() -> Self

Returns a duration of approximately 50 years.

No leap-seconds/days have been taken into account.

Can be used in place of MAX to avoid overflows.

Trait Implementations

impl Add<Duration> for Instant

fn add(self, rhs: Duration) -> Self::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: Self) -> Self::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

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<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<u32> for Duration

fn div(self, rhs: u32) -> Self::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) -> Self

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

fn mul(self, rhs: Duration) -> Self::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!(2 * Duration::from_secs(1), Duration::from_secs(2));

use veecle_osal_api::time::Duration;

let _ = 2 * Duration::MAX;

type Output = Duration

The resulting type after applying the * operator.

impl Mul<u32> for Duration

fn mul(self, rhs: u32) -> Self::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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Duration> for Instant

fn sub(self, rhs: Duration) -> Self::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: Self) -> Self::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<Self, Self::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