Struct Timestamp

#[non_exhaustive]
pub struct Timestamp { /* private fields */ }

Well-known point in time representation for Google APIs.

A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one.

All minutes are 60 seconds long. Leap seconds are “smeared” so that no leap second table is needed for interpretation, using a 24-hour linear smear.

The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings.

JSON Mapping

In JSON format, the Timestamp type is encoded as a string in the RFC 3339 format. That is, the format is “{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z” where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The “Z” suffix indicates the timezone (“UTC”); the timezone is required.

For example, “2017-01-15T01:30:15.01Z” encodes 15.01 seconds past 01:30 UTC on January 15, 2017.

Implementations

impl Timestamp

pub const MIN_SECONDS: i64 = -62_135_596_800i64

The minimum value for the seconds component. Corresponds to ‘0001-01-01T00:00:00Z’.

pub const MAX_SECONDS: i64 = 253_402_300_799i64

The maximum value for the seconds component. Corresponds to ‘9999-12-31T23:59:59Z’.

pub const MIN_NANOS: i32 = 0i32

The minimum value for the nanos component.

pub const MAX_NANOS: i32 = 999_999_999i32

The maximum value for the nanos component.

pub fn new(seconds: i64, nanos: i32) -> Result<Self, TimestampError>

Creates a new Timestamp from the seconds and nanoseconds.

If either value is out of range it returns an error.

Arguments

• seconds - the seconds on the timestamp.
• nanos - the nanoseconds on the timestamp.

pub fn clamp(seconds: i64, nanos: i32) -> Self

Create a normalized, clamped Timestamp.

Timestamps must be between 0001-01-01T00:00:00Z and 9999-12-31T23:59:59.999999999Z, and the nanoseconds component must always be in the range [0, 999_999_999]. This function creates a new Timestamp instance clamped to those ranges.

The function effectively adds the nanoseconds part (with carry) to the seconds part, with saturation.

Arguments

• seconds - the seconds on the timestamp.
• nanos - the nanoseconds added to the seconds.

pub fn seconds(&self) -> i64

Represents seconds of UTC time since Unix epoch (1970-01-01T00:00:00Z).

Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.

pub fn nanos(&self) -> i32

Non-negative fractions of a second at nanosecond resolution.

Negative second values (before the Unix epoch) with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.

Trait Implementations

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl Default for Timestamp

fn default() -> Timestamp

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Timestamp

Implement serde deserialization for timestamps.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for Timestamp

fn typename() -> &'static str

The typename of this message.

impl PartialEq for Timestamp

fn eq(&self, other: &Timestamp) -> 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 Timestamp

fn partial_cmp(&self, other: &Timestamp) -> 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 Timestamp

Implement serde serialization for timestamps.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&Timestamp> for String

Converts a Timestamp to its String representation.

type Error = TimestampError

The type returned in the event of a conversion error.

fn try_from(timestamp: &Timestamp) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&str> for Timestamp

Converts the String representation of a timestamp to Timestamp.

type Error = TimestampError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Timestamp