source/i18n/collationsettings.h

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2013-2015, International Business Machines
   6 * Corporation and others.  All Rights Reserved.
   7 *******************************************************************************
   8 * collationsettings.h
   9 *
  10 * created on: 2013feb07
  11 * created by: Markus W. Scherer
  12 */
  13
  14 #ifndef __COLLATIONSETTINGS_H__
  15 #define __COLLATIONSETTINGS_H__
  16
  17 #include "unicode/utypes.h"
  18
  19 #if !UCONFIG_NO_COLLATION
  20
  21 #include "unicode/ucol.h"
  22 #include "collation.h"
  23 #include "sharedobject.h"
  24 #include "umutex.h"
  25
  26 U_NAMESPACE_BEGIN
  27
  28 struct CollationData;
  29
  30 /**
  31  * Collation settings/options/attributes.
  32  * These are the values that can be changed via API.
  33  */
  34 struct U_I18N_API CollationSettings : public SharedObject {
  35     /**
  36      * Options bit 0: Perform the FCD check on the input text and deliver normalized text.
  37      */
  38     static const int32_t CHECK_FCD = 1;
  39     /**
  40      * Options bit 1: Numeric collation.
  41      * Also known as CODAN = COllate Digits As Numbers.
  42      *
  43      * Treat digit sequences as numbers with CE sequences in numeric order,
  44      * rather than returning a normal CE for each digit.
  45      */
  46     static const int32_t NUMERIC = 2;
  47     /**
  48      * "Shifted" alternate handling, see ALTERNATE_MASK.
  49      */
  50     static const int32_t SHIFTED = 4;
  51     /**
  52      * Options bits 3..2: Alternate-handling mask. 0 for non-ignorable.
  53      * Reserve values 8 and 0xc for shift-trimmed and blanked.
  54      */
  55     static const int32_t ALTERNATE_MASK = 0xc;
  56     /**
  57      * Options bits 6..4: The 3-bit maxVariable value bit field is shifted by this value.
  58      */
  59     static const int32_t MAX_VARIABLE_SHIFT = 4;
  60     /** maxVariable options bit mask before shifting. */
  61     static const int32_t MAX_VARIABLE_MASK = 0x70;
  62     /** Options bit 7: Reserved/unused/0. */
  63     /**
  64      * Options bit 8: Sort uppercase first if caseLevel or caseFirst is on.
  65      */
  66     static const int32_t UPPER_FIRST = 0x100;
  67     /**
  68      * Options bit 9: Keep the case bits in the tertiary weight (they trump other tertiary values)
  69      * unless case level is on (when they are *moved* into the separate case level).
  70      * By default, the case bits are removed from the tertiary weight (ignored).
  71      *
  72      * When CASE_FIRST is off, UPPER_FIRST must be off too, corresponding to
  73      * the tri-value UCOL_CASE_FIRST attribute: UCOL_OFF vs. UCOL_LOWER_FIRST vs. UCOL_UPPER_FIRST.
  74      */
  75     static const int32_t CASE_FIRST = 0x200;
  76     /**
  77      * Options bit mask for caseFirst and upperFirst, before shifting.
  78      * Same value as caseFirst==upperFirst.
  79      */
  80     static const int32_t CASE_FIRST_AND_UPPER_MASK = CASE_FIRST | UPPER_FIRST;
  81     /**
  82      * Options bit 10: Insert the case level between the secondary and tertiary levels.
  83      */
  84     static const int32_t CASE_LEVEL = 0x400;
  85     /**
  86      * Options bit 11: Compare secondary weights backwards. ("French secondary")
  87      */
  88     static const int32_t BACKWARD_SECONDARY = 0x800;
  89     /**
  90      * Options bits 15..12: The 4-bit strength value bit field is shifted by this value.
  91      * It is the top used bit field in the options. (No need to mask after shifting.)
  92      */
  93     static const int32_t STRENGTH_SHIFT = 12;
  94     /** Strength options bit mask before shifting. */
  95     static const int32_t STRENGTH_MASK = 0xf000;
  96
  97     /** maxVariable values */
  98     enum MaxVariable {
  99         MAX_VAR_SPACE,
 100         MAX_VAR_PUNCT,
 101         MAX_VAR_SYMBOL,
 102         MAX_VAR_CURRENCY
 103     };
 104
 105     CollationSettings()
 106             : options((UCOL_DEFAULT_STRENGTH << STRENGTH_SHIFT) |
 107                       (MAX_VAR_PUNCT << MAX_VARIABLE_SHIFT)),
 108               variableTop(0),
 109               reorderTable(NULL),
 110               minHighNoReorder(0),
 111               reorderRanges(NULL), reorderRangesLength(0),
 112               reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0),
 113               fastLatinOptions(-1) {}
 114
 115     CollationSettings(const CollationSettings &other);
 116     virtual ~CollationSettings();
 117
 118     UBool operator==(const CollationSettings &other) const;
 119
 120     inline UBool operator!=(const CollationSettings &other) const {
 121         return !operator==(other);
 122     }
 123
 124     int32_t hashCode() const;
 125
 126     void resetReordering();
 127     void aliasReordering(const CollationData &data, const int32_t *codes, int32_t length,
 128                          const uint32_t *ranges, int32_t rangesLength,
 129                          const uint8_t *table, UErrorCode &errorCode);
 130     void setReordering(const CollationData &data, const int32_t *codes, int32_t codesLength,
 131                        UErrorCode &errorCode);
 132     void copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode);
 133
 134     inline UBool hasReordering() const { return reorderTable != NULL; }
 135     static UBool reorderTableHasSplitBytes(const uint8_t table[256]);
 136     inline uint32_t reorder(uint32_t p) const {
 137         uint8_t b = reorderTable[p >> 24];
 138         if(b != 0 || p <= Collation::NO_CE_PRIMARY) {
 139             return ((uint32_t)b << 24) | (p & 0xffffff);
 140         } else {
 141             return reorderEx(p);
 142         }
 143     }
 144
 145     void setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode);
 146
 147     static int32_t getStrength(int32_t options) {
 148         return options >> STRENGTH_SHIFT;
 149     }
 150
 151     int32_t getStrength() const {
 152         return getStrength(options);
 153     }
 154
 155     /** Sets the options bit for an on/off attribute. */
 156     void setFlag(int32_t bit, UColAttributeValue value,
 157                  int32_t defaultOptions, UErrorCode &errorCode);
 158
 159     UColAttributeValue getFlag(int32_t bit) const {
 160         return ((options & bit) != 0) ? UCOL_ON : UCOL_OFF;
 161     }
 162
 163     void setCaseFirst(UColAttributeValue value, int32_t defaultOptions, UErrorCode &errorCode);
 164
 165     UColAttributeValue getCaseFirst() const {
 166         int32_t option = options & CASE_FIRST_AND_UPPER_MASK;
 167         return (option == 0) ? UCOL_OFF :
 168                 (option == CASE_FIRST) ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST;
 169     }
 170
 171     void setAlternateHandling(UColAttributeValue value,
 172                               int32_t defaultOptions, UErrorCode &errorCode);
 173
 174     UColAttributeValue getAlternateHandling() const {
 175         return ((options & ALTERNATE_MASK) == 0) ? UCOL_NON_IGNORABLE : UCOL_SHIFTED;
 176     }
 177
 178     void setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode);
 179
 180     MaxVariable getMaxVariable() const {
 181         return (MaxVariable)((options & MAX_VARIABLE_MASK) >> MAX_VARIABLE_SHIFT);
 182     }
 183
 184     /**
 185      * Include case bits in the tertiary level if caseLevel=off and caseFirst!=off.
 186      */
 187     static inline UBool isTertiaryWithCaseBits(int32_t options) {
 188         return (options & (CASE_LEVEL | CASE_FIRST)) == CASE_FIRST;
 189     }
 190     static uint32_t getTertiaryMask(int32_t options) {
 191         // Remove the case bits from the tertiary weight when caseLevel is on or caseFirst is off.
 192         return isTertiaryWithCaseBits(options) ?
 193                 Collation::CASE_AND_TERTIARY_MASK : Collation::ONLY_TERTIARY_MASK;
 194     }
 195
 196     static UBool sortsTertiaryUpperCaseFirst(int32_t options) {
 197         // On tertiary level, consider case bits and sort uppercase first
 198         // if caseLevel is off and caseFirst==upperFirst.
 199         return (options & (CASE_LEVEL | CASE_FIRST_AND_UPPER_MASK)) == CASE_FIRST_AND_UPPER_MASK;
 200     }
 201
 202     inline UBool dontCheckFCD() const {
 203         return (options & CHECK_FCD) == 0;
 204     }
 205
 206     inline UBool hasBackwardSecondary() const {
 207         return (options & BACKWARD_SECONDARY) != 0;
 208     }
 209
 210     inline UBool isNumeric() const {
 211         return (options & NUMERIC) != 0;
 212     }
 213
 214     /** CHECK_FCD etc. */
 215     int32_t options;
 216     /** Variable-top primary weight. */
 217     uint32_t variableTop;
 218     /**
 219      * 256-byte table for reordering permutation of primary lead bytes; NULL if no reordering.
 220      * A 0 entry at a non-zero index means that the primary lead byte is "split"
 221      * (there are different offsets for primaries that share that lead byte)
 222      * and the reordering offset must be determined via the reorderRanges.
 223      */
 224     const uint8_t *reorderTable;
 225     /** Limit of last reordered range. 0 if no reordering or no split bytes. */
 226     uint32_t minHighNoReorder;
 227     /**
 228      * Primary-weight ranges for script reordering,
 229      * to be used by reorder(p) for split-reordered primary lead bytes.
 230      *
 231      * Each entry is a (limit, offset) pair.
 232      * The upper 16 bits of the entry are the upper 16 bits of the
 233      * exclusive primary limit of a range.
 234      * Primaries between the previous limit and this one have their lead bytes
 235      * modified by the signed offset (-0xff..+0xff) stored in the lower 16 bits.
 236      *
 237      * CollationData::makeReorderRanges() writes a full list where the first range
 238      * (at least for terminators and separators) has a 0 offset.
 239      * The last range has a non-zero offset.
 240      * minHighNoReorder is set to the limit of that last range.
 241      *
 242      * In the settings object, the initial ranges before the first split lead byte
 243      * are omitted for efficiency; they are handled by reorder(p) via the reorderTable.
 244      * If there are no split-reordered lead bytes, then no ranges are needed.
 245      */
 246     const uint32_t *reorderRanges;
 247     int32_t reorderRangesLength;
 248     /** Array of reorder codes; ignored if reorderCodesLength == 0. */
 249     const int32_t *reorderCodes;
 250     /** Number of reorder codes; 0 if no reordering. */
 251     int32_t reorderCodesLength;
 252     /**
 253      * Capacity of reorderCodes.
 254      * If 0, then the codes, the ranges, and the table are aliases.
 255      * Otherwise, this object owns the memory via the reorderCodes pointer;
 256      * the codes, the ranges, and the table are in the same memory block, in that order.
 257      */
 258     int32_t reorderCodesCapacity;
 259
 260     /** Options for CollationFastLatin. Negative if disabled. */
 261     int32_t fastLatinOptions;
 262     uint16_t fastLatinPrimaries[0x180];
 263
 264 private:
 265     void setReorderArrays(const int32_t *codes, int32_t codesLength,
 266                           const uint32_t *ranges, int32_t rangesLength,
 267                           const uint8_t *table, UErrorCode &errorCode);
 268     uint32_t reorderEx(uint32_t p) const;
 269 };
 270
 271 U_NAMESPACE_END
 272
 273 #endif  // !UCONFIG_NO_COLLATION
 274 #endif  // __COLLATIONSETTINGS_H__