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

Last change on this file was 6228, checked in by nmedfort, 4 months ago

redesign of PopCount? calculation + mem leak fix

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