Struct compact_calendar::CompactYear

pub struct CompactYear(_);

A compact representation of included days for a year, using a collection of u32-based bit array.

Implementations

impl CompactYear

pub const fn new() -> Self

Create a new year that does not include any day.

use compact_calendar::CompactYear;

let year = CompactYear::new();
assert_eq!(year.count(), 0);

pub fn insert(&mut self, month: u32, day: u32)

Include a day in this year.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(11, 3);
year.insert(11, 3);
year.insert(1, 25);
assert_eq!(year.count(), 2);

pub fn contains(&self, month: u32, day: u32) -> bool

Check if this year includes the given day.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(3, 1);
year.insert(9, 5);

assert!(year.contains(3, 1));
assert!(year.contains(9, 5));
assert!(!year.contains(7, 14));

pub fn iter(&self) -> impl Iterator<Item = (u32, u32)> + '_

Iterate over the days included in this year.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(9, 5);
year.insert(3, 1);

let days: Vec<_> = year.iter().collect();
assert_eq!(days, [(3, 1), (9, 5)])

pub fn first(&self) -> Option<(u32, u32)>

Get the first day included in this year if it is not empty.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
assert_eq!(year.first(), None);

year.insert(12, 31);
assert_eq!(year.first(), Some((12, 31)));

year.insert(5, 8);
assert_eq!(year.first(), Some((5, 8)));

pub fn first_after(&self, month: u32, day: u32) -> Option<(u32, u32)>

Get the first day included in this year that follows the input day, if such a day exists.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(3, 15);
year.insert(10, 9);
year.insert(2, 7);

assert_eq!(year.first_after(2, 2), Some((2, 7)));
assert_eq!(year.first_after(2, 7), Some((3, 15)));
assert_eq!(year.first_after(11, 1), None);

pub fn count(&self) -> u32

Count number of days included for this year.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(11, 3);
year.insert(4, 28);
assert_eq!(year.count(), 2);

pub fn serialize(&self, writer: impl Write) -> Result<()>

Serialize this year into a writer.

use compact_calendar::CompactYear;

let mut year = CompactYear::new();

let mut buf1 = Vec::new();
year.insert(11, 3);
year.serialize(&mut buf1).unwrap();

let mut buf2 = Vec::new();
year.insert(4, 28);
year.serialize(&mut buf2).unwrap();

assert_ne!(buf1, buf2);

pub fn deserialize(reader: impl Read) -> Result<Self>

Deserialize a year from a reader.

use compact_calendar::CompactYear;

let mut year1 = CompactYear::new();
year1.insert(11, 3);
year1.insert(4, 28);

let mut buf = Vec::new();
year1.serialize(&mut buf).unwrap();

let year2 = CompactYear::deserialize(buf.as_slice()).unwrap();
assert_eq!(year1, year2);

Trait Implementations

impl Clone for CompactYear

fn clone(&self) -> CompactYear

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompactYear

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

use compact_calendar::CompactYear;

let mut year = CompactYear::new();
year.insert(11, 3);
year.insert(4, 28);
assert_eq!(format!("{year:?}"), "{04-28, 11-03}");

impl Hash for CompactYear

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, 

Feeds a slice of this type into the given Hasher.

impl Ord for CompactYear

fn cmp(&self, other: &CompactYear) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl PartialEq<CompactYear> for CompactYear

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

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

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

This method tests for !=.

impl PartialOrd<CompactYear> for CompactYear

fn partial_cmp(&self, other: &CompactYear) -> 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 Copy for CompactYear

impl Eq for CompactYear

impl StructuralEq for CompactYear

impl StructuralPartialEq for CompactYear