source: icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.h @ 6138

Last change on this file since 6138 was 6138, checked in by cameron, 12 months ago

Unicode decomposition, casefolding: initial check-in

File size: 11.2 KB
Line 
1#ifndef PROPERTYOBJECTS_H
2#define PROPERTYOBJECTS_H
3/*
4 *  Copyright (c) 2014 International Characters, Inc.
5 *  This software is licensed to the public under the Open Software License 3.0.
6 *  icgrep is a trademark of International Characters, Inc.
7 *
8 */
9
10#include "PropertyAliases.h"
11#include "PropertyValueAliases.h"
12#include "unicode_set.h"
13#include <string>
14#include <vector>
15#include <unordered_map>
16namespace re {class RE;}
17
18namespace UCD {
19
20std::string canonicalize_value_name(const std::string & prop_or_val);
21
22class PropertyObject {
23public:
24    enum class ClassTypeId : unsigned {
25        BinaryProperty,
26        EnumeratedProperty,
27        ExtensionProperty,
28        NumericProperty,
29        StringProperty,
30        StringOverrideProperty,
31        ObsoleteProperty,
32        UnsupportedProperty
33    };
34
35    using iterator = const std::vector<std::string>::const_iterator;
36    inline ClassTypeId getClassTypeId() const {
37        return the_kind;
38    }
39    inline property_t getPropertyCode() const {
40        return the_property;
41    }
42    PropertyObject(property_t p, ClassTypeId k) : the_property(p), the_kind(k) {}
43    virtual const UnicodeSet GetCodepointSet(const std::string & prop_value_string);
44    virtual const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern);
45    virtual const UnicodeSet GetReflexiveSet();
46    virtual const std::string GetStringValue(UCD::codepoint_t cp);
47
48    virtual const std::string & GetPropertyValueGrepString();
49    property_t the_property;
50    ClassTypeId the_kind;
51};
52
53class BinaryPropertyObject : public PropertyObject {
54public:
55    static inline bool classof(const PropertyObject * p) {
56        return p->getClassTypeId() == ClassTypeId::BinaryProperty;
57    }
58    static inline bool classof(const void *) {
59        return false;
60    }
61   
62    BinaryPropertyObject(UCD::property_t p, const UnicodeSet && set)
63    : PropertyObject(p, ClassTypeId::BinaryProperty)
64    , mNoUninitialized(true)
65    , mY(std::move(set)) {
66       
67    }
68    const UnicodeSet GetCodepointSet(const std::string & prop_value_string) override;
69    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
70    const UnicodeSet & GetCodepointSet(const int property_enum_val);
71    const std::string & GetPropertyValueGrepString() override;
72private:
73    bool mNoUninitialized;
74    const UnicodeSet mY;
75    UnicodeSet mN;
76    std::string mPropertyValueGrepString;
77};
78
79class EnumeratedPropertyObject : public PropertyObject {
80public:
81    static inline bool classof(const PropertyObject * p) {
82        return p->getClassTypeId() == ClassTypeId::EnumeratedProperty;
83    }
84    static inline bool classof(const void *) {
85        return false;
86    }
87
88    EnumeratedPropertyObject(UCD::property_t p,
89                             const unsigned independent_enums,
90                             const std::vector<std::string> && enum_names,
91                             const std::vector<std::string> && names,
92                             std::unordered_map<std::string, int> && aliases,
93                             std::vector<const UnicodeSet *> && sets)
94    : PropertyObject(p, ClassTypeId::EnumeratedProperty)
95    , independent_enum_count(independent_enums)
96    , property_value_enum_names(std::move(enum_names))
97    , property_value_full_names(std::move(names))
98    , property_value_aliases(std::move(aliases))
99    , uninitialized(true)
100    , property_value_sets(std::move(sets)) {
101
102    }
103
104    virtual int GetPropertyValueEnumCode(const std::string & value_spec);
105    const std::string & GetPropertyValueGrepString() override;
106    const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
107    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
108    const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
109    std::vector<UnicodeSet> & GetEnumerationBasisSets();
110    const std::string & GetValueEnumName(const int property_enum_val) const {return property_value_enum_names[property_enum_val]; }
111    const std::string & GetValueFullName(const int property_enum_val) const {return property_value_full_names[property_enum_val]; }
112
113    iterator begin() const {
114        return property_value_enum_names.cbegin();
115    }
116
117    iterator end() const {
118        return property_value_enum_names.cend();
119    }
120
121private:
122    const unsigned independent_enum_count;
123    const std::vector<std::string> property_value_enum_names;
124    const std::vector<std::string> property_value_full_names;
125    std::unordered_map<std::string, int> property_value_aliases;
126    std::string mPropertyValueGrepString;
127    bool uninitialized; // full names must be added dynamically.
128    const std::vector<const UnicodeSet *> property_value_sets;
129    std::vector<UnicodeSet> enumeration_basis_sets;
130};
131
132class ExtensionPropertyObject : public PropertyObject {
133public:
134    static inline bool classof(const PropertyObject * p) {
135        return p->getClassTypeId() == ClassTypeId::ExtensionProperty;
136    }
137    static inline bool classof(const void *) {
138        return false;
139    }
140
141    ExtensionPropertyObject(UCD::property_t p,
142                            UCD::property_t base,
143                            const std::vector<const UnicodeSet *> && sets)
144    : PropertyObject(p, ClassTypeId::ExtensionProperty)
145    , base_property(base)
146    , property_value_sets(sets) {
147
148
149    }
150
151    iterator begin() const;
152
153    iterator end() const;
154
155    int GetPropertyValueEnumCode(const std::string & value_spec);
156    const std::string & GetPropertyValueGrepString() override;
157    const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
158    const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
159    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
160
161private:
162    const property_t base_property;
163    const std::vector<const UnicodeSet *> property_value_sets;
164};
165
166class NumericPropertyObject : public PropertyObject {
167public:
168    static inline bool classof(const PropertyObject * p) {
169        return p->getClassTypeId() == ClassTypeId::NumericProperty;
170    }
171    static inline bool classof(const void *) {
172        return false;
173    }
174   
175    NumericPropertyObject(UCD::property_t p, const UnicodeSet && NaN_Set, const char * string_buffer, unsigned bufsize, const std::vector<UCD::codepoint_t> && cps)
176    : PropertyObject(p, ClassTypeId::NumericProperty)
177    , mNaNCodepointSet(std::move(NaN_Set))
178    , mStringBuffer(string_buffer)
179    , mBufSize(bufsize)
180    , mExplicitCps(std::move(cps))
181    {
182       
183    }
184    const UnicodeSet GetCodepointSet(const std::string & numeric_spec) override;
185    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
186
187private:
188    const UnicodeSet mNaNCodepointSet;  // codepoints for which the property value is NaN (not a number).
189    const char * mStringBuffer;  // buffer holding all string values for other codepoints, in sorted order.
190    unsigned mBufSize;
191    const std::vector<UCD::codepoint_t> mExplicitCps;
192};
193
194class StringPropertyObject : public PropertyObject {
195public:
196    static inline bool classof(const PropertyObject * p) {
197        return p->getClassTypeId() == ClassTypeId::StringProperty;
198    }
199    static inline bool classof(const void *) {
200        return false;
201    }
202    StringPropertyObject(UCD::property_t p, const UnicodeSet && nullSet, const UnicodeSet && mapsToSelf, const char * string_buffer,
203                         const std::vector<unsigned> && offsets, const std::vector<UCD::codepoint_t> && cps)
204    : PropertyObject(p, ClassTypeId::StringProperty)
205    , mNullCodepointSet(std::move(nullSet))
206    , mSelfCodepointSet(std::move(mapsToSelf))
207    , mStringBuffer(string_buffer)
208    , mStringOffsets(offsets)
209    , mExplicitCps(cps)
210    {
211
212    }
213    const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
214    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
215    const UnicodeSet GetReflexiveSet() override;
216    const std::string GetStringValue(UCD::codepoint_t cp) override;
217   
218private:
219    const UnicodeSet mNullCodepointSet;  // codepoints for which the property value is the null string.
220    const UnicodeSet mSelfCodepointSet;  // codepoints for which the property value is the codepoint itself.
221    // Codepoints other than those in these two sets are explicitly represented.
222    const char * mStringBuffer;  // buffer holding all string values for explicit codepoints, in sorted order.
223    const std::vector<unsigned> mStringOffsets;        // the offsets of each string within the buffer.
224    //unsigned mBufSize;                               // mStringOffsets has one extra element for buffer size.
225    const std::vector<UCD::codepoint_t> mExplicitCps;  // the codepoints having explicit strings
226};
227   
228class StringOverridePropertyObject : public PropertyObject {
229public:
230    static inline bool classof(const PropertyObject * p) {
231        return p->getClassTypeId() == ClassTypeId::StringOverrideProperty;
232    }
233    static inline bool classof(const void *) {
234        return false;
235    }
236    StringOverridePropertyObject(UCD::property_t p, PropertyObject & baseObj, const UnicodeSet && overriddenSet, const char * string_buffer,
237                                 const std::vector<unsigned> && offsets, const std::vector<UCD::codepoint_t> && cps)
238    : PropertyObject(p, ClassTypeId::StringOverrideProperty)
239    , mBaseObject(baseObj)
240    , mOverriddenSet(std::move(overriddenSet))
241    , mStringBuffer(string_buffer)
242    , mStringOffsets(offsets)
243    , mExplicitCps(cps)
244    {
245       
246    }
247    const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
248    const UnicodeSet GetCodepointSetMatchingPattern(re::RE * pattern) override;
249    const UnicodeSet GetReflexiveSet() override;
250    const PropertyObject & GetBaseObject() {return mBaseObject;}
251    const UnicodeSet & GetOverriddenSet() {return mOverriddenSet;}
252    const std::string GetStringValue(UCD::codepoint_t cp) override;
253
254private:
255    PropertyObject & mBaseObject;  // the base object that provides default values for this property unless overridden.
256    const UnicodeSet mOverriddenSet;   // codepoints for which the baseObject value is overridden.
257    const char * mStringBuffer;  // buffer holding all string values for overridden codepoints, in sorted order.
258    const std::vector<unsigned> mStringOffsets;        // the offsets of each string within the buffer.
259    //unsigned mBufSize;                               // mStringOffsets has one extra element for buffer size.
260    const std::vector<codepoint_t> mExplicitCps;
261};
262   
263class ObsoletePropertyObject : public PropertyObject {
264public:
265    static inline bool classof(const PropertyObject * p) {
266        return p->getClassTypeId() == ClassTypeId::ObsoleteProperty;
267    }
268    static inline bool classof(const void *) {
269        return false;
270    }
271   
272    ObsoletePropertyObject(property_t p)
273    : PropertyObject(p, ClassTypeId::ObsoleteProperty) {}
274   
275    const std::string & GetPropertyValueGrepString() override;
276    const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
277
278};
279
280class UnsupportedPropertyObject : public PropertyObject {
281public:
282    static inline bool classof(const PropertyObject * p) {
283        return p->getClassTypeId() == ClassTypeId::UnsupportedProperty;
284    }
285    static inline bool classof(const void *) {
286        return false;
287    }
288   
289    UnsupportedPropertyObject(property_t p, ClassTypeId)
290    : PropertyObject(p, ClassTypeId::UnsupportedProperty) {}
291};
292}
293
294#endif
Note: See TracBrowser for help on using the repository browser.