Struct Delta 

pub struct Delta<U: TimeUnit = Nsec> { /* private fields */ }

A span of time.

The span is stored in the unit given by the type parameter U (see TimeUnit); its value has type U::Repr. U defaults to Nsec, so a plain Delta is a span in nanoseconds. The value can be negative, zero, or positive.

Implementations

impl Delta<Jiffy>

pub const fn from_jiffies(jiffies: isize) -> Self

Create a new Delta from a number of jiffies.

pub const fn as_jiffies(self) -> isize

Return the number of jiffies in the Delta.

impl Delta

pub const ZERO: Self

A span of time equal to zero.

pub const fn from_nanos(nanos: i64) -> Self

Create a new Delta from a number of nanoseconds.

pub const fn from_micros(micros: i64) -> Self

Create a new Delta from a number of microseconds.

The micros can range from -9_223_372_036_854_775 to 9_223_372_036_854_775. If micros is outside this range, i64::MIN is used for negative values, and i64::MAX is used for positive values due to saturation.

pub const fn from_millis(millis: i64) -> Self

Create a new Delta from a number of milliseconds.

The millis can range from -9_223_372_036_854 to 9_223_372_036_854. If millis is outside this range, i64::MIN is used for negative values, and i64::MAX is used for positive values due to saturation.

pub const fn from_secs(secs: i64) -> Self

Create a new Delta from a number of seconds.

The secs can range from -9_223_372_036 to 9_223_372_036. If secs is outside this range, i64::MIN is used for negative values, and i64::MAX is used for positive values due to saturation.

pub fn is_zero(self) -> bool

Return true if the Delta spans no time.

pub fn is_negative(self) -> bool

Return true if the Delta spans a negative amount of time.

pub const fn as_nanos(self) -> i64

Return the number of nanoseconds in the Delta.

pub fn as_micros_ceil(self) -> i64

Return the smallest number of microseconds greater than or equal to the value in the Delta.

pub fn as_millis(self) -> i64

Return the number of milliseconds in the Delta.

pub fn as_millis_ceil(self) -> i64

Return the smallest number of milliseconds greater than or equal to the value in the Delta.

pub fn to_jiffies_timeout(self) -> Delta<Jiffy>

Convert this span to a Delta<Jiffy> suitable for use as a timeout.

Unless the result saturates, the value is rounded up to the next whole jiffy, so the resulting timeout is never shorter than self.

A negative span saturates at zero jiffies, i.e. an immediate timeout.

A span that does not fit saturates at the kernel’s MAX_JIFFY_OFFSET, the upper bound for a jiffies span. That is a finite timeout, so a saturated result can be shorter than the requested span. It is derived from long, so only 32 bit can reach it, at about 12 days with HZ=1000.

Examples

use kernel::time::Delta;

// A negative span is an immediate timeout.
assert_eq!(Delta::from_millis(-1).to_jiffies_timeout().as_jiffies(), 0);

// A span shorter than a jiffy still waits, i.e. the timeout is never
// shorter than the span.
assert!(Delta::from_nanos(1).to_jiffies_timeout().as_jiffies() >= 1);

pub fn rem_nanos(self, dividend: i32) -> Self

Return self % dividend where dividend is in nanoseconds.

The kernel doesn’t have any emulation for s64 % s64 on 32 bit platforms, so this is limited to 32 bit dividends.

Trait Implementations

impl Add for Delta

type Output = Delta

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: ClockId> Add<Delta> for Instant<T>

type Output = Instant<T>

The resulting type after applying the + operator.

fn add(self, rhs: Delta) -> Self::Output

Performs the + operation.

impl AddAssign for Delta

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<U: Clone + TimeUnit> Clone for Delta<U>

where U::Repr: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<U: Copy + TimeUnit> Copy for Delta<U>

where U::Repr: Copy,

impl<U: Debug + TimeUnit> Debug for Delta<U>

where U::Repr: Debug,

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

Formats the value using the given formatter.

impl Div for Delta

type Output = i64

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<U: Eq + TimeUnit> Eq for Delta<U>

where U::Repr: Eq,

impl HrTimerExpires for Delta

fn as_nanos(&self) -> i64

Converts the expiration time into a nanosecond representation.

impl Mul<i64> for Delta

type Output = Delta

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl MulAssign<i64> for Delta

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<U: Ord + TimeUnit> Ord for Delta<U>

where U::Repr: Ord,

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<U: PartialEq + TimeUnit> PartialEq for Delta<U>

where U::Repr: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<U: PartialOrd + TimeUnit> PartialOrd for Delta<U>

where U::Repr: PartialOrd,

fn partial_cmp(&self, other: &Self) -> 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<U: PartialEq + TimeUnit> StructuralPartialEq for Delta<U>

where U::Repr: PartialEq,

impl Sub for Delta

type Output = Delta

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: ClockId> Sub<Delta> for Instant<T>

type Output = Instant<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Delta) -> Self::Output

Performs the - operation.

impl SubAssign for Delta

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.