Struct aws_smithy_types::date_time::DateTime

pub struct DateTime { /* private fields */ }

DateTime in time.

DateTime in time represented as seconds and sub-second nanos since the Unix epoch (January 1, 1970 at midnight UTC/GMT).

This type can be converted to/from the standard library’s SystemTime:

use std::convert::TryFrom;

let the_millennium_as_system_time = SystemTime::try_from(DateTime::from_secs(946_713_600))?;
let now_as_date_time = DateTime::from(SystemTime::now());

The aws-smithy-types-convert crate can be used for conversions to/from other libraries, such as time or chrono.

Implementations

impl DateTime

pub fn from_secs(epoch_seconds: i64) -> Self

Creates a DateTime from a number of seconds since the Unix epoch.

pub fn from_millis(epoch_millis: i64) -> DateTime

Creates a DateTime from a number of milliseconds since the Unix epoch.

pub fn from_nanos(epoch_nanos: i128) -> Result<Self, ConversionError>

Creates a DateTime from a number of nanoseconds since the Unix epoch.

pub fn as_nanos(&self) -> i128

Returns the number of nanoseconds since the Unix epoch that this DateTime represents.

pub fn from_fractional_secs(epoch_seconds: i64, fraction: f64) -> Self

Creates a DateTime from a number of seconds and a fractional second since the Unix epoch.

Example

assert_eq!(
    DateTime::from_secs_and_nanos(1, 500_000_000u32),
    DateTime::from_fractional_secs(1, 0.5),
);

pub fn from_secs_and_nanos(seconds: i64, subsecond_nanos: u32) -> Self

Creates a DateTime from a number of seconds and sub-second nanos since the Unix epoch.

Example

assert_eq!(
    DateTime::from_fractional_secs(1, 0.5),
    DateTime::from_secs_and_nanos(1, 500_000_000u32),
);

pub fn as_secs_f64(&self) -> f64

Returns the DateTime value as an f64 representing the seconds since the Unix epoch.

Note: This conversion will lose precision due to the nature of floating point numbers.

pub fn from_secs_f64(epoch_seconds: f64) -> Self

Creates a DateTime from an f64 representing the number of seconds since the Unix epoch.

Example

assert_eq!(
    DateTime::from_fractional_secs(1, 0.5),
    DateTime::from_secs_f64(1.5),
);

pub fn from_str(s: &str, format: Format) -> Result<Self, DateTimeParseError>

Parses a DateTime from a string using the given format.

pub fn has_subsec_nanos(&self) -> bool

Returns true if sub-second nanos is greater than zero.

pub fn secs(&self) -> i64

Returns the epoch seconds component of the DateTime.

Note: this does not include the sub-second nanos.

pub fn set_seconds(&mut self, seconds: i64) -> &mut Self

Set the seconds component of this DateTime.

pub fn subsec_nanos(&self) -> u32

Returns the sub-second nanos component of the DateTime.

Note: this does not include the number of seconds since the epoch.

pub fn set_subsec_nanos(&mut self, subsec_nanos: u32) -> &mut Self

Set the “sub-second” nanoseconds of this DateTime.

pub fn to_millis(self) -> Result<i64, ConversionError>

Converts the DateTime to the number of milliseconds since the Unix epoch.

This is fallible since DateTime holds more precision than an i64, and will return a ConversionError for DateTime values that can’t be converted.

pub fn read( s: &str, format: Format, delim: char, ) -> Result<(Self, &str), DateTimeParseError>

Read 1 date of format from s, expecting either delim or EOF

Enable parsing multiple dates from the same string

pub fn fmt(&self, format: Format) -> Result<String, DateTimeFormatError>

Formats the DateTime to a string using the given format.

Returns an error if the given DateTime cannot be represented by the desired format.

Trait Implementations

impl Clone for DateTime

fn clone(&self) -> DateTime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DateTime

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

Formats the value using the given formatter.

impl Display for DateTime

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

Formats the value using the given formatter.

impl From<SystemTime> for DateTime

fn from(time: SystemTime) -> Self

Converts to this type from the input type.

impl Hash for DateTime

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 Ord for DateTime

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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for DateTime

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

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 TryFrom<DateTime> for SystemTime

Tries to convert a DateTime into a SystemTime.

This can fail if the the DateTime value is larger or smaller than what the SystemTime can represent on the operating system it’s compiled for. On Linux, for example, it will only fail on Instant::from_secs(i64::MIN) (with any nanoseconds value). On Windows, however, Rust’s standard library uses a smaller precision type for SystemTime, and it will fail conversion for a much larger range of date-times. This is only an issue if dealing with date-times beyond several thousands of years from now.

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(date_time: DateTime) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for DateTime

impl Eq for DateTime

impl StructuralPartialEq for DateTime