source: icGREP/icgrep-devel/icgrep/re/re_cc.h @ 4614

Last change on this file since 4614 was 4614, checked in by nmedfort, 4 years ago

Replaced CharSetItem? with a std::pair.

File size: 5.5 KB
Line 
1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#ifndef RE_CC_H
8#define RE_CC_H
9
10#include "re_re.h"
11
12#include <string>
13#include <vector>
14#include <slab_allocator.h>
15
16namespace re {
17
18using codepoint_t = unsigned;
19using interval_t = std::pair<codepoint_t, codepoint_t>;
20
21enum CC_type {UnicodeClass, ByteClass};
22
23class CC : public RE {
24public:
25
26    static inline bool classof(const RE * re) {
27        return re->getClassTypeId() == ClassTypeId::CC;
28    }
29    static inline bool classof(const void *) {
30        return false;
31    }
32
33    using IntervalAllocator = SlabAllocator<interval_t>;
34    using IntervalVector = std::vector<interval_t, IntervalAllocator>;
35
36    using iterator = IntervalVector::iterator;
37    using const_iterator = IntervalVector::const_iterator;
38    using size_type = IntervalVector::size_type;
39    using reference = IntervalVector::reference;
40    using const_reference = IntervalVector::const_reference;
41
42    static const codepoint_t UNICODE_MAX = 0x10FFFF;
43
44    std::string canonicalName(const CC_type type) const;
45
46    interval_t & operator [](unsigned i) {
47        return mSparseCharSet[i];
48    }
49
50    const interval_t & operator [](unsigned i) const {
51        return mSparseCharSet[i];
52    }
53
54    inline codepoint_t min_codepoint() const {
55        return empty() ? 0 : std::get<0>(front());
56    }
57
58    inline codepoint_t max_codepoint() const {
59        return empty() ? 0 : std::get<1>(back());
60    }
61
62    void insert_range(const codepoint_t lo, const codepoint_t hi);
63
64    void remove_range(const codepoint_t lo, const codepoint_t hi);
65
66    inline void insert(const codepoint_t codepoint) {
67        insert_range(codepoint, codepoint);
68    }
69
70    inline void remove(const codepoint_t codepoint) {
71        remove_range(codepoint, codepoint);
72    }
73
74    inline iterator begin() {
75        return mSparseCharSet.begin();
76    }
77
78    inline iterator end() {
79        return mSparseCharSet.end();
80    }
81
82    inline reference front() {
83        return mSparseCharSet.front();
84    }
85
86    inline reference back() {
87        return mSparseCharSet.back();
88    }
89
90    inline const_iterator begin() const {
91        return mSparseCharSet.cbegin();
92    }
93
94    inline const_iterator end() const {
95        return mSparseCharSet.cend();
96    }
97
98    inline const_iterator cbegin() const {
99        return mSparseCharSet.cbegin();
100    }
101
102    inline const_iterator cend() const {
103        return mSparseCharSet.cend();
104    }
105
106    inline const_reference front() const {
107        return mSparseCharSet.front();
108    }
109
110    inline const_reference back() const {
111        return mSparseCharSet.back();
112    }
113
114    inline size_type size() const {
115        return mSparseCharSet.size();
116    }
117
118    inline bool empty() const {
119        return mSparseCharSet.empty();
120    }
121
122    virtual ~CC() {}
123
124protected:
125    friend CC * makeCC();
126    friend CC * makeCC(const codepoint_t codepoint);
127    friend CC * makeCC(const codepoint_t lo, const codepoint_t hi);
128    friend CC * makeCC(const CC * cc1, const CC * cc2);
129    friend CC * subtractCC(const CC * cc1, const CC * cc2);
130    inline CC()
131    : RE(ClassTypeId::CC)
132    , mSparseCharSet(mCharSetAllocator) {
133
134    }
135    CC(const CC & cc);
136    inline CC(const codepoint_t codepoint)
137    : RE(ClassTypeId::CC)
138    , mSparseCharSet(mCharSetAllocator) {
139        insert(codepoint);
140    }
141    inline CC(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint)
142    : RE(ClassTypeId::CC)
143    , mSparseCharSet(mCharSetAllocator) {
144        insert_range(lo_codepoint, hi_codepoint);
145    }
146    CC(const CC * cc1, const CC * cc2);
147
148private:   
149    IntervalVector mSparseCharSet;
150    static IntervalAllocator mCharSetAllocator;
151};
152
153inline static CC::iterator begin(CC & cc) {
154    return cc.begin();
155}
156
157inline static CC::iterator end(CC & cc) {
158    return cc.end();
159}
160
161inline static CC::const_iterator begin(const CC & cc) {
162    return cc.cbegin();
163}
164
165inline static CC::const_iterator end(const CC & cc) {
166    return cc.cend();
167}
168
169inline codepoint_t & lo_codepoint(CC::reference i) {
170    return std::get<0>(i);
171}
172inline codepoint_t lo_codepoint(CC::const_reference i) {
173    return std::get<0>(i);
174}
175inline codepoint_t & lo_codepoint(const CC::iterator i) {
176    return lo_codepoint(*i);
177}
178inline codepoint_t lo_codepoint(const CC::const_iterator i) {
179    return lo_codepoint(*i);
180}
181
182inline codepoint_t & hi_codepoint(CC::reference i) {
183    return std::get<1>(i);
184}
185inline codepoint_t hi_codepoint(CC::const_reference i) {
186    return std::get<1>(i);
187}
188inline codepoint_t & hi_codepoint(const CC::iterator i) {
189    return hi_codepoint(*i);
190}
191inline codepoint_t hi_codepoint(const CC::const_iterator i) {
192    return hi_codepoint(*i);
193}
194
195
196/**
197 * @brief RE::makeCC
198 *
199 * Various factory constructors for the RE CC class
200 *
201 * @return a CC object
202 */
203
204inline CC * makeCC() {
205    return new CC();
206}
207
208inline CC * makeCC(const codepoint_t codepoint) {
209    return new CC(codepoint);
210}
211
212inline CC * makeCC(const codepoint_t lo, const codepoint_t hi) {
213    return new CC(lo, hi);
214}
215
216inline CC * makeCC(const CC * cc1, const CC * cc2) {
217    return new CC(cc1, cc2);
218}
219
220CC * subtractCC(const CC * a, const CC * b);
221   
222CC * intersectCC(const CC * cc1, const CC * cc2);
223
224CC * caseInsensitize(const CC * cc);
225
226CC * rangeIntersect(const CC * cc, const codepoint_t lo, const codepoint_t hi);
227
228CC * rangeGaps(const CC * cc, const codepoint_t lo, const codepoint_t hi);
229
230CC * outerRanges(const CC * cc);
231
232CC * innerRanges(const CC * cc);
233
234}
235
236#endif // RE_CC_H
Note: See TracBrowser for help on using the repository browser.