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

Last change on this file since 5672 was 5672, checked in by cameron, 2 years ago

StringOverride? properties (simple case conversion vs full case conversion)

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