Struct WeekdaySet

pub struct WeekdaySet(/* private fields */);

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.

Implementations

impl WeekdaySet

pub const EMPTY: WeekdaySet

An empty WeekdaySet.

pub const ALL: WeekdaySet

A WeekdaySet containing all seven Weekdays.

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

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

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: WeekdaySet) -> 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: WeekdaySet) -> WeekdaySet

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: WeekdaySet) -> WeekdaySet

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: WeekdaySet) -> WeekdaySet

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: WeekdaySet) -> WeekdaySet

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

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<(), Error>

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<(), Error>

Formats the value using the given formatter.

impl FromIterator<Weekday> for WeekdaySet

fn from_iter<T>(iter: T) -> WeekdaySet

where T: IntoIterator<Item = Weekday>,

Creates a value from an iterator.

impl Hash for WeekdaySet

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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