Struct jomini::common::Date

pub struct Date { /* private fields */ }

A date without a time component

See RawDate for additional date / time commentary

Implementations

impl Date

pub fn from_ymd_opt(year: i16, month: u8, day: u8) -> Option<Self>

Create a new date from year, month, and day parts

Will return None if the date does not exist

use jomini::common::Date;
assert_eq!(Date::from_ymd_opt(1444, 11, 11), Some(Date::from_ymd(1444, 11, 11)));
assert_eq!(Date::from_ymd_opt(800, 5, 3), Some(Date::from_ymd(800, 5, 3)));
assert!(Date::from_ymd_opt(800, 0, 3).is_none());
assert!(Date::from_ymd_opt(800, 1, 0).is_none());
assert!(Date::from_ymd_opt(800, 13, 1).is_none());
assert!(Date::from_ymd_opt(800, 12, 32).is_none());
assert!(Date::from_ymd_opt(2020, 2, 29).is_none());

pub fn from_ymd(year: i16, month: u8, day: u8) -> Self

Create a new date from year, month, and day parts

Will panic if the date does not exist.

pub fn parse<T: AsRef<[u8]>>(s: T) -> Result<Self, DateError>

Parses a string and returns a new Date if valid. The expected format is either YYYY.MM.DD or a number representing of the equivalent binary representation.

use jomini::common::{Date, PdsDate};
let date = Date::parse("1444.11.11").expect("to parse date");
assert_eq!(date.year(), 1444);
assert_eq!(date.month(), 11);
assert_eq!(date.day(), 11);

pub fn days_until(self, other: &Date) -> i32

Returns the number of days between two dates

use jomini::common::Date;
let date = Date::parse("1400.1.2").unwrap();
let date2 = Date::parse("1400.1.3").unwrap();
let date3 = Date::parse("1401.1.2").unwrap();
let date4 = Date::parse("1401.12.31").unwrap();
assert_eq!(1, date.days_until(&date2));
assert_eq!(365, date.days_until(&date3));
assert_eq!(728, date.days_until(&date4));
assert_eq!(-728, date4.days_until(&date));

pub fn add_days(self, days: i32) -> Date

Return a new date that is the given number of days in the future from the current date

use jomini::common::Date;

let date = Date::parse("1400.1.2").unwrap();
let expected = Date::parse("1400.1.3").unwrap();
let expected2 = Date::parse("1400.1.1").unwrap();
assert_eq!(expected, date.add_days(1));
assert_eq!(expected2, date.add_days(-1));

Will panic on overflow or underflow.

pub fn from_binary(s: i32) -> Option<Self>

Decodes a date from a number that had been parsed from binary data

The hour component, if present, will be ignored

pub fn from_binary_heuristic(s: i32) -> Option<Self>

Decodes a date from a number that had been parsed from binary data with the added check that the date is not too far fetched. This function is useful when working with binary data and it’s not clear with an encountered integer is supposed to represent a date or a number.

We use -100 as a cut off dates for years. Antonio I (EU4) holds the record with a birth date of -58.1.1. The exception is monuments, which date back to -2500 or even farther back (mods), but this function is just a heuristic so direct any extreme dates towards Date::from_binary.

pub fn to_binary(self) -> i32

Converts a date into the binary representation

use jomini::common::Date;
let date = Date::from_ymd(1, 1, 1);
assert_eq!(43808760, date.to_binary());

Trait Implementations

impl Clone for Date

fn clone(&self) -> Date

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Date

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Date

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for Date

type Err = DateError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Date

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 Date

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

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Date

fn partial_cmp(&self, other: &Date) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PdsDate for Date

fn year(&self) -> i16

Year of the date

use jomini::common::{Date, PdsDate};
let date = Date::from_ymd(1444, 2, 3);
assert_eq!(date.year(), 1444);

fn month(&self) -> u8

Month of the date

use jomini::common::{Date, PdsDate};
let date = Date::from_ymd(1444, 2, 3);
assert_eq!(date.month(), 2);

fn day(&self) -> u8

Day of the date

use jomini::common::{Date, PdsDate};
let date = Date::from_ymd(1444, 2, 3);
assert_eq!(date.day(), 3);

fn iso_8601(&self) -> PdsDateFormatter

Formats a date in the ISO 8601 format: YYYY-MM-DD

use jomini::common::{Date, PdsDate};
let date = Date::from_ymd(1400, 1, 2);
assert_eq!(date.iso_8601().to_string(), String::from("1400-01-02"));

fn game_fmt(&self) -> PdsDateFormatter

Formats a date in the game format: Y.M.D

use jomini::common::{Date, PdsDate};
let date = Date::from_ymd(1400, 1, 2);
assert_eq!(date.game_fmt().to_string(), String::from("1400.1.2"));

impl Serialize for Date

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Date

impl Eq for Date

impl StructuralPartialEq for Date