// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

* Copyright (C) 2013-2015, International Business Machines

* Corporation and others.  All Rights Reserved.

*******************************************************************************

* collationsettings.h

*

* created on: 2013feb07

* created by: Markus W. Scherer

*/

#ifndef __COLLATIONSETTINGS_H__

#define __COLLATIONSETTINGS_H__

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION

#include "unicode/ucol.h"

#include "collation.h"

#include "sharedobject.h"

#include "umutex.h"

U_NAMESPACE_BEGIN

struct CollationData;

/**

 * Collation settings/options/attributes.

 * These are the values that can be changed via API.

 */

struct U_I18N_API CollationSettings : public SharedObject {

    /**

     * Options bit 0: Perform the FCD check on the input text and deliver normalized text.

     */

    static const int32_t CHECK_FCD = 1;

    /**

     * Options bit 1: Numeric collation.

     * Also known as CODAN = COllate Digits As Numbers.

     *

     * Treat digit sequences as numbers with CE sequences in numeric order,

     * rather than returning a normal CE for each digit.

     */

    static const int32_t NUMERIC = 2;

    /**

     * "Shifted" alternate handling, see ALTERNATE_MASK.

     */

    static const int32_t SHIFTED = 4;

    /**

     * Options bits 3..2: Alternate-handling mask. 0 for non-ignorable.

     * Reserve values 8 and 0xc for shift-trimmed and blanked.

     */

    static const int32_t ALTERNATE_MASK = 0xc;

    /**

     * Options bits 6..4: The 3-bit maxVariable value bit field is shifted by this value.

     */

    static const int32_t MAX_VARIABLE_SHIFT = 4;

    /** maxVariable options bit mask before shifting. */

    static const int32_t MAX_VARIABLE_MASK = 0x70;

    /** Options bit 7: Reserved/unused/0. */

    /**

     * Options bit 8: Sort uppercase first if caseLevel or caseFirst is on.

     */

    static const int32_t UPPER_FIRST = 0x100;

    /**

     * Options bit 9: Keep the case bits in the tertiary weight (they trump other tertiary values)

     * unless case level is on (when they are *moved* into the separate case level).

     * By default, the case bits are removed from the tertiary weight (ignored).

     *

     * When CASE_FIRST is off, UPPER_FIRST must be off too, corresponding to

     * the tri-value UCOL_CASE_FIRST attribute: UCOL_OFF vs. UCOL_LOWER_FIRST vs. UCOL_UPPER_FIRST.

     */

    static const int32_t CASE_FIRST = 0x200;

    /**

     * Options bit mask for caseFirst and upperFirst, before shifting.

     * Same value as caseFirst==upperFirst.

     */

    static const int32_t CASE_FIRST_AND_UPPER_MASK = CASE_FIRST | UPPER_FIRST;

    /**

     * Options bit 10: Insert the case level between the secondary and tertiary levels.

     */

    static const int32_t CASE_LEVEL = 0x400;

    /**

     * Options bit 11: Compare secondary weights backwards. ("French secondary")

     */

    static const int32_t BACKWARD_SECONDARY = 0x800;

    /**

     * Options bits 15..12: The 4-bit strength value bit field is shifted by this value.

     * It is the top used bit field in the options. (No need to mask after shifting.)

     */

    static const int32_t STRENGTH_SHIFT = 12;

    /** Strength options bit mask before shifting. */

    static const int32_t STRENGTH_MASK = 0xf000;

    /** maxVariable values */

    enum MaxVariable {

        MAX_VAR_SPACE,

        MAX_VAR_PUNCT,

        MAX_VAR_SYMBOL,

        MAX_VAR_CURRENCY

    };

    CollationSettings()

            : options((UCOL_DEFAULT_STRENGTH << STRENGTH_SHIFT) |

                      (MAX_VAR_PUNCT << MAX_VARIABLE_SHIFT)),

              variableTop(0),

              reorderTable(NULL),

              minHighNoReorder(0),

              reorderRanges(NULL), reorderRangesLength(0),

              reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0),

              fastLatinOptions(-1) {}

    CollationSettings(const CollationSettings &other);

    virtual ~CollationSettings();

    bool operator==(const CollationSettings &other) const;

    inline bool operator!=(const CollationSettings &other) const {

        return !operator==(other);

    }

    int32_t hashCode() const;

    void resetReordering();

    void aliasReordering(const CollationData &data, const int32_t *codes, int32_t length,

                         const uint32_t *ranges, int32_t rangesLength,

                         const uint8_t *table, UErrorCode &errorCode);

    void setReordering(const CollationData &data, const int32_t *codes, int32_t codesLength,

                       UErrorCode &errorCode);

    void copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode);

    inline UBool hasReordering() const { return reorderTable != NULL; }

    static UBool reorderTableHasSplitBytes(const uint8_t table[256]);

    inline uint32_t reorder(uint32_t p) const {

        uint8_t b = reorderTable[p >> 24];

        if(b != 0 || p <= Collation::NO_CE_PRIMARY) {

            return ((uint32_t)b << 24) | (p & 0xffffff);

        } else {

            return reorderEx(p);

        }

    }

    void setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode);

    static int32_t getStrength(int32_t options) {

        return options >> STRENGTH_SHIFT;

    }

    int32_t getStrength() const {

        return getStrength(options);

    }

    /** Sets the options bit for an on/off attribute. */

    void setFlag(int32_t bit, UColAttributeValue value,

                 int32_t defaultOptions, UErrorCode &errorCode);

    UColAttributeValue getFlag(int32_t bit) const {

        return ((options & bit) != 0) ? UCOL_ON : UCOL_OFF;

    }

    void setCaseFirst(UColAttributeValue value, int32_t defaultOptions, UErrorCode &errorCode);

    UColAttributeValue getCaseFirst() const {

        int32_t option = options & CASE_FIRST_AND_UPPER_MASK;

        return (option == 0) ? UCOL_OFF :

                (option == CASE_FIRST) ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST;

    }

    void setAlternateHandling(UColAttributeValue value,

                              int32_t defaultOptions, UErrorCode &errorCode);

    UColAttributeValue getAlternateHandling() const {

        return ((options & ALTERNATE_MASK) == 0) ? UCOL_NON_IGNORABLE : UCOL_SHIFTED;

    }

    void setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode);

    MaxVariable getMaxVariable() const {

        return (MaxVariable)((options & MAX_VARIABLE_MASK) >> MAX_VARIABLE_SHIFT);

    }

    /**

     * Include case bits in the tertiary level if caseLevel=off and caseFirst!=off.

     */

    static inline UBool isTertiaryWithCaseBits(int32_t options) {

        return (options & (CASE_LEVEL | CASE_FIRST)) == CASE_FIRST;

    }

    static uint32_t getTertiaryMask(int32_t options) {

        // Remove the case bits from the tertiary weight when caseLevel is on or caseFirst is off.

        return isTertiaryWithCaseBits(options) ?

                Collation::CASE_AND_TERTIARY_MASK : Collation::ONLY_TERTIARY_MASK;

    }

    static UBool sortsTertiaryUpperCaseFirst(int32_t options) {

        // On tertiary level, consider case bits and sort uppercase first

        // if caseLevel is off and caseFirst==upperFirst.

        return (options & (CASE_LEVEL | CASE_FIRST_AND_UPPER_MASK)) == CASE_FIRST_AND_UPPER_MASK;

    }

    inline UBool dontCheckFCD() const {

        return (options & CHECK_FCD) == 0;

    }

    inline UBool hasBackwardSecondary() const {

        return (options & BACKWARD_SECONDARY) != 0;

    }

    inline UBool isNumeric() const {

        return (options & NUMERIC) != 0;

    }

    /** CHECK_FCD etc. */

    int32_t options;

    /** Variable-top primary weight. */

    uint32_t variableTop;

    /**

     * 256-byte table for reordering permutation of primary lead bytes; NULL if no reordering.

     * A 0 entry at a non-zero index means that the primary lead byte is "split"

     * (there are different offsets for primaries that share that lead byte)

     * and the reordering offset must be determined via the reorderRanges.

     */

    const uint8_t *reorderTable;

    /** Limit of last reordered range. 0 if no reordering or no split bytes. */

    uint32_t minHighNoReorder;

    /**

     * Primary-weight ranges for script reordering,

     * to be used by reorder(p) for split-reordered primary lead bytes.

     *

     * Each entry is a (limit, offset) pair.

     * The upper 16 bits of the entry are the upper 16 bits of the

     * exclusive primary limit of a range.

     * Primaries between the previous limit and this one have their lead bytes

     * modified by the signed offset (-0xff..+0xff) stored in the lower 16 bits.

     *

     * CollationData::makeReorderRanges() writes a full list where the first range

     * (at least for terminators and separators) has a 0 offset.

     * The last range has a non-zero offset.

     * minHighNoReorder is set to the limit of that last range.

     *

     * In the settings object, the initial ranges before the first split lead byte

     * are omitted for efficiency; they are handled by reorder(p) via the reorderTable.

     * If there are no split-reordered lead bytes, then no ranges are needed.

     */

    const uint32_t *reorderRanges;

    int32_t reorderRangesLength;

    /** Array of reorder codes; ignored if reorderCodesLength == 0. */

    const int32_t *reorderCodes;

    /** Number of reorder codes; 0 if no reordering. */

    int32_t reorderCodesLength;

    /**

     * Capacity of reorderCodes.

     * If 0, then the codes, the ranges, and the table are aliases.

     * Otherwise, this object owns the memory via the reorderCodes pointer;

     * the codes, the ranges, and the table are in the same memory block, in that order.

     */

    int32_t reorderCodesCapacity;

    /** Options for CollationFastLatin. Negative if disabled. */

    int32_t fastLatinOptions;

    uint16_t fastLatinPrimaries[0x180];

private:

    void setReorderArrays(const int32_t *codes, int32_t codesLength,

                          const uint32_t *ranges, int32_t rangesLength,

                          const uint8_t *table, UErrorCode &errorCode);

    uint32_t reorderEx(uint32_t p) const;

};

U_NAMESPACE_END

#endif  // !UCONFIG_NO_COLLATION

#endif  // __COLLATIONSETTINGS_H__