Struct Duration 

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

A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like “day” or “month”. It is related to Timestamp in that the difference between two Timestamp values is a Duration.

Values of this type are not guaranteed to only exist in their normalized form.

Examples

Example 1: Compute Duration from two Timestamps in pseudo code.

Timestamp start = ...;
Timestamp end = ...;
Duration duration = ...;

duration.seconds = end.seconds - start.seconds;
duration.nanos = end.nanos - start.nanos;

if (duration.seconds < 0 && duration.nanos > 0) {
   duration.seconds += 1;
   duration.nanos -= 1000000000;
} else if (duration.seconds > 0 && duration.nanos < 0) {
   duration.seconds -= 1;
   duration.nanos += 1000000000;
}

Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.

Timestamp start = ...;
Duration duration = ...;
Timestamp end = ...;

end.seconds = start.seconds + duration.seconds;
end.nanos = start.nanos + duration.nanos;

if (end.nanos < 0) {
   end.seconds -= 1;
   end.nanos += 1000000000;
} else if (end.nanos >= 1000000000) {
   end.seconds += 1;
   end.nanos -= 1000000000;
}

Fields

seconds: i64

Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

nanos: i32

Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

Implementations

impl Duration

pub fn is_canonical(&self) -> bool

Returns true iff the duration is already normalized.

pub fn normalize(&mut self)

Normalizes the duration to a canonical format.

Based on google::protobuf::util::CreateNormalized.

Trait Implementations

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 EmptyState<(), Duration> for ()

where (): EmptyState<fixed, i32> + EmptyState<general, i64> + Encoder<fixed, i32> + Encoder<general, i64>,

fn is_empty(val: &__Self) -> bool

Returns true iff this instance is in the empty state.

fn clear(val: &mut __Self)

fn empty() -> T

Produces the empty state for this type.

impl ForOverwrite<(), Duration> for ()

where (): EmptyState<fixed, i32> + EmptyState<general, i64> + Encoder<fixed, i32> + Encoder<general, i64>,

fn for_overwrite() -> __Self

Produces a new Self value to be overwritten.

impl FromStr for Duration

type Err = DurationError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Duration, DurationError>

Parses a string s to return a value of this 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 Neg for Duration

type Output = Duration

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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<'__a> RawDistinguishedMessageBorrowDecoder<'__a> for __Self

where (): DistinguishedBorrowDecoder<'__a, fixed, i32> + DistinguishedBorrowDecoder<'__a, general, i64> + EmptyState<fixed, i32> + EmptyState<general, i64>, Self: Eq,

fn raw_borrow_decode_field_distinguished( &mut self, tag: u32, wire_type: WireType, duplicated: bool, buf: Capped<'_, &'__a [u8]>, ctx: RestrictedDecodeContext, ) -> Result<Canonicity, DecodeError>

impl RawDistinguishedMessageDecoder for __Self

where (): DistinguishedDecoder<fixed, i32> + DistinguishedDecoder<general, i64> + EmptyState<fixed, i32> + EmptyState<general, i64>, Self: Eq,

fn raw_decode_field_distinguished<__B>( &mut self, tag: u32, wire_type: WireType, duplicated: bool, buf: Capped<'_, __B>, ctx: RestrictedDecodeContext, ) -> Result<Canonicity, DecodeError>

where __B: Buf + ?Sized,

impl RawMessage for __Self

where (): EmptyState<fixed, i32> + EmptyState<general, i64> + Encoder<fixed, i32> + Encoder<general, i64>,

const __ASSERTIONS: ()

fn empty() -> Self

Returns an initialized message in an empty state.

fn is_empty(&self) -> bool

Returns whether the message is currently empty.

fn clear(&mut self)

Resets the message to an empty state.

fn raw_encode<__B>(&self, buf: &mut __B)

where __B: BufMut + ?Sized,

Encodes the message to a buffer.

fn raw_prepend<__B>(&self, buf: &mut __B)

where __B: ReverseBuf + ?Sized,

Prepends the message to a prepend buffer.

fn raw_encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

impl<'__a> RawMessageBorrowDecoder<'__a> for __Self

where (): BorrowDecoder<'__a, fixed, i32> + BorrowDecoder<'__a, general, i64> + EmptyState<fixed, i32> + EmptyState<general, i64>,

fn raw_borrow_decode_field( &mut self, tag: u32, wire_type: WireType, duplicated: bool, buf: Capped<'_, &'__a [u8]>, ctx: DecodeContext, ) -> Result<(), DecodeError>

Decodes a field from a buffer into self from a borrowed slice.

impl RawMessageDecoder for __Self

where (): Decoder<fixed, i32> + Decoder<general, i64> + EmptyState<fixed, i32> + EmptyState<general, i64>,

fn raw_decode_field<__B>( &mut self, tag: u32, wire_type: WireType, duplicated: bool, buf: Capped<'_, __B>, ctx: DecodeContext, ) -> Result<(), DecodeError>

where __B: Buf + ?Sized,

Decodes a field from a buffer into self.

impl TryFrom<Duration> for Duration

fn try_from(duration: Duration) -> Result<Duration, DurationError>

Converts a std::time::Duration to a Duration, failing if the duration is too large.

type Error = DurationError

The type returned in the event of a conversion error.

impl TryFrom<Duration> for Duration

fn try_from(duration: Duration) -> Result<Duration, DurationError>

Converts a Duration to a std::time::Duration, failing if the duration is negative.

type Error = DurationError

The type returned in the event of a conversion error.

impl Eq for Duration

impl StructuralPartialEq for Duration