## Timestamp

# Struct Timestamp

    pub struct Timestamp(/* private fields */);

Expand description

Wrapper around `DateTime<Utc>` to allow us to do custom de(serialization)

## Methods from Deref<Target = DateTime<Utc>>§

Source

#### pub const MIN_UTC: DateTime<Utc>

Source

#### pub const MAX_UTC: DateTime<Utc>

Source

#### pub fn date(&self) -> Date<Tz>

👎Deprecated since 0.4.23: Use `date_naive()` instead

Retrieves the date component with an associated timezone.

Unless you are immediately planning on turning this into a `DateTime` with the same timezone you should use the `date_naive` method.

`NaiveDate` is a more well-defined type, and has more traits implemented on it, so should be preferred to `Date` any time you truly want to operate on dates.

##### §Panics

`DateTime` internally stores the date and time in UTC with a `NaiveDateTime`. This method will panic if the offset from UTC would push the local date outside of the representable range of a `Date`.

Source

#### pub fn date_naive(&self) -> NaiveDate

Retrieves the date component.

##### §Panics

`DateTime` internally stores the date and time in UTC with a `NaiveDateTime`. This method will panic if the offset from UTC would push the local date outside of the representable range of a `NaiveDate`.

##### §Example

    use chrono::prelude::*;

    let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
    let other: DateTime<FixedOffset> =
        FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
    assert_eq!(date.date_naive(), other.date_naive());

Source

#### pub fn time(&self) -> NaiveTime

Retrieves the time component.

Source

#### pub fn timestamp(&self) -> i64

Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”).

The reverse operation of creating a `DateTime` from a timestamp can be performed using `from_timestamp` or `TimeZone::timestamp_opt`.

    use chrono::{DateTime, TimeZone, Utc};

    let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
    assert_eq!(dt.timestamp(), 1431648000);

    assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);

Source

#### pub fn timestamp_millis(&self) -> i64

Returns the number of non-leap-milliseconds since January 1, 1970 UTC.

##### §Example

    use chrono::{NaiveDate, Utc};

    let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
        .unwrap()
        .and_hms_milli_opt(0, 0, 1, 444)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_millis(), 1_444);

    let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
        .unwrap()
        .and_hms_milli_opt(1, 46, 40, 555)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);

Source

#### pub fn timestamp_micros(&self) -> i64

Returns the number of non-leap-microseconds since January 1, 1970 UTC.

##### §Example

    use chrono::{NaiveDate, Utc};

    let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
        .unwrap()
        .and_hms_micro_opt(0, 0, 1, 444)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_micros(), 1_000_444);

    let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
        .unwrap()
        .and_hms_micro_opt(1, 46, 40, 555)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);

Source

#### pub fn timestamp_nanos(&self) -> i64

👎Deprecated since 0.4.31: use `timestamp_nanos_opt()` instead

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

##### §Panics

An `i64` with nanosecond precision can span a range of ~584 years. This function panics on an out of range `DateTime`.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

Source

#### pub fn timestamp_nanos_opt(&self) -> Option<i64>

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

##### §Errors

An `i64` with nanosecond precision can span a range of ~584 years. This function returns `None` on an out of range `DateTime`.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

##### §Example

    use chrono::{NaiveDate, Utc};

    let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
        .unwrap()
        .and_hms_nano_opt(0, 0, 1, 444)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_444));

    let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
        .unwrap()
        .and_hms_nano_opt(1, 46, 40, 555)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_000_000_000_555));

    let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
        .unwrap()
        .and_hms_nano_opt(0, 12, 43, 145_224_192)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), Some(-9_223_372_036_854_775_808));

    let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
        .unwrap()
        .and_hms_nano_opt(23, 47, 16, 854_775_807)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), Some(9_223_372_036_854_775_807));

    let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
        .unwrap()
        .and_hms_nano_opt(0, 12, 43, 145_224_191)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), None);

    let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
        .unwrap()
        .and_hms_nano_opt(23, 47, 16, 854_775_808)
        .unwrap()
        .and_local_timezone(Utc)
        .unwrap();
    assert_eq!(dt.timestamp_nanos_opt(), None);

Source

#### pub fn timestamp_subsec_millis(&self) -> u32

Returns the number of milliseconds since the last second boundary.

In event of a leap second this may exceed 999.

Source

#### pub fn timestamp_subsec_micros(&self) -> u32

Returns the number of microseconds since the last second boundary.

In event of a leap second this may exceed 999,999.

Source

#### pub fn timestamp_subsec_nanos(&self) -> u32

Returns the number of nanoseconds since the last second boundary

In event of a leap second this may exceed 999,999,999.

Source

#### pub fn offset(&self) -> &<Tz as TimeZone>::Offset

Retrieves an associated offset from UTC.

Source

#### pub fn timezone(&self) -> Tz

Retrieves an associated time zone.

Source

#### pub fn with_timezone<Tz2>(&self, tz: &Tz2) -> DateTime<Tz2>
where Tz2: TimeZone,

Changes the associated time zone. The returned `DateTime` references the same instant of time from the perspective of the provided time zone.

Source

#### pub fn fixed_offset(&self) -> DateTime<FixedOffset>

Fix the offset from UTC to its current value, dropping the associated timezone information. This is useful for converting a generic `DateTime<Tz: Timezone>` to `DateTime<FixedOffset>`.

Source

#### pub fn to_utc(&self) -> DateTime<Utc>

Turn this `DateTime` into a `DateTime<Utc>`, dropping the offset and associated timezone information.

Source

#### pub fn naive_utc(&self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

Source

#### pub fn naive_local(&self) -> NaiveDateTime

Returns a view to the naive local datetime.

##### §Panics

`DateTime` internally stores the date and time in UTC with a `NaiveDateTime`. This method will panic if the offset from UTC would push the local datetime outside of the representable range of a `NaiveDateTime`.

Source

#### pub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>

Retrieve the elapsed years from now to the given `DateTime`.

##### §Errors

Returns `None` if `base > self`.

Source

#### pub fn to_rfc2822(&self) -> String

Returns an RFC 2822 date and time string such as `Tue, 1 Jul 2003 10:52:37 +0200`.

##### §Panics

Panics if the date can not be represented in this format: the year may not be negative and can not have more than 4 digits.

Source

#### pub fn to_rfc3339(&self) -> String

Returns an RFC 3339 and ISO 8601 date and time string such as `1996-12-19T16:39:57-08:00`.

Source

#### pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String

Return an RFC 3339 and ISO 8601 date and time string with subseconds formatted as per `SecondsFormat`.

If `use_z` is true and the timezone is UTC (offset 0), uses `Z` as per `Fixed::TimezoneOffsetColonZ`. If `use_z` is false, uses `Fixed::TimezoneOffsetColon`

##### §Examples

    let dt = NaiveDate::from_ymd_opt(2018, 1, 26)
        .unwrap()
        .and_hms_micro_opt(18, 30, 9, 453_829)
        .unwrap()
        .and_utc();
    assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), "2018-01-26T18:30:09.453+00:00");
    assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), "2018-01-26T18:30:09.453Z");
    assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T18:30:09Z");

    let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
    let dt = pst
        .from_local_datetime(
            &NaiveDate::from_ymd_opt(2018, 1, 26)
                .unwrap()
                .and_hms_micro_opt(10, 30, 9, 453_829)
                .unwrap(),
        )
        .unwrap();
    assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");

Source

#### pub fn with_time(&self, time: NaiveTime) -> LocalResult<DateTime<Tz>>

Set the time to a new fixed time on the existing date.

##### §Errors

Returns `LocalResult::None` if the datetime is at the edge of the representable range for a `DateTime`, and `with_time` would push the value in UTC out of range.

##### §Example

    use chrono::{Local, NaiveTime};

    let noon = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
    let today_noon = Local::now().with_time(noon);
    let today_midnight = Local::now().with_time(NaiveTime::MIN);

    assert_eq!(today_noon.single().unwrap().time(), noon);
    assert_eq!(today_midnight.single().unwrap().time(), NaiveTime::MIN);

Source

#### pub const UNIX_EPOCH: DateTime<Utc>

Source

#### pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the combined date and time with the specified formatting items.

Source

#### pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Formats the combined date and time per the specified format string.

See the `crate::format::strftime` module for the supported escape sequences.

##### §Example

    use chrono::prelude::*;

    let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
    let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
    assert_eq!(formatted, "02/04/2017 12:50");

## Trait Implementations§

§

### impl Clone for Timestamp

§

#### fn clone(&self) -> Timestamp

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
§

### impl Debug for Timestamp

§

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

Formats the value using the given formatter. Read more
§

### impl Deref for Timestamp

§

#### type Target = DateTime<Utc>

The resulting type after dereferencing.
§

#### fn deref(&self) -> &<Timestamp as Deref>::Target

Dereferences the value.
§

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

§

#### fn deserialize<D>( deserializer: D, ) -> Result<Timestamp, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
§

### impl From<DateTime<Utc>> for Timestamp

§

#### fn from(datetime: DateTime<Utc>) -> Timestamp

Converts to this type from the input type.
§

### impl From<Timestamp> for DateTime<Utc>

§

#### fn from(ts: Timestamp) -> DateTime<Utc>

Converts to this type from the input type.
§

### impl From<i64> for Timestamp

§

#### fn from(timestamp: i64) -> Timestamp

Converts to this type from the input type.
§

### impl PartialEq for Timestamp

§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

#### 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 Serialize for Timestamp

§

#### 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. Read more
§

### impl Copy for Timestamp

§

### impl Eq for Timestamp

§

### impl StructuralPartialEq for Timestamp

## Auto Trait Implementations§

§

### impl Freeze for Timestamp

§

### impl RefUnwindSafe for Timestamp

§

### impl Send for Timestamp

§

### impl Sync for Timestamp

§

### impl Unpin for Timestamp

§

### impl UnwindSafe for Timestamp

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [`Span`], returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> PolicyExt for T
where T: ?Sized,

§

#### fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new `Policy` that returns [`Action::Follow`] only if `self` and `other` return `Action::Follow`. Read more
§

#### fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new `Policy` that returns [`Action::Follow`] if either `self` or `other` returns `Action::Follow`. Read more
Source§

### impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

#### type Target = T

🔬This is a nightly-only experimental API. (`arbitrary_self_types`)
The target type on which the method may be called.
§

### impl<T> ServiceExt for T

§

#### fn map_response_body<F>(self, f: F) -> MapResponseBody<Self, F>
where Self: Sized,

Apply a transformation to the response body. Read more
§

#### fn trace_for_http(self) -> Trace<Self, SharedClassifier<ServerErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using HTTP status codes. Read more
§

#### fn trace_for_grpc(self) -> Trace<Self, SharedClassifier<GrpcErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using gRPC headers. Read more
§

#### fn follow_redirects(self) -> FollowRedirect<Self>
where Self: Sized,

Follow redirect resposes using the `Standard` policy. Read more
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
Source§

### impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,