Struct perDiem::types::Date

pub struct Date {
    pub day: u8,
    pub month: u8,
    pub year: i32,
}

The basic Date struct

Fields

day: u8

Contains the day number of the Date instance

month: u8

Contains the month number of the Date instance

year: i32

Contains the year number of the Date instance

Implementations

impl Date

pub fn is_valid(&self) -> bool

Checks if a Date is valid

Example

 use perDiem::types::Date;
 
 assert_eq!(Date { day: 1, month: 1, year: 2000}.is_valid(), true);
 assert_eq!(Date { day: 29, month: 2, year: 2001}.is_valid(), false);
 assert_eq!(Date { day: 50, month: 4, year: 2000}.is_valid(), false);

pub fn allShare(vec: Vec<Date>) -> Vec<&'static str>

Returns a Vector of the shared fields in each Date from Vector

Example

 use perDiem::types::Date;
 
 let shares_vec = Date::allShare(vec![Date::from(1, 1, 2001).unwrap(), Date::from(1, 1, 2000).unwrap()]);
 assert_eq!(shares_vec.contains(&"day"), true);
 assert_eq!(shares_vec.contains(&"month"), true);
 assert_eq!(shares_vec.contains(&"year"), false);

pub fn snapshot_date() -> Date

Takes a snapshot of the current date in Local time

pub fn days_in_month(&self) -> i8

Returns the # of days in the month of the Date/DateTime(Credit to TDark on Rust Discord)

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 1, 2000).unwrap().days_in_month(), 31);
 assert_eq!(Date::from(1, 2, 2000).unwrap().days_in_month(), 29);

pub fn datesShare( &self, datetime2: &Date, compare_type: &str ) -> Result<bool, &str>

same function of sharesDay, sharesMonth, sharesYear, but adds comparison field as a param.

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 5, 2000).unwrap().datesShare(&Date::from(1, 10, 2001).unwrap(), "day").unwrap(), true);
 assert_eq!(Date::from(1, 5, 2000).unwrap().datesShare(&Date::from(1, 10, 2001).unwrap(), "month").unwrap(), false);

pub fn is_after(&self, date: Date) -> bool

Takes self and Date fields and returns true if self is after the second, date, and false if not.

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 1, 2001).unwrap().is_after(Date::from(1, 1, 2000).unwrap()), true);
 assert_eq!(Date::from(1, 1, 2000).unwrap().is_after(Date::from(1, 1, 2001).unwrap()), false);

pub fn is_before(&self, date: Date) -> bool

Takes self and Date fields and returns true if self is before the second, date, and false if not.

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 1, 2000).unwrap().is_before(Date::from(1, 1, 2001).unwrap()), true);
 assert_eq!(Date::from(1, 1, 2001).unwrap().is_before(Date::from(1, 1, 2000).unwrap()), false);

impl Date

pub fn last_two_digits_year(&self) -> String

Returns the last two digits of the given year

Example

 
 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 1, 2021).unwrap().last_two_digits_year(), "21".to_string());

pub fn to_OrdinalDate(&self) -> Result<OrdinalDate, &'static str>

Converts given Date to OrdinalDate

Example

 use perDiem::types::{Date, OrdinalDate};
 
 assert_eq!(Date::from(1, 1, 2021).unwrap().to_OrdinalDate().unwrap(), OrdinalDate::from(1, 2021).unwrap());
 assert_eq!(Date::from(25, 5, 2021).unwrap().to_OrdinalDate().unwrap(), OrdinalDate::from(145, 2021).unwrap());

pub fn start_of_year(&mut self)

Changes Date to be start of year

Example

 use perDiem::types::Date;
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.start_of_year();
 assert_eq!(date, Date::from(1, 1, 2021).unwrap());

pub fn start_of_month(&mut self)

Changes Date to be start of current month

Example

 use perDiem::types::Date;
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.start_of_month();
 assert_eq!(date, Date::from(1, 11, 2021).unwrap());

pub fn end_of_year(&mut self)

Changes Date to be end of current year

Example

 use perDiem::types::Date;
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.end_of_year();
 assert_eq!(date, Date::from(31, 12, 2021).unwrap());

pub fn end_of_month(&mut self)

Changes Date to be end of current month

Example

 use perDiem::types::Date; 
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.end_of_month();
 assert_eq!(date, Date::from(30, 11, 2021).unwrap());

pub fn increase(&mut self, length: TimeSpan) -> Result<(), &'static str>

Increases the receiver-in-place Date by the TimeSpan specified and returns a Result.

Example

 use perDiem::types::{Date, TimeSpan};
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.increase(TimeSpan::days(5)).unwrap();
 assert_eq!(date, Date::from(25, 11, 2021).unwrap());

pub fn increase_ordinally( &mut self, length: TimeSpan ) -> Result<(), &'static str>

Increases the receiver-in-place Date by the TimeSpan specified and returns a result(same result as increase method, just better at larger increases)

Example

 use perDiem::types::{Date, TimeSpan};
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.increase_ordinally(TimeSpan::days(5));
 assert_eq!(date, Date::from(25, 11, 2021).unwrap());

pub fn decrease_ordinally( &mut self, length: TimeSpan ) -> Result<(), &'static str>

Decreases the receiver-in-place Date by the TimeSpan specified and returns a Result.

Example

 use perDiem::types::{Date, TimeSpan};
 
 let mut date = Date::from(20, 11, 2021).unwrap();
 date.decrease_ordinally(TimeSpan::days(5));
 assert_eq!(date, Date::from(15, 11, 2021).unwrap());

pub fn difference(&self, date: &Date) -> TimeDifference

Returns the difference between two Dates as a TimeDifference with seconds, minutes, and hours set to 0

Example

 use perDiem::types::{Date, TimeDifference};
 
 let date1 = Date::from(20, 11, 2021).unwrap();
 let date2 = Date::from(25, 5, 2024).unwrap();
 assert_eq!(date1.difference(&date2), TimeDifference {seconds: 0, minutes: 0, hours: 0, days: 5, months: 6, years: 3});

pub fn new() -> Date

Creates an instance of Date at the start of BCE

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::new(), Date::from(1, 1, 0).unwrap());

pub fn from(day: u8, month: u8, year: i32) -> Result<Date, &'static str>

Creates a instance of Date with fields provided

Example

 use perDiem::types::Date;
 
 assert_eq!(Date::from(1, 1, 2021).unwrap(), Date { day: 1, month: 1, year: 2021});

pub fn to_DateTime(&self) -> DateTime

Converts Date to DateTime and sets second, minute, and hour to 0.

Example

 use perDiem::types::{Date, DateTime};
 
 assert_eq!(Date::from(1, 1, 2021).unwrap().to_DateTime(), DateTime::from(0, 0, 0, 1, 1, 2021).unwrap());

pub fn decrease_ordinally_as_new( &self, length: TimeSpan ) -> Result<Date, &'static str>

Decreases given Date using conversion to ordinal for days. Much better at larger increases than other, but much poorer at smaller increases.*Difference is only for TimeSpan::days

Example

 use perDiem::types::{Date, TimeSpan};
 
 assert_eq!(Date::from(20, 11, 2021).unwrap().decrease_ordinally_as_new(TimeSpan::days(5)).unwrap(), Date::from(15, 11, 2021).unwrap());
 assert_eq!(Date::from(20, 11, 2021).unwrap().decrease_ordinally_as_new(TimeSpan::months(5)).unwrap(), Date::from(20, 6, 2021).unwrap());

pub fn increase_ordinally_as_new( &self, length: TimeSpan ) -> Result<Date, &'static str>

Increases given Date using conversion to ordinal for days. Much better at larger increases than other, but much poorer at smaller increases.*Difference is only for TimeSpan::days

Example

 use perDiem::types::{Date, TimeSpan};
 
 assert_eq!(Date::from(20, 11, 2021).unwrap().increase_ordinally_as_new(TimeSpan::days(5)).unwrap(), Date::from(25, 11, 2021).unwrap());
 assert_eq!(Date::from(20, 11, 2021).unwrap().increase_ordinally_as_new(TimeSpan::months(5)).unwrap(), Date::from(20, 4, 2022).unwrap());

pub fn increase_as_new(&self, length: TimeSpan) -> Result<Date, &'static str>

Creates a new instance of Date that has been incremented by given TimeSpan parameter

Example

 use perDiem::types::{Date, TimeSpan};
 
 assert_eq!(Date::from(20, 11, 2021).unwrap().increase_as_new(TimeSpan::days(5)).unwrap(), Date::from(25, 11, 2021).unwrap());
 assert_eq!(Date::from(20, 11, 2021).unwrap().increase_as_new(TimeSpan::months(5)).unwrap(), Date::from(20, 4, 2022).unwrap());

pub fn decrease_as_new(&self, _length: TimeSpan) -> Result<Date, &'static str>

Decreases Date by given TimeSpan parameter. (Unfinished, use decrease_ordinally_as_new)

impl Date

pub fn to_string( &self, date_format: &str, separator: &char ) -> Result<String, &str>

Converts a Date object to a String. Give date format something like ddmmyyyy or ddmmyy(for last two digits of year). And separator to output in the format given.

Example

 use perDiem::types::Date;
 let date = Date::from(1, 1, 2021).unwrap();
 assert_eq!(date.to_string("ddmmyyyy", &'/').unwrap(), "01/01/2021".to_string());
 assert_eq!(date.to_string("ddmmyy", &'-').unwrap(), "01-01-21".to_string());

pub fn to_ChronoNaiveDate(&self) -> Option<NaiveDate>

Converts a perDiem::types::Date to a chrono::NaiveDate

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

fn iter<'a>(&'a self) -> IntoIter<(&'static str, &'a dyn Any)>

Returns an iterator over the struct’s fields as tuples.

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

fn isStartOfMonth(&self) -> bool

Method returns bool if Date or DateTime is start of month.

Example

 use perDiem::types::Date;
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(1, 1, 2000).unwrap().isStartOfMonth(), true);
 assert_eq!(Date::from(15, 1, 2000).unwrap().isStartOfMonth(), false);

fn isEndOfMonth(&self) -> bool

Method returns bool if Date or DateTime is end of month.

Example

 use perDiem::types::Date; 
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(29, 2, 2000).unwrap().isEndOfMonth(), true);
 assert_eq!(Date::from(31, 3, 2000).unwrap().isEndOfMonth(), true);
 assert_eq!(Date::from(15, 1, 2000).unwrap().isEndOfMonth(), false);

fn isStartOfYear(&self) -> bool

Method returns bool if Date or DateTime is start of year.

Example

 use perDiem::types::Date;
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(1, 1, 2000).unwrap().isStartOfYear(), true);
 assert_eq!(Date::from(15, 1, 2000).unwrap().isStartOfYear(), false);

fn isEndOfYear(&self) -> bool

Method returns bool if Date or DateTime is end of year.

Example

 use perDiem::types::Date; 
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(31, 12, 2000).unwrap().isEndOfYear(), true);
 assert_eq!(Date::from(15, 1, 2000).unwrap().isEndOfYear(), false);

fn isLeapYear(&self) -> bool

Method pass Date or DateTime and returns true if Date or DateTime’s year field is a leap year

Example

 use perDiem::types::Date; 
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(1, 1, 2000).unwrap().isLeapYear(), true);
 assert_eq!(Date::from(1, 1, 2001).unwrap().isLeapYear(), false);
 assert_eq!(Date::from(1, 1, 1900).unwrap().isLeapYear(), false); // Make sure you understand leap year rules

fn weekday(&self) -> Result<String, &str>

Method returns the day of the week as a String of the Date or DateTime passed to it.

Example

 use perDiem::types::Date; 
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(22, 5, 2024).unwrap().weekday().unwrap(), "Wednesday");
 assert_eq!(Date::from(23, 5, 2024).unwrap().weekday().unwrap(), "Thursday");

fn weekday_as_int(&self) -> Result<u8, &str>

Method returns the day of the week as a i8 with 0 being Sunday

Example

use perDiem::evals::weekday_as_int;

println!(“Out test {}”, Date::from(23, 5, 2024).unwrap().weekday_as_int().unwrap()); assert_eq!(Date::from(23, 5, 2024).unwrap().weekday_as_int().unwrap(), 4); assert_eq!(Date::from(24, 5, 2024).unwrap().weekday_as_int().unwrap(), 5);

fn sharesDay(&self, date2: &Date) -> bool

Returns true if both params share the same day of month

Example

 use perDiem::types::Date;
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(1, 3, 2002).unwrap().sharesDay(&Date::from(1, 5, 2020).unwrap()), true);
 assert_eq!(Date::from(1, 3, 2020).unwrap().sharesDay(&Date::from(2, 3, 2020).unwrap()), false);

fn sharesYear(&self, date2: &Date) -> bool

Returns true if both params share the same year

Example

 use perDiem::types::Date;
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(5, 3, 2002).unwrap().sharesYear(&Date::from(1, 5, 2002).unwrap()), true);
 assert_eq!(Date::from(1, 3, 2000).unwrap().sharesYear(&Date::from(2, 3, 2020).unwrap()), false);

fn sharesMonth(&self, date2: &Date) -> bool

Returns true if both params share the same month

Example

 use perDiem::types::Date;
 use perDiem::types::datekindEvals;
 
 assert_eq!(Date::from(1, 3, 2002).unwrap().sharesMonth(&Date::from(15, 3, 2020).unwrap()), true);
 assert_eq!(Date::from(1, 3, 2000).unwrap().sharesMonth(&Date::from(2, 4, 2020).unwrap()), false);

impl Eq for Date

impl StructuralPartialEq for Date