Struct CompactCalendar

pub struct CompactCalendar { /* private fields */ }

A compact representation of included days in a range of years, using u32-based bit arrays.

Implementations

impl CompactCalendar

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

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

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());

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

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

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

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

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

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

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

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

impl Clone for CompactCalendar

fn clone(&self) -> CompactCalendar

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompactCalendar

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} }",
);

impl Hash for CompactCalendar

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 CompactCalendar

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

Restrict a value to a certain interval.

impl PartialEq for CompactCalendar

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for CompactCalendar

impl StructuralPartialEq for CompactCalendar