Struct WeekdaySet 

pub struct WeekdaySet(u8);

A collection of Weekdays stored as a single byte.

This type is Copy and provides efficient set-like and slice-like operations. Many operations are const as well.

Implemented as a bitmask where bits 1-7 correspond to Monday-Sunday.

Tuple Fields

0: u8

Implementations

impl WeekdaySet

pub const EMPTY: Self

An empty WeekdaySet.

pub const ALL: Self

A WeekdaySet containing all seven Weekdays.

pub const fn from_array<const C: usize>(days: [Weekday; C]) -> Self

Create a WeekdaySet from an array of Weekdays.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::EMPTY, WeekdaySet::from_array([]));
assert_eq!(WeekdaySet::single(Mon), WeekdaySet::from_array([Mon]));
assert_eq!(WeekdaySet::ALL, WeekdaySet::from_array([Mon, Tue, Wed, Thu, Fri, Sat, Sun]));

pub const fn single(weekday: Weekday) -> Self

Create a WeekdaySet from a single Weekday.

pub const fn single_day(self) -> Option<Weekday>

Returns Some(day) if this collection contains exactly one day.

Returns None otherwise.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).single_day(), Some(Mon));
assert_eq!(WeekdaySet::from_array([Mon, Tue]).single_day(), None);
assert_eq!(WeekdaySet::EMPTY.single_day(), None);
assert_eq!(WeekdaySet::ALL.single_day(), None);

pub fn insert(&mut self, day: Weekday) -> bool

Adds a day to the collection.

Returns true if the day was new to the collection.

Example

use chrono::Weekday::*;
let mut weekdays = WeekdaySet::single(Mon);
assert!(weekdays.insert(Tue));
assert!(!weekdays.insert(Tue));

pub fn remove(&mut self, day: Weekday) -> bool

Removes a day from the collection.

Returns true if the collection did contain the day.

Example

use chrono::Weekday::*;
let mut weekdays = WeekdaySet::single(Mon);
assert!(weekdays.remove(Mon));
assert!(!weekdays.remove(Mon));

pub const fn is_subset(self, other: Self) -> bool

Returns true if other contains all days in self.

Example

use chrono::Weekday::*;
assert!(WeekdaySet::single(Mon).is_subset(WeekdaySet::ALL));
assert!(!WeekdaySet::single(Mon).is_subset(WeekdaySet::EMPTY));
assert!(WeekdaySet::EMPTY.is_subset(WeekdaySet::single(Mon)));

pub const fn intersection(self, other: Self) -> Self

Returns days that are in both self and other.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Tue)), WeekdaySet::EMPTY);
assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::EMPTY), WeekdaySet::EMPTY);

pub const fn union(self, other: Self) -> Self

Returns days that are in either self or other.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
assert_eq!(WeekdaySet::ALL.union(WeekdaySet::single(Mon)), WeekdaySet::ALL);
assert_eq!(WeekdaySet::ALL.union(WeekdaySet::EMPTY), WeekdaySet::ALL);

pub const fn symmetric_difference(self, other: Self) -> Self

Returns days that are in self or other but not in both.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
assert_eq!(
    WeekdaySet::ALL.symmetric_difference(WeekdaySet::single(Mon)),
    WeekdaySet::from_array([Tue, Wed, Thu, Fri, Sat, Sun]),
);
assert_eq!(WeekdaySet::ALL.symmetric_difference(WeekdaySet::EMPTY), WeekdaySet::ALL);

pub const fn difference(self, other: Self) -> Self

Returns days that are in self but not in other.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Tue)), WeekdaySet::single(Mon));
assert_eq!(WeekdaySet::EMPTY.difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);

pub const fn first(self) -> Option<Weekday>

Get the first day in the collection, starting from Monday.

Returns None if the collection is empty.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
assert_eq!(WeekdaySet::EMPTY.first(), None);

pub fn last(self) -> Option<Weekday>

Get the last day in the collection, starting from Sunday.

Returns None if the collection is empty.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
assert_eq!(WeekdaySet::EMPTY.last(), None);

const fn split_at(self, weekday: Weekday) -> (Self, Self)

Split the collection in two at the given day.

Returns a tuple (before, after). before contains all days starting from Monday up to but not including weekday. after contains all days starting from weekday up to and including Sunday.

pub const fn iter(self, start: Weekday) -> WeekdaySetIter

Iterate over the Weekdays in the collection starting from a given day.

Wraps around from Sunday to Monday if necessary.

Example

use chrono::Weekday::*;
let weekdays = WeekdaySet::from_array([Mon, Wed, Fri]);
let mut iter = weekdays.iter(Wed);
assert_eq!(iter.next(), Some(Wed));
assert_eq!(iter.next(), Some(Fri));
assert_eq!(iter.next(), Some(Mon));
assert_eq!(iter.next(), None);

pub const fn contains(self, day: Weekday) -> bool

Returns true if the collection contains the given day.

Example

use chrono::Weekday::*;
assert!(WeekdaySet::single(Mon).contains(Mon));
assert!(WeekdaySet::from_array([Mon, Tue]).contains(Tue));
assert!(!WeekdaySet::single(Mon).contains(Tue));

pub const fn is_empty(self) -> bool

Returns true if the collection is empty.

Example

assert!(WeekdaySet::EMPTY.is_empty());
assert!(!WeekdaySet::single(Weekday::Mon).is_empty());

pub const fn len(self) -> u8

Returns the number of days in the collection.

Example

use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).len(), 1);
assert_eq!(WeekdaySet::from_array([Mon, Wed, Fri]).len(), 3);
assert_eq!(WeekdaySet::ALL.len(), 7);

Trait Implementations

impl Clone for WeekdaySet

fn clone(&self) -> WeekdaySet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WeekdaySet

Print the underlying bitmask, padded to 7 bits.

Example

use chrono::Weekday::*;
assert_eq!(format!("{:?}", WeekdaySet::single(Mon)), "WeekdaySet(0000001)");
assert_eq!(format!("{:?}", WeekdaySet::single(Tue)), "WeekdaySet(0000010)");
assert_eq!(format!("{:?}", WeekdaySet::ALL), "WeekdaySet(1111111)");

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

Formats the value using the given formatter.

impl Default for WeekdaySet

fn default() -> WeekdaySet

Returns the “default value” for a type.

impl Display for WeekdaySet

Print the collection as a slice-like list of weekdays.

Example

use chrono::Weekday::*;
assert_eq!("[]", WeekdaySet::EMPTY.to_string());
assert_eq!("[Mon]", WeekdaySet::single(Mon).to_string());
assert_eq!("[Mon, Fri, Sun]", WeekdaySet::from_array([Mon, Fri, Sun]).to_string());

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

Formats the value using the given formatter.

impl FromIterator<Weekday> for WeekdaySet

fn from_iter<T: IntoIterator<Item = Weekday>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for WeekdaySet

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 WeekdaySet

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

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

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

impl Eq for WeekdaySet

impl StructuralPartialEq for WeekdaySet