Struct compact_calendar::CompactCalendar
source · pub struct CompactCalendar { /* private fields */ }
Expand description
A compact representation of included days in a range of years, using u32-based bit arrays.
Implementations§
source§impl CompactCalendar
impl CompactCalendar
sourcepub fn new(first_year: i32, last_year: i32) -> Self
pub fn new(first_year: i32, last_year: i32) -> Self
Create a new year that does not include any day but has the capacity to add any new day in
the range of [first_year, last_year]
.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2055, 7, 5).unwrap();
let mut cal = CompactCalendar::new(2020, 2050);
assert!(!cal.insert(day1));
assert!(cal.insert(day2));
assert!(!cal.insert(day3));
assert_eq!(cal.count(), 1);
sourcepub const fn empty() -> Self
pub const fn empty() -> Self
Create a new calendar year that does not include any day and does not have the capacity to add any.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let mut cal = CompactCalendar::empty();
assert!(!cal.insert(NaiveDate::from_ymd_opt(2013, 11, 3).unwrap()));
assert_eq!(cal.count(), 0);
sourcepub fn year_for(&self, date: NaiveDate) -> Option<&CompactYear>
pub fn year_for(&self, date: NaiveDate) -> Option<&CompactYear>
Get a reference to the year containing give date.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2055, 3, 5).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(day1);
assert!(cal.year_for(day1).unwrap().contains(11, 3));
assert!(cal.year_for(day2).is_none());
sourcepub fn year_for_mut(&mut self, date: NaiveDate) -> Option<&mut CompactYear>
pub fn year_for_mut(&mut self, date: NaiveDate) -> Option<&mut CompactYear>
Get a mutable reference to the year containing give date.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2055, 7, 5).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
assert!(cal.year_for_mut(day3).is_none());
cal.insert(day1);
assert!(cal.year_for_mut(day1).unwrap().contains(11, 3));
cal.year_for_mut(day2).unwrap().insert(3, 5);
assert!(cal.contains(day2));
sourcepub fn insert(&mut self, date: NaiveDate) -> bool
pub fn insert(&mut self, date: NaiveDate) -> bool
Include a day in this calendar. Return false if the given day was not inserted because it does not belong to the year range of this calendar.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2055, 9, 7).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
assert!(cal.insert(day1));
assert!(cal.insert(day1));
assert!(cal.insert(day2));
assert_eq!(cal.count(), 2);
assert!(!cal.insert(day3));
assert_eq!(cal.count(), 2);
sourcepub fn contains(&self, date: NaiveDate) -> bool
pub fn contains(&self, date: NaiveDate) -> bool
Check if this calendar includes the given day.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2022, 8, 12).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(day1);
cal.insert(day2);
assert!(cal.contains(day1));
assert!(cal.contains(day2));
assert!(!cal.contains(day3));
sourcepub fn iter(&self) -> impl Iterator<Item = NaiveDate> + '_
pub fn iter(&self) -> impl Iterator<Item = NaiveDate> + '_
Iterate over the days included in this calendar.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2022, 8, 12).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(day3);
cal.insert(day1);
cal.insert(day2);
let days: Vec<_> = cal.iter().collect();
assert_eq!(days, [day1, day2, day3])
sourcepub fn first_after(&self, date: NaiveDate) -> Option<NaiveDate>
pub fn first_after(&self, date: NaiveDate) -> Option<NaiveDate>
Get the first day included in this calendar that follows the input day, if such a day exists.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let day0 = NaiveDate::from_ymd_opt(2010, 1, 1).unwrap();
let day1 = NaiveDate::from_ymd_opt(2013, 11, 3).unwrap();
let day2 = NaiveDate::from_ymd_opt(2022, 3, 5).unwrap();
let day3 = NaiveDate::from_ymd_opt(2022, 8, 12).unwrap();
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(day1);
cal.insert(day2);
cal.insert(day3);
assert_eq!(cal.first_after(day0), Some(day1));
assert_eq!(cal.first_after(day2), Some(day3));
assert_eq!(cal.first_after(day3), None);
sourcepub fn count(&self) -> u32
pub fn count(&self) -> u32
Count number of days included for this calendar.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(NaiveDate::from_ymd(2022, 8, 12));
cal.insert(NaiveDate::from_ymd(2022, 3, 5));
assert_eq!(cal.count(), 2);
sourcepub fn serialize(&self, writer: impl Write) -> Result<()>
pub fn serialize(&self, writer: impl Write) -> Result<()>
Serialize this calendar into a writer.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let mut cal = CompactCalendar::new(2000, 2050);
let mut buf1 = Vec::new();
cal.insert(NaiveDate::from_ymd(2022, 8, 12));
cal.serialize(&mut buf1).unwrap();
let mut buf2 = Vec::new();
cal.insert(NaiveDate::from_ymd(2022, 3, 5));
cal.serialize(&mut buf2).unwrap();
assert_ne!(buf1, buf2);
sourcepub fn deserialize(reader: impl Read) -> Result<Self>
pub fn deserialize(reader: impl Read) -> Result<Self>
Deserialize a calendar from a reader.
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let mut cal1 = CompactCalendar::new(2000, 2050);
cal1.insert(NaiveDate::from_ymd(2022, 8, 12));
cal1.insert(NaiveDate::from_ymd(2022, 3, 5));
let mut buf = Vec::new();
cal1.serialize(&mut buf).unwrap();
let cal2 = CompactCalendar::deserialize(buf.as_slice()).unwrap();
assert_eq!(cal1, cal2);
Trait Implementations§
source§impl Clone for CompactCalendar
impl Clone for CompactCalendar
source§fn clone(&self) -> CompactCalendar
fn clone(&self) -> CompactCalendar
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for CompactCalendar
impl Debug for CompactCalendar
source§fn fmt(&self, f: &mut Formatter<'_>) -> Result
fn fmt(&self, f: &mut Formatter<'_>) -> Result
use compact_calendar::CompactCalendar;
use chrono::NaiveDate;
let mut cal = CompactCalendar::new(2000, 2050);
cal.insert(NaiveDate::from_ymd(2022, 8, 12));
cal.insert(NaiveDate::from_ymd(2022, 3, 5));
assert_eq!(
format!("{cal:?}"),
"CompactCalendar { first_year: 2000, last_year: 2050, calendar: {2022-03-05, 2022-08-12} }",
);
source§impl Hash for CompactCalendar
impl Hash for CompactCalendar
source§impl Ord for CompactCalendar
impl Ord for CompactCalendar
source§fn cmp(&self, other: &CompactCalendar) -> Ordering
fn cmp(&self, other: &CompactCalendar) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl PartialEq for CompactCalendar
impl PartialEq for CompactCalendar
source§fn eq(&self, other: &CompactCalendar) -> bool
fn eq(&self, other: &CompactCalendar) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialOrd for CompactCalendar
impl PartialOrd for CompactCalendar
source§fn partial_cmp(&self, other: &CompactCalendar) -> Option<Ordering>
fn partial_cmp(&self, other: &CompactCalendar) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more