char_set 0.0.1

A library providing a high-performance char set.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Provides a CharSet type which is an optimized Set<char>.
//!
//! This types is analogous to IntegerSet<char>, which is not viable
//! since char does not implement the Num trait and is not contiguous
//! by as it is Unicode.

extern crate integer_set;
extern crate interval;

use self::interval::Collection;
use self::interval::Interval;
use self::interval::Set;

use integer_set::IntegerSet;

// CharSet is just a wrapper over IntegerSet<u32>.
#[deriving(PartialEq, Show)]
pub struct CharSet(IntegerSet<u32>);

impl CharSet {
    fn new(i: Interval<u32>) -> CharSet {
        CharSet(IntegerSet::new(vec![i]))
    }
    /// Creates a new instance containing a single character.
    pub fn for_char(c: char) -> CharSet {
        CharSet::for_range(c, c)
    }
    /// Creates a new instance spanning [begin, end].
    pub fn for_range(begin: char, end: char) -> CharSet {
        CharSet::new(Interval::new(begin as u32, end as u32))
    }

    // TODO It would be useful to represent a non-closed interval
    // since we can't perform arithmetic on chars due to their
    // non-contiguous nature.

    fn to_integer_set(self) -> IntegerSet<u32> {
        match self { CharSet(n) => n }
    }

    fn as_integer_set(&self) -> &IntegerSet<u32> {
        match self { &CharSet(ref n) => n }
    }
}

impl Collection for CharSet {
    fn is_empty(&self) -> bool { self.as_integer_set().is_empty() }
    fn len(&self) -> uint { self.as_integer_set().len() }
}

impl Set<char> for CharSet {
    fn contains(&self, value: &char) -> bool {
        self.as_integer_set().contains(&(*value as u32))
    }
    fn is_disjoint(&self, other: &CharSet) -> bool {
        self.as_integer_set().is_disjoint(other.as_integer_set())
    }
    fn is_subset(&self, other: &CharSet) -> bool {
        self.as_integer_set().is_subset(other.as_integer_set())
    }
}

impl Add<CharSet, CharSet> for CharSet {
    fn add(self, other: CharSet) -> CharSet {
        CharSet(self.to_integer_set() + other.to_integer_set())
    }
}

impl Add<char, CharSet> for CharSet {
    fn add(self, other: char) -> CharSet { self + CharSet::for_char(other) }
}


// TODO Implement Sub trait.

#[test]
fn test_singleton_contains() {
    let set = CharSet::for_char('b');
    assert!(set.contains(&'b'));
    assert!(!set.contains(&'a'));
    assert!(!set.contains(&'c'));
}

#[test]
fn test_range_contains() {
    let set = CharSet::for_range('d', 'f');
    assert!(set.contains(&'d'));
    assert!(set.contains(&'e'));
    assert!(set.contains(&'f'));
    assert!(!set.contains(&'c'));
    assert!(!set.contains(&'g'));
}

#[test]
fn test_union() {
    let set = CharSet::for_char('c') + CharSet::for_range('e', 'f');
    assert!(set.contains(&'c'));
    assert!(set.contains(&'e'));
    assert!(set.contains(&'f'));
    assert!(!set.contains(&'b'));
    assert!(!set.contains(&'d'));
    assert!(!set.contains(&'g'));
}

// TODO Test is good, but doesn't work due to lack of Sub trait on
// CharSet.
#[test]
#[ignore]
#[cfg(do_not_compile)]
fn test_difference() {
    let set = CharSet::for_range('a', 'z') - CharSet::for_range('c', 'd');
    assert!(set.contains(&'a'));
    assert!(set.contains(&'z'));
    assert!(set.contains(&'b'));
    assert!(set.contains(&'e'));
    assert!(!set.contains(&'c'));
    assert!(!set.contains(&'d'));

    let set = CharSet::for_range('a', 'c') - CharSet::for_char('a');
    assert!(set.contains(&'b'));
    assert!(set.contains(&'c'));
    assert!(!set.contains(&'a'));
}