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

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

Bug fix for CC insert_range and UnicodeSet? iterator.

File size: 6.0 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 * makeCC(const std::initializer_list<interval_t> list);
130    friend CC * makeCC(const std::vector<interval_t> & list);
131    friend CC * subtractCC(const CC * cc1, const CC * cc2);
132
133    inline CC()
134    : RE(ClassTypeId::CC)
135    , mSparseCharSet(mCharSetAllocator) {
136
137    }
138    CC(const CC & cc);
139    inline CC(const codepoint_t codepoint)
140    : RE(ClassTypeId::CC)
141    , mSparseCharSet(mCharSetAllocator) {
142        insert(codepoint);
143    }
144    inline CC(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint)
145    : RE(ClassTypeId::CC)
146    , mSparseCharSet(mCharSetAllocator) {
147        insert_range(lo_codepoint, hi_codepoint);
148    }
149    CC(const CC * cc1, const CC * cc2);
150
151    template <typename itr>
152    CC * initialize(itr begin, itr end);
153private:   
154    IntervalVector mSparseCharSet;
155    static IntervalAllocator mCharSetAllocator;
156};
157
158inline static CC::iterator begin(CC & cc) {
159    return cc.begin();
160}
161
162inline static CC::iterator end(CC & cc) {
163    return cc.end();
164}
165
166inline static CC::const_iterator begin(const CC & cc) {
167    return cc.cbegin();
168}
169
170inline static CC::const_iterator end(const CC & cc) {
171    return cc.cend();
172}
173
174inline codepoint_t & lo_codepoint(interval_t & i) {
175    return std::get<0>(i);
176}
177inline codepoint_t lo_codepoint(const interval_t & i) {
178    return std::get<0>(i);
179}
180inline codepoint_t & lo_codepoint(const CC::iterator i) {
181    return lo_codepoint(*i);
182}
183inline codepoint_t lo_codepoint(const CC::const_iterator i) {
184    return lo_codepoint(*i);
185}
186
187inline codepoint_t & hi_codepoint(interval_t & i) {
188    return std::get<1>(i);
189}
190inline codepoint_t hi_codepoint(const interval_t & i) {
191    return std::get<1>(i);
192}
193inline codepoint_t & hi_codepoint(const CC::iterator i) {
194    return hi_codepoint(*i);
195}
196inline codepoint_t hi_codepoint(const CC::const_iterator i) {
197    return hi_codepoint(*i);
198}
199
200template<typename itr>
201CC * CC::initialize(itr begin, itr end) {
202    mSparseCharSet.resize(std::distance(begin, end));
203    for (auto i = begin; i != end; ++i) {
204        assert (i == begin || lo_codepoint(*i) > max_codepoint());
205        mSparseCharSet[std::distance(begin, i)] = *i;
206    }
207    return this;
208}
209
210
211/**
212 * @brief RE::makeCC
213 *
214 * Various factory constructors for the RE CC class
215 *
216 * @return a CC object
217 */
218
219inline CC * makeCC() {
220    return new CC();
221}
222
223inline CC * makeCC(const codepoint_t codepoint) {
224    return new CC(codepoint);
225}
226
227inline CC * makeCC(const codepoint_t lo, const codepoint_t hi) {
228    return new CC(lo, hi);
229}
230
231inline CC * makeCC(const CC * cc1, const CC * cc2) {
232    return new CC(cc1, cc2);
233}
234
235inline CC * makeCC(const std::initializer_list<interval_t> list) {
236    return makeCC()->initialize(list.begin(), list.end());
237}
238
239inline CC * makeCC(const std::vector<interval_t> & list) {
240    return makeCC()->initialize(list.begin(), list.end());
241}
242
243CC * subtractCC(const CC * a, const CC * b);
244   
245CC * intersectCC(const CC * cc1, const CC * cc2);
246
247CC * caseInsensitize(const CC * cc);
248
249}
250
251#endif // RE_CC_H
Note: See TracBrowser for help on using the repository browser.