use std::collections::HashSet;
/// An unordered set of characters
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
///
/// struct AsciiCharacter;
///
/// impl CharacterSet for AsciiCharacter {
/// fn contains(&self, ch: char) -> bool {
/// ch.is_ascii()
/// }
/// }
/// ```
pub trait CharacterSet {
/// Returns `true` if the character set contains the given character.
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
/// use snob::csets::AsciiLetters;
///
/// assert!(AsciiLetters.contains('h'));
/// assert!(!AsciiLetters.contains(' '));
/// ```
fn contains(&self, ch: char) -> bool;
/// Returns a [`CharacterSet`] that contains the characters in the `self`
/// set, as well as any characters in the given `other` character set.
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
/// use snob::csets::AsciiLetters;
///
/// let cset = AsciiLetters.union(' ');
/// assert!(cset.contains('h'));
/// assert!(cset.contains(' '));
/// ```
fn union<Other: CharacterSet>(self, other: Other) -> CharacterSetUnion<Self, Other>
where
Self: Sized,
{
CharacterSetUnion {
first: self,
second: other,
}
}
/// Returns a [`CharacterSet`] that contains only the characters in both
/// of `self` and `other`.
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
/// use snob::csets::AsciiLetters;
///
/// let cset = AsciiLetters.intersection("Hello, world");
/// assert!(cset.contains('e'));
/// assert!(!cset.contains('a'));
/// assert!(!cset.contains(' '));
/// ```
fn intersection<Other: CharacterSet>(
self,
other: Other,
) -> CharacterSetIntersection<Self, Other>
where
Self: Sized,
{
CharacterSetIntersection {
first: self,
second: other,
}
}
/// Returns a [`CharacterSet`] that contains the characters in the `self`
/// character set, unless they are also contained in `other`.
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
/// use snob::csets::AsciiLetters;
///
/// let cset = AsciiLetters.difference("Hello, world");
/// assert!(cset.contains('a'));
/// assert!(!cset.contains('e'));
/// assert!(!cset.contains(' '));
/// ```
fn difference<Other: CharacterSet>(self, other: Other) -> CharacterSetDifference<Self, Other>
where
Self: Sized,
{
CharacterSetDifference {
first: self,
second: other,
}
}
/// Returns a [`CharacterSet`] that contains all of the characters that are
/// NOT contained in the `self` character set.
///
/// # Example
///
/// ```
/// use snob::csets::CharacterSet;
/// use snob::csets::AsciiLetters;
///
/// let cset = AsciiLetters.complement();
/// assert!(!cset.contains('a'));
/// assert!(cset.contains(' '));
/// ```
fn complement(self) -> CharacterSetComplement<Self>
where
Self: Sized,
{
CharacterSetComplement { inner: self }
}
}
/// Contains all Unicode characters
#[derive(Debug, Clone, Copy)]
pub struct AnyCharacter;
impl CharacterSet for AnyCharacter {
fn contains(&self, _: char) -> bool {
true
}
}
/// Contains all Unicode alphabetic characters
#[derive(Debug, Clone, Copy)]
pub struct Alphabetic;
impl CharacterSet for Alphabetic {
fn contains(&self, ch: char) -> bool {
ch.is_alphabetic()
}
}
/// Contains all Unicode lowercase characters
#[derive(Debug, Clone, Copy)]
pub struct Lowercase;
impl CharacterSet for Lowercase {
fn contains(&self, ch: char) -> bool {
ch.is_lowercase()
}
}
/// Contains all Unicode uppercase characters
#[derive(Debug, Clone, Copy)]
pub struct Uppercase;
impl CharacterSet for Uppercase {
fn contains(&self, ch: char) -> bool {
ch.is_uppercase()
}
}
/// Contains all Unicode whitespace characters
#[derive(Debug, Clone, Copy)]
pub struct Whitespace;
impl CharacterSet for Whitespace {
fn contains(&self, ch: char) -> bool {
ch.is_whitespace()
}
}
/// Contains all Unicode alphabetic or numeric characters
#[derive(Debug, Clone, Copy)]
pub struct Alphanumeric;
impl CharacterSet for Alphanumeric {
fn contains(&self, ch: char) -> bool {
ch.is_alphanumeric()
}
}
/// Contains all Unicode control chartacters
#[derive(Debug, Clone, Copy)]
pub struct Control;
impl CharacterSet for Control {
fn contains(&self, ch: char) -> bool {
ch.is_control()
}
}
/// Contains all Unicode numeric characters
#[derive(Debug, Clone, Copy)]
pub struct Numeric;
impl CharacterSet for Numeric {
fn contains(&self, ch: char) -> bool {
ch.is_numeric()
}
}
/// Contains all ASCII characters
#[derive(Debug, Clone, Copy)]
pub struct Ascii;
impl CharacterSet for Ascii {
fn contains(&self, ch: char) -> bool {
ch.is_ascii()
}
}
/// Contains all ASCII letters: a-z, A-Z
#[derive(Debug, Clone, Copy)]
pub struct AsciiAlphabetic;
impl CharacterSet for AsciiAlphabetic {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_alphabetic()
}
}
/// Contains all uppercase ASCII letters, A-Z
#[derive(Debug, Clone, Copy)]
pub struct AsciiUppercase;
impl CharacterSet for AsciiUppercase {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_uppercase()
}
}
/// Contains all lowercase ASCII letters, a-z
#[derive(Debug, Clone, Copy)]
pub struct AsciiLowercase;
impl CharacterSet for AsciiLowercase {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_lowercase()
}
}
/// Contains all ASCII characters a-z, A-Z, 0-9
#[derive(Debug, Clone, Copy)]
pub struct AsciiAlphanumeric;
impl CharacterSet for AsciiAlphanumeric {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_alphanumeric()
}
}
/// Contains the ASCII digits, 0-9
#[derive(Debug, Clone, Copy)]
pub struct AsciiDigits;
impl CharacterSet for AsciiDigits {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_digit()
}
}
/// Contains the ASCII hexadecimal digits: 0-9, a-f, A-F
#[derive(Debug, Clone, Copy)]
pub struct AsciiHexDigit;
impl CharacterSet for AsciiHexDigit {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_hexdigit()
}
}
/// Contains ASCII punctuation characters:
///
/// - U+0021 ..= U+002F `! " # $ % & ' ( ) * + , - . /`
/// - U+003A ..= U+0040 `: ; < = > ? @`
/// - U+005B ..= U+0060 ``[ \ ] ^ _ ` ``
/// - U+007B ..= U+007E `{ | } ~`
#[derive(Debug, Clone, Copy)]
pub struct AsciiPunctuation;
impl CharacterSet for AsciiPunctuation {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_punctuation()
}
}
/// Contains the ASCII graphic characters: `U+0021 (!) ..= U+007E (~)`
#[derive(Debug, Clone, Copy)]
pub struct AsciiGraphic;
impl CharacterSet for AsciiGraphic {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_graphic()
}
}
/// Contains the ASCII whitespace characters
#[derive(Debug, Clone, Copy)]
pub struct AsciiWhitespace;
impl CharacterSet for AsciiWhitespace {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_whitespace()
}
}
/// Contains the ASCII control characters:
/// `U+0000 (NUL) ..= U+001F (UNIT SEPARATOR)` or `U+007F (DELETE)`
#[derive(Debug, Clone, Copy)]
pub struct AsciiControl;
impl CharacterSet for AsciiControl {
fn contains(&self, ch: char) -> bool {
ch.is_ascii_control()
}
}
impl CharacterSet for char {
fn contains(&self, ch: char) -> bool {
*self == ch
}
}
impl CharacterSet for &[char] {
fn contains(&self, ch: char) -> bool {
(self as &[char]).contains(&ch)
}
}
impl CharacterSet for &str {
fn contains(&self, ch: char) -> bool {
self.chars().any(|c| c == ch)
}
}
impl CharacterSet for HashSet<char> {
fn contains(&self, ch: char) -> bool {
self.contains(&ch)
}
}
/// A union of two [`CharacterSet`]s.
///
/// This is created by calling [`CharacterSet::union`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CharacterSetUnion<A: CharacterSet, B: CharacterSet> {
first: A,
second: B,
}
impl<A: CharacterSet, B: CharacterSet> CharacterSet for CharacterSetUnion<A, B> {
fn contains(&self, ch: char) -> bool {
self.first.contains(ch) || self.second.contains(ch)
}
}
/// An intersection of two [`CharacterSet`]s.
///
/// This is created by calling [`CharacterSet::intersection`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CharacterSetIntersection<A: CharacterSet, B: CharacterSet> {
first: A,
second: B,
}
impl<A: CharacterSet, B: CharacterSet> CharacterSet for CharacterSetIntersection<A, B> {
fn contains(&self, ch: char) -> bool {
self.first.contains(ch) && self.second.contains(ch)
}
}
/// The difference of two [`CharacterSet`]s.
///
/// This is created by calling [`CharacterSet::difference`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CharacterSetDifference<A: CharacterSet, B: CharacterSet> {
first: A,
second: B,
}
impl<A: CharacterSet, B: CharacterSet> CharacterSet for CharacterSetDifference<A, B> {
fn contains(&self, ch: char) -> bool {
self.first.contains(ch) && !self.second.contains(ch)
}
}
/// The complement of a [`CharacterSet`].
///
/// This is created by calling [`CharacterSet::complement`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CharacterSetComplement<Inner: CharacterSet> {
inner: Inner,
}
impl<Inner: CharacterSet> CharacterSet for CharacterSetComplement<Inner> {
fn contains(&self, ch: char) -> bool {
!self.inner.contains(ch)
}
}
|
