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

Last change on this file since 6194 was 6186, checked in by cameron, 7 months ago

Various clean-ups

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