[apple/icu.git] / icuSources / i18n / collationsettings.cpp

// © 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.cpp
*
* created on: 2013feb07
* created by: Markus W. Scherer
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION

#include "unicode/ucol.h"
#include "cmemory.h"
#include "collation.h"
#include "collationdata.h"
#include "collationsettings.h"
#include "sharedobject.h"
#include "uassert.h"
#include "umutex.h"
#include "uvectr32.h"

U_NAMESPACE_BEGIN

CollationSettings::CollationSettings(const CollationSettings &other)
        : SharedObject(other),
          options(other.options), variableTop(other.variableTop),
          reorderTable(NULL),
          minHighNoReorder(other.minHighNoReorder),
          reorderRanges(NULL), reorderRangesLength(0),
          reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0),
          fastLatinOptions(other.fastLatinOptions) {
    UErrorCode errorCode = U_ZERO_ERROR;
    copyReorderingFrom(other, errorCode);
    if(fastLatinOptions >= 0) {
        uprv_memcpy(fastLatinPrimaries, other.fastLatinPrimaries, sizeof(fastLatinPrimaries));
    }
}

CollationSettings::~CollationSettings() {
    if(reorderCodesCapacity != 0) {
        uprv_free(const_cast<int32_t *>(reorderCodes));
    }
}

UBool
CollationSettings::operator==(const CollationSettings &other) const {
    if(options != other.options) { return FALSE; }
    if((options & ALTERNATE_MASK) != 0 && variableTop != other.variableTop) { return FALSE; }
    if(reorderCodesLength != other.reorderCodesLength) { return FALSE; }
    for(int32_t i = 0; i < reorderCodesLength; ++i) {
        if(reorderCodes[i] != other.reorderCodes[i]) { return FALSE; }
    }
    return TRUE;
}

int32_t
CollationSettings::hashCode() const {
    int32_t h = options << 8;
    if((options & ALTERNATE_MASK) != 0) { h ^= variableTop; }
    h ^= reorderCodesLength;
    for(int32_t i = 0; i < reorderCodesLength; ++i) {
        h ^= (reorderCodes[i] << i);
    }
    return h;
}

void
CollationSettings::resetReordering() {
    // When we turn off reordering, we want to set a NULL permutation
    // rather than a no-op permutation.
    // Keep the memory via reorderCodes and its capacity.
    reorderTable = NULL;
    minHighNoReorder = 0;
    reorderRangesLength = 0;
    reorderCodesLength = 0;
}

void
CollationSettings::aliasReordering(const CollationData &data, const int32_t *codes, int32_t length,
                                   const uint32_t *ranges, int32_t rangesLength,
                                   const uint8_t *table, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    if(table != NULL &&
            (rangesLength == 0 ?
                    !reorderTableHasSplitBytes(table) :
                    rangesLength >= 2 &&
                    // The first offset must be 0. The last offset must not be 0.
                    (ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0)) {
        // We need to release the memory before setting the alias pointer.
        if(reorderCodesCapacity != 0) {
            uprv_free(const_cast<int32_t *>(reorderCodes));
            reorderCodesCapacity = 0;
        }
        reorderTable = table;
        reorderCodes = codes;
        reorderCodesLength = length;
        // Drop ranges before the first split byte. They are reordered by the table.
        // This then speeds up reordering of the remaining ranges.
        int32_t firstSplitByteRangeIndex = 0;
        while(firstSplitByteRangeIndex < rangesLength &&
                (ranges[firstSplitByteRangeIndex] & 0xff0000) == 0) {
            // The second byte of the primary limit is 0.
            ++firstSplitByteRangeIndex;
        }
        if(firstSplitByteRangeIndex == rangesLength) {
            U_ASSERT(!reorderTableHasSplitBytes(table));
            minHighNoReorder = 0;
            reorderRanges = NULL;
            reorderRangesLength = 0;
        } else {
            U_ASSERT(table[ranges[firstSplitByteRangeIndex] >> 24] == 0);
            minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;
            reorderRanges = ranges + firstSplitByteRangeIndex;
            reorderRangesLength = rangesLength - firstSplitByteRangeIndex;
        }
        return;
    }
    // Regenerate missing data.
    setReordering(data, codes, length, errorCode);
}

void
CollationSettings::setReordering(const CollationData &data,
                                 const int32_t *codes, int32_t codesLength,
                                 UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    if(codesLength == 0 || (codesLength == 1 && codes[0] == UCOL_REORDER_CODE_NONE)) {
        resetReordering();
        return;
    }
    UVector32 rangesList(errorCode);
    data.makeReorderRanges(codes, codesLength, rangesList, errorCode);
    if(U_FAILURE(errorCode)) { return; }
    int32_t rangesLength = rangesList.size();
    if(rangesLength == 0) {
        resetReordering();
        return;
    }
    const uint32_t *ranges = reinterpret_cast<uint32_t *>(rangesList.getBuffer());
    // ranges[] contains at least two (limit, offset) pairs.
    // The first offset must be 0. The last offset must not be 0.
    // Separators (at the low end) and trailing weights (at the high end)
    // are never reordered.
    U_ASSERT(rangesLength >= 2);
    U_ASSERT((ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0);
    minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;

    // Write the lead byte permutation table.
    // Set a 0 for each lead byte that has a range boundary in the middle.
    uint8_t table[256];
    int32_t b = 0;
    int32_t firstSplitByteRangeIndex = -1;
    for(int32_t i = 0; i < rangesLength; ++i) {
        uint32_t pair = ranges[i];
        int32_t limit1 = (int32_t)(pair >> 24);
        while(b < limit1) {
            table[b] = (uint8_t)(b + pair);
            ++b;
        }
        // Check the second byte of the limit.
        if((pair & 0xff0000) != 0) {
            table[limit1] = 0;
            b = limit1 + 1;
            if(firstSplitByteRangeIndex < 0) {
                firstSplitByteRangeIndex = i;
            }
        }
    }
    while(b <= 0xff) {
        table[b] = (uint8_t)b;
        ++b;
    }
    if(firstSplitByteRangeIndex < 0) {
        // The lead byte permutation table alone suffices for reordering.
        rangesLength = 0;
    } else {
        // Remove the ranges below the first split byte.
        ranges += firstSplitByteRangeIndex;
        rangesLength -= firstSplitByteRangeIndex;
    }
    setReorderArrays(codes, codesLength, ranges, rangesLength, table, errorCode);
}

void
CollationSettings::setReorderArrays(const int32_t *codes, int32_t codesLength,
                                    const uint32_t *ranges, int32_t rangesLength,
                                    const uint8_t *table, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    int32_t *ownedCodes;
    int32_t totalLength = codesLength + rangesLength;
    U_ASSERT(totalLength > 0);
    if(totalLength <= reorderCodesCapacity) {
        ownedCodes = const_cast<int32_t *>(reorderCodes);
    } else {
        // Allocate one memory block for the codes, the ranges, and the 16-aligned table.
        int32_t capacity = (totalLength + 3) & ~3;  // round up to a multiple of 4 ints
        ownedCodes = (int32_t *)uprv_malloc(capacity * 4 + 256);
        if(ownedCodes == NULL) {
            resetReordering();
            errorCode = U_MEMORY_ALLOCATION_ERROR;
            return;
        }
        if(reorderCodesCapacity != 0) {
            uprv_free(const_cast<int32_t *>(reorderCodes));
        }
        reorderCodes = ownedCodes;
        reorderCodesCapacity = capacity;
    }
    uprv_memcpy(ownedCodes + reorderCodesCapacity, table, 256);
    uprv_memcpy(ownedCodes, codes, codesLength * 4);
    uprv_memcpy(ownedCodes + codesLength, ranges, rangesLength * 4);
    reorderTable = reinterpret_cast<const uint8_t *>(reorderCodes + reorderCodesCapacity);
    reorderCodesLength = codesLength;
    reorderRanges = reinterpret_cast<uint32_t *>(ownedCodes) + codesLength;
    reorderRangesLength = rangesLength;
}

void
CollationSettings::copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    if(!other.hasReordering()) {
        resetReordering();
        return;
    }
    minHighNoReorder = other.minHighNoReorder;
    if(other.reorderCodesCapacity == 0) {
        // The reorder arrays are aliased to memory-mapped data.
        reorderTable = other.reorderTable;
        reorderRanges = other.reorderRanges;
        reorderRangesLength = other.reorderRangesLength;
        reorderCodes = other.reorderCodes;
        reorderCodesLength = other.reorderCodesLength;
    } else {
        setReorderArrays(other.reorderCodes, other.reorderCodesLength,
                         other.reorderRanges, other.reorderRangesLength,
                         other.reorderTable, errorCode);
    }
}

UBool
CollationSettings::reorderTableHasSplitBytes(const uint8_t table[256]) {
    U_ASSERT(table[0] == 0);
    for(int32_t i = 1; i < 256; ++i) {
        if(table[i] == 0) {
            return TRUE;
        }
    }
    return FALSE;
}

uint32_t
CollationSettings::reorderEx(uint32_t p) const {
    if(p >= minHighNoReorder) { return p; }
    // Round up p so that its lower 16 bits are >= any offset bits.
    // Then compare q directly with (limit, offset) pairs.
    uint32_t q = p | 0xffff;
    uint32_t r;
    const uint32_t *ranges = reorderRanges;
    while(q >= (r = *ranges)) { ++ranges; }
    return p + (r << 24);
}

void
CollationSettings::setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    int32_t noStrength = options & ~STRENGTH_MASK;
    switch(value) {
    case UCOL_PRIMARY:
    case UCOL_SECONDARY:
    case UCOL_TERTIARY:
    case UCOL_QUATERNARY:
    case UCOL_IDENTICAL:
        options = noStrength | (value << STRENGTH_SHIFT);
        break;
    case UCOL_DEFAULT:
        options = noStrength | (defaultOptions & STRENGTH_MASK);
        break;
    default:
        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        break;
    }
}

void
CollationSettings::setFlag(int32_t bit, UColAttributeValue value,
                           int32_t defaultOptions, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    switch(value) {
    case UCOL_ON:
        options |= bit;
        break;
    case UCOL_OFF:
        options &= ~bit;
        break;
    case UCOL_DEFAULT:
        options = (options & ~bit) | (defaultOptions & bit);
        break;
    default:
        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        break;
    }
}

void
CollationSettings::setCaseFirst(UColAttributeValue value,
                                int32_t defaultOptions, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    int32_t noCaseFirst = options & ~CASE_FIRST_AND_UPPER_MASK;
    switch(value) {
    case UCOL_OFF:
        options = noCaseFirst;
        break;
    case UCOL_LOWER_FIRST:
        options = noCaseFirst | CASE_FIRST;
        break;
    case UCOL_UPPER_FIRST:
        options = noCaseFirst | CASE_FIRST_AND_UPPER_MASK;
        break;
    case UCOL_DEFAULT:
        options = noCaseFirst | (defaultOptions & CASE_FIRST_AND_UPPER_MASK);
        break;
    default:
        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        break;
    }
}

void
CollationSettings::setAlternateHandling(UColAttributeValue value,
                                        int32_t defaultOptions, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    int32_t noAlternate = options & ~ALTERNATE_MASK;
    switch(value) {
    case UCOL_NON_IGNORABLE:
        options = noAlternate;
        break;
    case UCOL_SHIFTED:
        options = noAlternate | SHIFTED;
        break;
    case UCOL_DEFAULT:
        options = noAlternate | (defaultOptions & ALTERNATE_MASK);
        break;
    default:
        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        break;
    }
}

void
CollationSettings::setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return; }
    int32_t noMax = options & ~MAX_VARIABLE_MASK;
    switch(value) {
    case MAX_VAR_SPACE:
    case MAX_VAR_PUNCT:
    case MAX_VAR_SYMBOL:
    case MAX_VAR_CURRENCY:
        options = noMax | (value << MAX_VARIABLE_SHIFT);
        break;
    case UCOL_DEFAULT:
        options = noMax | (defaultOptions & MAX_VARIABLE_MASK);
        break;
    default:
        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        break;
    }
}

U_NAMESPACE_END

#endif  // !UCONFIG_NO_COLLATION
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
57a6839d A	3	/*
57a6839d A	4	*******************************************************************************
b331163b	5	* Copyright (C) 2013-2015, International Business Machines
57a6839d A	6	* Corporation and others. All Rights Reserved.
	7	*******************************************************************************
	8	* collationsettings.cpp
	9	*
	10	* created on: 2013feb07
	11	* created by: Markus W. Scherer
	12	*/
	13
	14	#include "unicode/utypes.h"
	15
	16	#if !UCONFIG_NO_COLLATION
	17
	18	#include "unicode/ucol.h"
	19	#include "cmemory.h"
	20	#include "collation.h"
b331163b	21	#include "collationdata.h"
57a6839d A	22	#include "collationsettings.h"
	23	#include "sharedobject.h"
	24	#include "uassert.h"
	25	#include "umutex.h"
b331163b	26	#include "uvectr32.h"
57a6839d A	27
	28	U_NAMESPACE_BEGIN
	29
	30	CollationSettings::CollationSettings(const CollationSettings &other)
	31	: SharedObject(other),
	32	options(other.options), variableTop(other.variableTop),
	33	reorderTable(NULL),
b331163b A	34	minHighNoReorder(other.minHighNoReorder),
b331163b A	35	reorderRanges(NULL), reorderRangesLength(0),
57a6839d A	36	reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0),
57a6839d A	37	fastLatinOptions(other.fastLatinOptions) {
b331163b A	38	UErrorCode errorCode = U_ZERO_ERROR;
b331163b A	39	copyReorderingFrom(other, errorCode);
57a6839d A	40	if(fastLatinOptions >= 0) {
	41	uprv_memcpy(fastLatinPrimaries, other.fastLatinPrimaries, sizeof(fastLatinPrimaries));
	42	}
	43	}
	44
	45	CollationSettings::~CollationSettings() {
	46	if(reorderCodesCapacity != 0) {
	47	uprv_free(const_cast<int32_t *>(reorderCodes));
	48	}
	49	}
	50
	51	UBool
	52	CollationSettings::operator==(const CollationSettings &other) const {
	53	if(options != other.options) { return FALSE; }
	54	if((options & ALTERNATE_MASK) != 0 && variableTop != other.variableTop) { return FALSE; }
	55	if(reorderCodesLength != other.reorderCodesLength) { return FALSE; }
	56	for(int32_t i = 0; i < reorderCodesLength; ++i) {
	57	if(reorderCodes[i] != other.reorderCodes[i]) { return FALSE; }
	58	}
	59	return TRUE;
	60	}
	61
	62	int32_t
	63	CollationSettings::hashCode() const {
	64	int32_t h = options << 8;
	65	if((options & ALTERNATE_MASK) != 0) { h ^= variableTop; }
	66	h ^= reorderCodesLength;
	67	for(int32_t i = 0; i < reorderCodesLength; ++i) {
	68	h ^= (reorderCodes[i] << i);
	69	}
	70	return h;
	71	}
	72
	73	void
	74	CollationSettings::resetReordering() {
	75	// When we turn off reordering, we want to set a NULL permutation
	76	// rather than a no-op permutation.
	77	// Keep the memory via reorderCodes and its capacity.
	78	reorderTable = NULL;
b331163b A	79	minHighNoReorder = 0;
b331163b A	80	reorderRangesLength = 0;
57a6839d A	81	reorderCodesLength = 0;
	82	}
	83
	84	void
b331163b A	85	CollationSettings::aliasReordering(const CollationData &data, const int32_t *codes, int32_t length,
	86	const uint32_t *ranges, int32_t rangesLength,
	87	const uint8_t *table, UErrorCode &errorCode) {
	88	if(U_FAILURE(errorCode)) { return; }
	89	if(table != NULL &&
	90	(rangesLength == 0 ?
	91	!reorderTableHasSplitBytes(table) :
	92	rangesLength >= 2 &&
	93	// The first offset must be 0. The last offset must not be 0.
	94	(ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0)) {
57a6839d A	95	// We need to release the memory before setting the alias pointer.
	96	if(reorderCodesCapacity != 0) {
	97	uprv_free(const_cast<int32_t *>(reorderCodes));
	98	reorderCodesCapacity = 0;
	99	}
	100	reorderTable = table;
	101	reorderCodes = codes;
	102	reorderCodesLength = length;
b331163b A	103	// Drop ranges before the first split byte. They are reordered by the table.
	104	// This then speeds up reordering of the remaining ranges.
	105	int32_t firstSplitByteRangeIndex = 0;
	106	while(firstSplitByteRangeIndex < rangesLength &&
	107	(ranges[firstSplitByteRangeIndex] & 0xff0000) == 0) {
	108	// The second byte of the primary limit is 0.
	109	++firstSplitByteRangeIndex;
	110	}
	111	if(firstSplitByteRangeIndex == rangesLength) {
	112	U_ASSERT(!reorderTableHasSplitBytes(table));
	113	minHighNoReorder = 0;
	114	reorderRanges = NULL;
	115	reorderRangesLength = 0;
	116	} else {
	117	U_ASSERT(table[ranges[firstSplitByteRangeIndex] >> 24] == 0);
	118	minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;
	119	reorderRanges = ranges + firstSplitByteRangeIndex;
	120	reorderRangesLength = rangesLength - firstSplitByteRangeIndex;
	121	}
	122	return;
57a6839d	123	}
b331163b A	124	// Regenerate missing data.
b331163b A	125	setReordering(data, codes, length, errorCode);
57a6839d A	126	}
57a6839d A	127
b331163b A	128	void
	129	CollationSettings::setReordering(const CollationData &data,
	130	const int32_t *codes, int32_t codesLength,
	131	UErrorCode &errorCode) {
	132	if(U_FAILURE(errorCode)) { return; }
	133	if(codesLength == 0 \|\| (codesLength == 1 && codes[0] == UCOL_REORDER_CODE_NONE)) {
57a6839d	134	resetReordering();
b331163b A	135	return;
	136	}
	137	UVector32 rangesList(errorCode);
	138	data.makeReorderRanges(codes, codesLength, rangesList, errorCode);
	139	if(U_FAILURE(errorCode)) { return; }
	140	int32_t rangesLength = rangesList.size();
	141	if(rangesLength == 0) {
	142	resetReordering();
	143	return;
	144	}
	145	const uint32_t ranges = reinterpret_cast<uint32_t >(rangesList.getBuffer());
	146	// ranges[] contains at least two (limit, offset) pairs.
	147	// The first offset must be 0. The last offset must not be 0.
	148	// Separators (at the low end) and trailing weights (at the high end)
	149	// are never reordered.
	150	U_ASSERT(rangesLength >= 2);
	151	U_ASSERT((ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0);
	152	minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;
	153
	154	// Write the lead byte permutation table.
	155	// Set a 0 for each lead byte that has a range boundary in the middle.
	156	uint8_t table[256];
	157	int32_t b = 0;
	158	int32_t firstSplitByteRangeIndex = -1;
	159	for(int32_t i = 0; i < rangesLength; ++i) {
	160	uint32_t pair = ranges[i];
	161	int32_t limit1 = (int32_t)(pair >> 24);
	162	while(b < limit1) {
	163	table[b] = (uint8_t)(b + pair);
	164	++b;
	165	}
	166	// Check the second byte of the limit.
	167	if((pair & 0xff0000) != 0) {
	168	table[limit1] = 0;
	169	b = limit1 + 1;
	170	if(firstSplitByteRangeIndex < 0) {
	171	firstSplitByteRangeIndex = i;
57a6839d	172	}
57a6839d	173	}
57a6839d	174	}
b331163b A	175	while(b <= 0xff) {
	176	table[b] = (uint8_t)b;
	177	++b;
	178	}
	179	if(firstSplitByteRangeIndex < 0) {
	180	// The lead byte permutation table alone suffices for reordering.
	181	rangesLength = 0;
	182	} else {
	183	// Remove the ranges below the first split byte.
	184	ranges += firstSplitByteRangeIndex;
	185	rangesLength -= firstSplitByteRangeIndex;
	186	}
	187	setReorderArrays(codes, codesLength, ranges, rangesLength, table, errorCode);
	188	}
	189
	190	void
	191	CollationSettings::setReorderArrays(const int32_t *codes, int32_t codesLength,
	192	const uint32_t *ranges, int32_t rangesLength,
	193	const uint8_t *table, UErrorCode &errorCode) {
	194	if(U_FAILURE(errorCode)) { return; }
	195	int32_t *ownedCodes;
	196	int32_t totalLength = codesLength + rangesLength;
	197	U_ASSERT(totalLength > 0);
	198	if(totalLength <= reorderCodesCapacity) {
	199	ownedCodes = const_cast<int32_t *>(reorderCodes);
	200	} else {
	201	// Allocate one memory block for the codes, the ranges, and the 16-aligned table.
	202	int32_t capacity = (totalLength + 3) & ~3; // round up to a multiple of 4 ints
	203	ownedCodes = (int32_t )uprv_malloc(capacity 4 + 256);
	204	if(ownedCodes == NULL) {
	205	resetReordering();
	206	errorCode = U_MEMORY_ALLOCATION_ERROR;
	207	return;
	208	}
	209	if(reorderCodesCapacity != 0) {
	210	uprv_free(const_cast<int32_t *>(reorderCodes));
	211	}
	212	reorderCodes = ownedCodes;
	213	reorderCodesCapacity = capacity;
	214	}
	215	uprv_memcpy(ownedCodes + reorderCodesCapacity, table, 256);
	216	uprv_memcpy(ownedCodes, codes, codesLength * 4);
	217	uprv_memcpy(ownedCodes + codesLength, ranges, rangesLength * 4);
	218	reorderTable = reinterpret_cast<const uint8_t *>(reorderCodes + reorderCodesCapacity);
	219	reorderCodesLength = codesLength;
	220	reorderRanges = reinterpret_cast<uint32_t *>(ownedCodes) + codesLength;
	221	reorderRangesLength = rangesLength;
	222	}
	223
	224	void
	225	CollationSettings::copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode) {
	226	if(U_FAILURE(errorCode)) { return; }
	227	if(!other.hasReordering()) {
	228	resetReordering();
	229	return;
	230	}
	231	minHighNoReorder = other.minHighNoReorder;
	232	if(other.reorderCodesCapacity == 0) {
	233	// The reorder arrays are aliased to memory-mapped data.
	234	reorderTable = other.reorderTable;
	235	reorderRanges = other.reorderRanges;
	236	reorderRangesLength = other.reorderRangesLength;
	237	reorderCodes = other.reorderCodes;
	238	reorderCodesLength = other.reorderCodesLength;
239	} else {
240	setReorderArrays(other.reorderCodes, other.reorderCodesLength,
241	other.reorderRanges, other.reorderRangesLength,
242	other.reorderTable, errorCode);
243	}
244	}
245
246	UBool
247	CollationSettings::reorderTableHasSplitBytes(const uint8_t table[256]) {
248	U_ASSERT(table[0] == 0);
249	for(int32_t i = 1; i < 256; ++i) {
250	if(table[i] == 0) {
251	return TRUE;
252	}
253	}
254	return FALSE;
255	}
256
257	uint32_t
258	CollationSettings::reorderEx(uint32_t p) const {
259	if(p >= minHighNoReorder) { return p; }
260	// Round up p so that its lower 16 bits are >= any offset bits.
261	// Then compare q directly with (limit, offset) pairs.
262	uint32_t q = p \| 0xffff;
263	uint32_t r;
264	const uint32_t *ranges = reorderRanges;
265	while(q >= (r = *ranges)) { ++ranges; }
266	return p + (r << 24);
57a6839d A	267	}
	268
	269	void
	270	CollationSettings::setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
	271	if(U_FAILURE(errorCode)) { return; }
	272	int32_t noStrength = options & ~STRENGTH_MASK;
	273	switch(value) {
	274	case UCOL_PRIMARY:
	275	case UCOL_SECONDARY:
	276	case UCOL_TERTIARY:
	277	case UCOL_QUATERNARY:
	278	case UCOL_IDENTICAL:
	279	options = noStrength \| (value << STRENGTH_SHIFT);
	280	break;
	281	case UCOL_DEFAULT:
	282	options = noStrength \| (defaultOptions & STRENGTH_MASK);
	283	break;
	284	default:
	285	errorCode = U_ILLEGAL_ARGUMENT_ERROR;
	286	break;
	287	}
	288	}
	289
	290	void
	291	CollationSettings::setFlag(int32_t bit, UColAttributeValue value,
	292	int32_t defaultOptions, UErrorCode &errorCode) {
	293	if(U_FAILURE(errorCode)) { return; }
	294	switch(value) {
	295	case UCOL_ON:
	296	options \|= bit;
	297	break;
	298	case UCOL_OFF:
	299	options &= ~bit;
	300	break;
	301	case UCOL_DEFAULT:
	302	options = (options & ~bit) \| (defaultOptions & bit);
	303	break;
	304	default:
	305	errorCode = U_ILLEGAL_ARGUMENT_ERROR;
	306	break;
	307	}
	308	}
	309
	310	void
	311	CollationSettings::setCaseFirst(UColAttributeValue value,
	312	int32_t defaultOptions, UErrorCode &errorCode) {
	313	if(U_FAILURE(errorCode)) { return; }
	314	int32_t noCaseFirst = options & ~CASE_FIRST_AND_UPPER_MASK;
	315	switch(value) {
	316	case UCOL_OFF:
	317	options = noCaseFirst;
	318	break;
	319	case UCOL_LOWER_FIRST:
	320	options = noCaseFirst \| CASE_FIRST;
	321	break;
	322	case UCOL_UPPER_FIRST:
	323	options = noCaseFirst \| CASE_FIRST_AND_UPPER_MASK;
	324	break;
	325	case UCOL_DEFAULT:
	326	options = noCaseFirst \| (defaultOptions & CASE_FIRST_AND_UPPER_MASK);
	327	break;
	328	default:
	329	errorCode = U_ILLEGAL_ARGUMENT_ERROR;
	330	break;
331	}
332	}
333
334	void
335	CollationSettings::setAlternateHandling(UColAttributeValue value,
336	int32_t defaultOptions, UErrorCode &errorCode) {
337	if(U_FAILURE(errorCode)) { return; }
338	int32_t noAlternate = options & ~ALTERNATE_MASK;
339	switch(value) {
340	case UCOL_NON_IGNORABLE:
341	options = noAlternate;
342	break;
343	case UCOL_SHIFTED:
344	options = noAlternate \| SHIFTED;
345	break;
346	case UCOL_DEFAULT:
347	options = noAlternate \| (defaultOptions & ALTERNATE_MASK);
348	break;
349	default:
350	errorCode = U_ILLEGAL_ARGUMENT_ERROR;
351	break;
352	}
353	}
354
355	void
356	CollationSettings::setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
357	if(U_FAILURE(errorCode)) { return; }
358	int32_t noMax = options & ~MAX_VARIABLE_MASK;
359	switch(value) {
360	case MAX_VAR_SPACE:
361	case MAX_VAR_PUNCT:
362	case MAX_VAR_SYMBOL:
363	case MAX_VAR_CURRENCY:
364	options = noMax \| (value << MAX_VARIABLE_SHIFT);
365	break;
366	case UCOL_DEFAULT:
367	options = noMax \| (defaultOptions & MAX_VARIABLE_MASK);
368	break;
369	default:
370	errorCode = U_ILLEGAL_ARGUMENT_ERROR;
371	break;
372	}
373	}
374
375	U_NAMESPACE_END
376
377	#endif // !UCONFIG_NO_COLLATION