Ignore:
Timestamp:
Jul 12, 2015, 3:52:43 PM (4 years ago)
Author:
nmedfort
Message:

Start of work to make the pablo compiler reenterant. Fixed bug that prevented it from using Less optimization level.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.h

    r4633 r4661  
    1717namespace UCD {
    1818
    19     std::string canonicalize_value_name(const std::string & prop_or_val);
     19std::string canonicalize_value_name(const std::string & prop_or_val);
    2020
    21         class PropertyObject {
    22         public:
    23         enum class ClassTypeId : unsigned {
    24             NumericProperty, CodepointProperty, StringProperty, MiscellaneousProperty, EnumeratedProperty, ExtensionProperty, CatalogProperty, BinaryProperty,  UnsupportedProperty
    25         };
    26         inline ClassTypeId getClassTypeId() const {
    27             return the_kind;
    28         }
    29                 PropertyObject(property_t p, ClassTypeId k) : the_property(p), the_kind(k) {}
    30         virtual int GetPropertyValueEnumCode(const std::string & value_spec);
    31                 property_t the_property;
    32                 ClassTypeId the_kind;
    33         };
    34        
    35         class UnsupportedPropertyObject : public PropertyObject {
    36         public:
    37         static inline bool classof(const PropertyObject * p) {
    38             return p->getClassTypeId() == ClassTypeId::UnsupportedProperty;
    39         }
    40         static inline bool classof(const void *) {
    41             return false;
    42         }
    43        
    44                 UnsupportedPropertyObject(property_t p, ClassTypeId k) : PropertyObject(p, k) {}
    45         UnicodeSet GetCodepointSet(const std::string &);
    46         UnicodeSet GetCodepointSet(const int);
    47         };
    48        
    49         class EnumeratedPropertyObject : public PropertyObject {
    50         public:
    51         static inline bool classof(const PropertyObject * p) {
    52             return p->getClassTypeId() == ClassTypeId::EnumeratedProperty;
    53         }
    54         static inline bool classof(const void *) {
    55             return false;
    56         }
    57                
     21class PropertyObject {
     22public:
     23    enum class ClassTypeId : unsigned {
     24        NumericProperty
     25        , CodepointProperty
     26        , StringProperty
     27        , MiscellaneousProperty
     28        , EnumeratedProperty
     29        , ExtensionProperty
     30        , CatalogProperty
     31        , BinaryProperty
     32        , UnsupportedProperty
     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 int GetPropertyValueEnumCode(const std::string & value_spec);
     43    property_t the_property;
     44    ClassTypeId the_kind;
     45};
    5846
    59                 EnumeratedPropertyObject(UCD::property_t p,
    60                                  const std::vector<std::string> & enum_names,
    61                                  const std::vector<std::string> & names,
    62                                  std::unordered_map<std::string, int> & aliases,
    63                                  std::vector<const UnicodeSet *> && sets)
    64         : PropertyObject(p, ClassTypeId::EnumeratedProperty)
    65         , property_value_enum_names(enum_names)
    66         , property_value_full_names(names)
    67         , property_value_aliases(aliases)
    68         , uninitialized(true)
    69         , property_value_sets(sets) {
     47class UnsupportedPropertyObject : public PropertyObject {
     48public:
     49    static inline bool classof(const PropertyObject * p) {
     50        return p->getClassTypeId() == ClassTypeId::UnsupportedProperty;
     51    }
     52    static inline bool classof(const void *) {
     53        return false;
     54    }
     55
     56    UnsupportedPropertyObject(property_t p, ClassTypeId k) : PropertyObject(p, k) {}
     57    UnicodeSet GetCodepointSet(const std::string &);
     58    UnicodeSet GetCodepointSet(const int);
     59};
     60
     61class EnumeratedPropertyObject : public PropertyObject {
     62public:
     63    static inline bool classof(const PropertyObject * p) {
     64        return p->getClassTypeId() == ClassTypeId::EnumeratedProperty;
     65    }
     66    static inline bool classof(const void *) {
     67        return false;
     68    }
     69
     70    EnumeratedPropertyObject(UCD::property_t p,
     71                             const std::vector<std::string> & enum_names,
     72                             const std::vector<std::string> & names,
     73                             std::unordered_map<std::string, int> & aliases,
     74                             std::vector<const UnicodeSet *> && sets)
     75    : PropertyObject(p, ClassTypeId::EnumeratedProperty)
     76    , property_value_enum_names(enum_names)
     77    , property_value_full_names(names)
     78    , property_value_aliases(aliases)
     79    , uninitialized(true)
     80    , property_value_sets(sets) {
     81
     82    }
     83
     84    virtual int GetPropertyValueEnumCode(const std::string & value_spec);
     85    const UnicodeSet & GetCodepointSet(const std::string & value_spec);
     86    const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
     87
     88    iterator begin() const {
     89        return property_value_enum_names.cbegin();
     90    }
     91
     92     iterator end() const {
     93        return property_value_enum_names.cend();
     94    }
     95
     96private:
     97    const std::vector<std::string> & property_value_enum_names;  // never changes
     98    const std::vector<std::string> & property_value_full_names;  // never changes
     99    std::unordered_map<std::string, int> & property_value_aliases;
     100    bool uninitialized; // full names must be added dynamically.
     101    const std::vector<const UnicodeSet *> property_value_sets;
     102};
     103
     104class ExtensionPropertyObject : public PropertyObject {
     105public:
     106    static inline bool classof(const PropertyObject * p) {
     107        return p->getClassTypeId() == ClassTypeId::ExtensionProperty;
     108    }
     109    static inline bool classof(const void *) {
     110        return false;
     111    }
     112
     113    ExtensionPropertyObject(UCD::property_t p,
     114                            UCD::property_t base,
     115                            std::vector<const UnicodeSet *> && sets)
     116    : PropertyObject(p, ClassTypeId::ExtensionProperty)
     117    , base_property(base)
     118    , property_value_sets(sets) {
    70119
    71120
    72         }
     121    }
    73122
    74         virtual int GetPropertyValueEnumCode(const std::string & value_spec);
    75         const UnicodeSet & GetCodepointSet(const std::string & value_spec);
    76         const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
    77                
    78         private:
    79         const std::vector<std::string> & property_value_enum_names;  // never changes
    80         const std::vector<std::string> & property_value_full_names;  // never changes
    81         std::unordered_map<std::string, int> & property_value_aliases;
    82         bool uninitialized; // full names must be added dynamically.
    83         const std::vector<const UnicodeSet *> property_value_sets;
    84         };
    85        
    86         class ExtensionPropertyObject : public PropertyObject {
    87         public:
    88         static inline bool classof(const PropertyObject * p) {
    89             return p->getClassTypeId() == ClassTypeId::ExtensionProperty;
    90         }
    91         static inline bool classof(const void *) {
    92             return false;
    93         }
    94                
     123    iterator begin() const;
    95124
    96                 ExtensionPropertyObject(UCD::property_t p,
    97                                  UCD::property_t base,
    98                                  std::vector<const UnicodeSet *> && sets)
    99         : PropertyObject(p, ClassTypeId::ExtensionProperty)
    100         , base_property(base)
    101         , property_value_sets(sets) {
     125    iterator end() const;
    102126
     127    virtual int GetPropertyValueEnumCode(const std::string & value_spec);
     128    const UnicodeSet & GetCodepointSet(const std::string & value_spec);
     129    const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
    103130
    104         }
     131private:
     132    const property_t base_property;
     133    const std::vector<const UnicodeSet *> property_value_sets;
     134};
    105135
    106         virtual int GetPropertyValueEnumCode(const std::string & value_spec);
    107         const UnicodeSet & GetCodepointSet(const std::string & value_spec);
    108         const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
    109                
    110         private:
    111         const property_t base_property;
    112         const std::vector<const UnicodeSet *> property_value_sets;
    113         };
    114        
    115         class BinaryPropertyObject : public PropertyObject {
    116         public:
    117         static inline bool classof(const PropertyObject * p) {
    118             return p->getClassTypeId() == ClassTypeId::BinaryProperty;
    119         }
    120         static inline bool classof(const void *) {
    121             return false;
    122         }
    123                
    124         BinaryPropertyObject(UCD::property_t p, UnicodeSet s)
     136class BinaryPropertyObject : public PropertyObject {
     137public:
     138    static inline bool classof(const PropertyObject * p) {
     139        return p->getClassTypeId() == ClassTypeId::BinaryProperty;
     140    }
     141    static inline bool classof(const void *) {
     142        return false;
     143    }
     144
     145    BinaryPropertyObject(UCD::property_t p, UnicodeSet s)
    125146        : PropertyObject(p, ClassTypeId::BinaryProperty)
    126147        , the_codepoint_set(s) {
    127148
    128         }
    129         UnicodeSet GetCodepointSet(const std::string & value_spec) const;
    130         UnicodeSet GetCodepointSet(const int property_enum_val) const;
    131     private:
    132                 UnicodeSet the_codepoint_set;       
    133         };
    134        
     149    }
     150    UnicodeSet GetCodepointSet(const std::string & value_spec) const;
     151    UnicodeSet GetCodepointSet(const int property_enum_val) const;
     152private:
     153    UnicodeSet the_codepoint_set;
     154};
     155
    135156}
    136        
     157
    137158#endif
Note: See TracChangeset for help on using the changeset viewer.