255 lines
8.1 KiB
C++
255 lines
8.1 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2013-2014, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*******************************************************************************
|
|
* collationrootelements.h
|
|
*
|
|
* created on: 2013mar01
|
|
* created by: Markus W. Scherer
|
|
*/
|
|
|
|
#ifndef __COLLATIONROOTELEMENTS_H__
|
|
#define __COLLATIONROOTELEMENTS_H__
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_COLLATION
|
|
|
|
#include "unicode/uobject.h"
|
|
#include "collation.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
/**
|
|
* Container and access methods for collation elements and weights
|
|
* that occur in the root collator.
|
|
* Needed for finding boundaries for building a tailoring.
|
|
*
|
|
* This class takes and returns 16-bit secondary and tertiary weights.
|
|
*/
|
|
class U_I18N_API CollationRootElements : public UMemory {
|
|
public:
|
|
CollationRootElements(const uint32_t *rootElements, int32_t rootElementsLength)
|
|
: elements(rootElements), length(rootElementsLength) {}
|
|
|
|
/**
|
|
* Higher than any root primary.
|
|
*/
|
|
static const uint32_t PRIMARY_SENTINEL = 0xffffff00;
|
|
|
|
/**
|
|
* Flag in a root element, set if the element contains secondary & tertiary weights,
|
|
* rather than a primary.
|
|
*/
|
|
static const uint32_t SEC_TER_DELTA_FLAG = 0x80;
|
|
/**
|
|
* Mask for getting the primary range step value from a primary-range-end element.
|
|
*/
|
|
static const uint8_t PRIMARY_STEP_MASK = 0x7f;
|
|
|
|
enum {
|
|
/**
|
|
* Index of the first CE with a non-zero tertiary weight.
|
|
* Same as the start of the compact root elements table.
|
|
*/
|
|
IX_FIRST_TERTIARY_INDEX,
|
|
/**
|
|
* Index of the first CE with a non-zero secondary weight.
|
|
*/
|
|
IX_FIRST_SECONDARY_INDEX,
|
|
/**
|
|
* Index of the first CE with a non-zero primary weight.
|
|
*/
|
|
IX_FIRST_PRIMARY_INDEX,
|
|
/**
|
|
* Must match Collation::COMMON_SEC_AND_TER_CE.
|
|
*/
|
|
IX_COMMON_SEC_AND_TER_CE,
|
|
/**
|
|
* Secondary & tertiary boundaries.
|
|
* Bits 31..24: [fixed last secondary common byte 45]
|
|
* Bits 23..16: [fixed first ignorable secondary byte 80]
|
|
* Bits 15.. 8: reserved, 0
|
|
* Bits 7.. 0: [fixed first ignorable tertiary byte 3C]
|
|
*/
|
|
IX_SEC_TER_BOUNDARIES,
|
|
/**
|
|
* The current number of indexes.
|
|
* Currently the same as elements[IX_FIRST_TERTIARY_INDEX].
|
|
*/
|
|
IX_COUNT
|
|
};
|
|
|
|
/**
|
|
* Returns the boundary between tertiary weights of primary/secondary CEs
|
|
* and those of tertiary CEs.
|
|
* This is the upper limit for tertiaries of primary/secondary CEs.
|
|
* This minus one is the lower limit for tertiaries of tertiary CEs.
|
|
*/
|
|
uint32_t getTertiaryBoundary() const {
|
|
return (elements[IX_SEC_TER_BOUNDARIES] << 8) & 0xff00;
|
|
}
|
|
|
|
/**
|
|
* Returns the first assigned tertiary CE.
|
|
*/
|
|
uint32_t getFirstTertiaryCE() const {
|
|
return elements[elements[IX_FIRST_TERTIARY_INDEX]] & ~SEC_TER_DELTA_FLAG;
|
|
}
|
|
|
|
/**
|
|
* Returns the last assigned tertiary CE.
|
|
*/
|
|
uint32_t getLastTertiaryCE() const {
|
|
return elements[elements[IX_FIRST_SECONDARY_INDEX] - 1] & ~SEC_TER_DELTA_FLAG;
|
|
}
|
|
|
|
/**
|
|
* Returns the last common secondary weight.
|
|
* This is the lower limit for secondaries of primary CEs.
|
|
*/
|
|
uint32_t getLastCommonSecondary() const {
|
|
return (elements[IX_SEC_TER_BOUNDARIES] >> 16) & 0xff00;
|
|
}
|
|
|
|
/**
|
|
* Returns the boundary between secondary weights of primary CEs
|
|
* and those of secondary CEs.
|
|
* This is the upper limit for secondaries of primary CEs.
|
|
* This minus one is the lower limit for secondaries of secondary CEs.
|
|
*/
|
|
uint32_t getSecondaryBoundary() const {
|
|
return (elements[IX_SEC_TER_BOUNDARIES] >> 8) & 0xff00;
|
|
}
|
|
|
|
/**
|
|
* Returns the first assigned secondary CE.
|
|
*/
|
|
uint32_t getFirstSecondaryCE() const {
|
|
return elements[elements[IX_FIRST_SECONDARY_INDEX]] & ~SEC_TER_DELTA_FLAG;
|
|
}
|
|
|
|
/**
|
|
* Returns the last assigned secondary CE.
|
|
*/
|
|
uint32_t getLastSecondaryCE() const {
|
|
return elements[elements[IX_FIRST_PRIMARY_INDEX] - 1] & ~SEC_TER_DELTA_FLAG;
|
|
}
|
|
|
|
/**
|
|
* Returns the first assigned primary weight.
|
|
*/
|
|
uint32_t getFirstPrimary() const {
|
|
return elements[elements[IX_FIRST_PRIMARY_INDEX]]; // step=0: cannot be a range end
|
|
}
|
|
|
|
/**
|
|
* Returns the first assigned primary CE.
|
|
*/
|
|
int64_t getFirstPrimaryCE() const {
|
|
return Collation::makeCE(getFirstPrimary());
|
|
}
|
|
|
|
/**
|
|
* Returns the last root CE with a primary weight before p.
|
|
* Intended only for reordering group boundaries.
|
|
*/
|
|
int64_t lastCEWithPrimaryBefore(uint32_t p) const;
|
|
|
|
/**
|
|
* Returns the first root CE with a primary weight of at least p.
|
|
* Intended only for reordering group boundaries.
|
|
*/
|
|
int64_t firstCEWithPrimaryAtLeast(uint32_t p) const;
|
|
|
|
/**
|
|
* Returns the primary weight before p.
|
|
* p must be greater than the first root primary.
|
|
*/
|
|
uint32_t getPrimaryBefore(uint32_t p, UBool isCompressible) const;
|
|
|
|
/** Returns the secondary weight before [p, s]. */
|
|
uint32_t getSecondaryBefore(uint32_t p, uint32_t s) const;
|
|
|
|
/** Returns the tertiary weight before [p, s, t]. */
|
|
uint32_t getTertiaryBefore(uint32_t p, uint32_t s, uint32_t t) const;
|
|
|
|
/**
|
|
* Finds the index of the input primary.
|
|
* p must occur as a root primary, and must not be 0.
|
|
*/
|
|
int32_t findPrimary(uint32_t p) const;
|
|
|
|
/**
|
|
* Returns the primary weight after p where index=findPrimary(p).
|
|
* p must be at least the first root primary.
|
|
*/
|
|
uint32_t getPrimaryAfter(uint32_t p, int32_t index, UBool isCompressible) const;
|
|
/**
|
|
* Returns the secondary weight after [p, s] where index=findPrimary(p)
|
|
* except use index=0 for p=0.
|
|
*/
|
|
uint32_t getSecondaryAfter(int32_t index, uint32_t s) const;
|
|
/**
|
|
* Returns the tertiary weight after [p, s, t] where index=findPrimary(p)
|
|
* except use index=0 for p=0.
|
|
*/
|
|
uint32_t getTertiaryAfter(int32_t index, uint32_t s, uint32_t t) const;
|
|
|
|
private:
|
|
/**
|
|
* Finds the largest index i where elements[i]<=p.
|
|
* Requires first primary<=p<0xffffff00 (PRIMARY_SENTINEL).
|
|
* Does not require that p is a root collator primary.
|
|
*/
|
|
int32_t findP(uint32_t p) const;
|
|
|
|
static inline UBool isEndOfPrimaryRange(uint32_t q) {
|
|
return (q & SEC_TER_DELTA_FLAG) == 0 && (q & PRIMARY_STEP_MASK) != 0;
|
|
}
|
|
|
|
/**
|
|
* Data structure:
|
|
*
|
|
* The first few entries are indexes, up to elements[IX_FIRST_TERTIARY_INDEX].
|
|
* See the comments on the IX_ constants.
|
|
*
|
|
* All other elements are a compact form of the root collator CEs
|
|
* in collation order.
|
|
*
|
|
* Primary weights have the SEC_TER_DELTA_FLAG flag not set.
|
|
* A primary-weight element by itself represents a root CE
|
|
* with Collation::COMMON_SEC_AND_TER_CE.
|
|
*
|
|
* If there are root CEs with the same primary but other secondary/tertiary weights,
|
|
* then for each such CE there is an element with those secondary and tertiary weights,
|
|
* and with the SEC_TER_DELTA_FLAG flag set.
|
|
*
|
|
* A range of only-primary CEs with a consistent "step" increment
|
|
* from each primary to the next may be stored as a range.
|
|
* Only the first and last primary are stored, and the last has the step
|
|
* value in the low bits (PRIMARY_STEP_MASK).
|
|
*
|
|
* An range-end element may also either start a new range or be followed by
|
|
* elements with secondary/tertiary deltas.
|
|
*
|
|
* A primary element that is not a range end has zero step bits.
|
|
*
|
|
* There is no element for the completely ignorable CE (all weights 0).
|
|
*
|
|
* Before elements[IX_FIRST_PRIMARY_INDEX], all elements are secondary/tertiary deltas,
|
|
* for all of the ignorable root CEs.
|
|
*
|
|
* There are no elements for unassigned-implicit primary CEs.
|
|
* All primaries stored here are at most 3 bytes long.
|
|
*/
|
|
const uint32_t *elements;
|
|
int32_t length;
|
|
};
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif // !UCONFIG_NO_COLLATION
|
|
#endif // __COLLATIONROOTELEMENTS_H__
|