Struct eu4save::Eu4Date

pub struct Eu4Date { /* private fields */ }

Struct specialized to parsing, formatting, and manipulating dates in EU4 A date without a time component

See RawDate for additional date / time commentary

Implementations

impl Date

Struct specialized to parsing, formatting, and manipulating dates in EU4

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

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) -> Date

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

Will panic if the date does not exist.

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

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<Date>

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<Date>

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.

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

Performs copy-assignment from source.

impl Debug for Date

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

Formats the value using the given formatter.

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

fn deserialize<D>(
    deserializer: D
) -> Result<Date, <D as Deserializer<'de>>::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<Date, <Date as FromStr>::Err>

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

impl Hash for Date

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

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.

const fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

const fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Date> for Date

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

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

const 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<Date> for Date

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

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

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

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

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

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

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

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

const 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 as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Date

impl Eq for Date

impl StructuralEq for Date

impl StructuralPartialEq for Date