Struct YmdHms 

pub struct YmdHms { /* private fields */ }

Combined Gregorian date + wall time with subsecond precision.

Has some basic calendar aware math, but not time zone aware.

Examples

Creating a YmdHms.

use deep_time::{Dt, Scale};

// clamped to 29
let x = Dt::from_ymd(2000, 2, 30, 0, 0, 0, 0, Scale::UTC).to_ymd();

assert_eq!(x.day(), 29);

Adding a year. 2000 is a leap year and Feb. 29th is possible, but 2001 isn’t a leap year so the day is clamped to the 28th.

use deep_time::{Dt, Scale};

let x = Dt::from_ymd(2000, 2, 29, 0, 0, 0, 0, Scale::UTC).to_ymd();
let x = x.add_yr(1);

assert_eq!(x.day(), 28);

Implementations

impl YmdHms

pub fn to_dt(&self) -> Dt

Reconstructs a Dt.

pub fn add_yr(&self, years: i64) -> Self

Adds (or subtracts) whole years, preserving month and day-of-month. Negative values subtract years. Uses standard last-day-of-month clamping.

pub fn add_mo(&self, months: i64) -> Self

Adds (or subtracts) whole months. Negative values subtract months. Uses i128 total-month arithmetic to avoid overflow at extreme years.

pub fn add_days(&self, days: i64) -> Self

Adds (or subtracts) calendar days using Julian Day arithmetic. Negative values subtract days.

pub fn add_wk(&self, weeks: i64) -> Self

pub fn add_attos(&self, attos: i128) -> Self

pub fn add_sec(&self, sec: i64) -> Self

pub fn add_min(&self, min: i64) -> Self

pub fn add_hr(&self, hr: i64) -> Self

pub fn yr(&self) -> i64

pub fn mo(&self) -> u8

pub fn day(&self) -> u8

pub fn hr(&self) -> u8

pub fn min(&self) -> u8

pub fn sec(&self) -> u8

pub fn attos(&self) -> u64

pub fn unix_attosec(&self) -> i128

Attoseconds since 1970-01-01 midnight, on whatever time scale the object was created on.

pub fn scale(&self) -> Scale

The time scale that the object was created on.

pub fn iso_yr(&self) -> i64

pub fn iso_wk(&self) -> u8

pub fn day_of_yr(&self) -> u16

pub fn wkday(&self) -> Weekday

pub fn wk_of_yr_sun(&self) -> u8

pub fn wk_of_yr_mon(&self) -> u8

pub const fn unix_timestamp(&self) -> (i64, u64)

Returns the Unix timestamp since 1970-01-01 00:00:00 as a tuple of (whole_seconds, attoseconds).

• The timestamp will be on whatever Scale the [DateTime] was created on.
• whole_seconds can be negative (for dates before 1970).
• The fractional part (attoseconds) is always in the range 0..=999_999_999_999_999_999.

Trait Implementations

impl Clone for YmdHms

fn clone(&self) -> YmdHms

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for YmdHms

impl Debug for YmdHms

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for YmdHms

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for YmdHms

impl Hash for YmdHms

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 PartialEq for YmdHms

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for YmdHms

impl Tsify for YmdHms

const DECL: &'static str = "/**\n * Combined Gregorian date + wall time with subsecond precision.\n *\n * Has some basic calendar aware math, but not time zone aware.\n *\n * ## Examples\n *\n * **Creating a** [`YmdHms`].\n *\n * ```rust\n * use deep_time::{Dt, Scale};\n *\n * // clamped to 29\n * let x = Dt::from_ymd(2000, 2, 30, 0, 0, 0, 0, Scale::UTC).to_ymd();\n *\n * assert_eq!(x.day(), 29);\n * ```\n *\n * **Adding a year.** 2000 is a leap year and Feb. 29th is possible, but\n * 2001 isn\\\'t a leap year so the day is clamped to the 28th.\n *\n * ```rust\n * use deep_time::{Dt, Scale};\n *\n * let x = Dt::from_ymd(2000, 2, 29, 0, 0, 0, 0, Scale::UTC).to_ymd();\n * let x = x.add_yr(1);\n *\n * assert_eq!(x.day(), 28);\n * ```\n */\nexport interface YmdHms {\n yr: number;\n mo: number;\n day: number;\n hr: number;\n min: number;\n sec: number;\n attos: number;\n unix_attosec: number;\n scale: Scale;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,