258 lines
9.4 KiB
C++
258 lines
9.4 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2012-2014, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*******************************************************************************
|
|
* collationdatabuilder.h
|
|
*
|
|
* created on: 2012apr01
|
|
* created by: Markus W. Scherer
|
|
*/
|
|
|
|
#ifndef __COLLATIONDATABUILDER_H__
|
|
#define __COLLATIONDATABUILDER_H__
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_COLLATION
|
|
|
|
#include "unicode/uniset.h"
|
|
#include "unicode/unistr.h"
|
|
#include "unicode/uversion.h"
|
|
#include "collation.h"
|
|
#include "collationdata.h"
|
|
#include "collationsettings.h"
|
|
#include "normalizer2impl.h"
|
|
#include "utrie2.h"
|
|
#include "uvectr32.h"
|
|
#include "uvectr64.h"
|
|
#include "uvector.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
struct ConditionalCE32;
|
|
|
|
class CollationFastLatinBuilder;
|
|
class CopyHelper;
|
|
class DataBuilderCollationIterator;
|
|
class UCharsTrieBuilder;
|
|
|
|
/**
|
|
* Low-level CollationData builder.
|
|
* Takes (character, CE) pairs and builds them into runtime data structures.
|
|
* Supports characters with context prefixes and contraction suffixes.
|
|
*/
|
|
class U_I18N_API CollationDataBuilder : public UObject {
|
|
public:
|
|
/**
|
|
* Collation element modifier. Interface class for a modifier
|
|
* that changes a tailoring builder's temporary CEs to final CEs.
|
|
* Called for every non-special CE32 and every expansion CE.
|
|
*/
|
|
class CEModifier : public UObject {
|
|
public:
|
|
virtual ~CEModifier();
|
|
/** Returns a new CE to replace the non-special input CE32, or else Collation::NO_CE. */
|
|
virtual int64_t modifyCE32(uint32_t ce32) const = 0;
|
|
/** Returns a new CE to replace the input CE, or else Collation::NO_CE. */
|
|
virtual int64_t modifyCE(int64_t ce) const = 0;
|
|
};
|
|
|
|
CollationDataBuilder(UErrorCode &errorCode);
|
|
|
|
virtual ~CollationDataBuilder();
|
|
|
|
void initForTailoring(const CollationData *b, UErrorCode &errorCode);
|
|
|
|
virtual UBool isCompressibleLeadByte(uint32_t b) const;
|
|
|
|
inline UBool isCompressiblePrimary(uint32_t p) const {
|
|
return isCompressibleLeadByte(p >> 24);
|
|
}
|
|
|
|
/**
|
|
* @return TRUE if this builder has mappings (e.g., add() has been called)
|
|
*/
|
|
UBool hasMappings() const { return modified; }
|
|
|
|
/**
|
|
* @return TRUE if c has CEs in this builder
|
|
*/
|
|
UBool isAssigned(UChar32 c) const;
|
|
|
|
/**
|
|
* @return the three-byte primary if c maps to a single such CE and has no context data,
|
|
* otherwise returns 0.
|
|
*/
|
|
uint32_t getLongPrimaryIfSingleCE(UChar32 c) const;
|
|
|
|
/**
|
|
* @return the single CE for c.
|
|
* Sets an error code if c does not have a single CE.
|
|
*/
|
|
int64_t getSingleCE(UChar32 c, UErrorCode &errorCode) const;
|
|
|
|
void add(const UnicodeString &prefix, const UnicodeString &s,
|
|
const int64_t ces[], int32_t cesLength,
|
|
UErrorCode &errorCode);
|
|
|
|
/**
|
|
* Encodes the ces as either the returned ce32 by itself,
|
|
* or by storing an expansion, with the returned ce32 referring to that.
|
|
*
|
|
* add(p, s, ces, cesLength) = addCE32(p, s, encodeCEs(ces, cesLength))
|
|
*/
|
|
virtual uint32_t encodeCEs(const int64_t ces[], int32_t cesLength, UErrorCode &errorCode);
|
|
void addCE32(const UnicodeString &prefix, const UnicodeString &s,
|
|
uint32_t ce32, UErrorCode &errorCode);
|
|
|
|
/**
|
|
* Sets three-byte-primary CEs for a range of code points in code point order,
|
|
* if it is worth doing; otherwise no change is made.
|
|
* None of the code points in the range should have complex mappings so far
|
|
* (expansions/contractions/prefixes).
|
|
* @param start first code point
|
|
* @param end last code point (inclusive)
|
|
* @param primary primary weight for 'start'
|
|
* @param step per-code point primary-weight increment
|
|
* @param errorCode ICU in/out error code
|
|
* @return TRUE if an OFFSET_TAG range was used for start..end
|
|
*/
|
|
UBool maybeSetPrimaryRange(UChar32 start, UChar32 end,
|
|
uint32_t primary, int32_t step,
|
|
UErrorCode &errorCode);
|
|
|
|
/**
|
|
* Sets three-byte-primary CEs for a range of code points in code point order.
|
|
* Sets range values if that is worth doing, or else individual values.
|
|
* None of the code points in the range should have complex mappings so far
|
|
* (expansions/contractions/prefixes).
|
|
* @param start first code point
|
|
* @param end last code point (inclusive)
|
|
* @param primary primary weight for 'start'
|
|
* @param step per-code point primary-weight increment
|
|
* @param errorCode ICU in/out error code
|
|
* @return the next primary after 'end': start primary incremented by ((end-start)+1)*step
|
|
*/
|
|
uint32_t setPrimaryRangeAndReturnNext(UChar32 start, UChar32 end,
|
|
uint32_t primary, int32_t step,
|
|
UErrorCode &errorCode);
|
|
|
|
/**
|
|
* Copies all mappings from the src builder, with modifications.
|
|
* This builder here must not be built yet, and should be empty.
|
|
*/
|
|
void copyFrom(const CollationDataBuilder &src, const CEModifier &modifier,
|
|
UErrorCode &errorCode);
|
|
|
|
void optimize(const UnicodeSet &set, UErrorCode &errorCode);
|
|
void suppressContractions(const UnicodeSet &set, UErrorCode &errorCode);
|
|
|
|
void enableFastLatin() { fastLatinEnabled = TRUE; }
|
|
virtual void build(CollationData &data, UErrorCode &errorCode);
|
|
|
|
/**
|
|
* Looks up CEs for s and appends them to the ces array.
|
|
* Does not handle normalization: s should be in FCD form.
|
|
*
|
|
* Does not write completely ignorable CEs.
|
|
* Does not write beyond Collation::MAX_EXPANSION_LENGTH.
|
|
*
|
|
* @return incremented cesLength
|
|
*/
|
|
int32_t getCEs(const UnicodeString &s, int64_t ces[], int32_t cesLength);
|
|
int32_t getCEs(const UnicodeString &prefix, const UnicodeString &s,
|
|
int64_t ces[], int32_t cesLength);
|
|
|
|
protected:
|
|
friend class CopyHelper;
|
|
friend class DataBuilderCollationIterator;
|
|
|
|
uint32_t getCE32FromOffsetCE32(UBool fromBase, UChar32 c, uint32_t ce32) const;
|
|
|
|
int32_t addCE(int64_t ce, UErrorCode &errorCode);
|
|
int32_t addCE32(uint32_t ce32, UErrorCode &errorCode);
|
|
int32_t addConditionalCE32(const UnicodeString &context, uint32_t ce32, UErrorCode &errorCode);
|
|
|
|
inline ConditionalCE32 *getConditionalCE32(int32_t index) const {
|
|
return static_cast<ConditionalCE32 *>(conditionalCE32s[index]);
|
|
}
|
|
inline ConditionalCE32 *getConditionalCE32ForCE32(uint32_t ce32) const {
|
|
return getConditionalCE32(Collation::indexFromCE32(ce32));
|
|
}
|
|
|
|
static uint32_t makeBuilderContextCE32(int32_t index) {
|
|
return Collation::makeCE32FromTagAndIndex(Collation::BUILDER_DATA_TAG, index);
|
|
}
|
|
static inline UBool isBuilderContextCE32(uint32_t ce32) {
|
|
return Collation::hasCE32Tag(ce32, Collation::BUILDER_DATA_TAG);
|
|
}
|
|
|
|
static uint32_t encodeOneCEAsCE32(int64_t ce);
|
|
uint32_t encodeOneCE(int64_t ce, UErrorCode &errorCode);
|
|
uint32_t encodeExpansion(const int64_t ces[], int32_t length, UErrorCode &errorCode);
|
|
uint32_t encodeExpansion32(const int32_t newCE32s[], int32_t length, UErrorCode &errorCode);
|
|
|
|
uint32_t copyFromBaseCE32(UChar32 c, uint32_t ce32, UBool withContext, UErrorCode &errorCode);
|
|
/**
|
|
* Copies base contractions to a list of ConditionalCE32.
|
|
* Sets cond->next to the index of the first new item
|
|
* and returns the index of the last new item.
|
|
*/
|
|
int32_t copyContractionsFromBaseCE32(UnicodeString &context, UChar32 c, uint32_t ce32,
|
|
ConditionalCE32 *cond, UErrorCode &errorCode);
|
|
|
|
UBool getJamoCE32s(uint32_t jamoCE32s[], UErrorCode &errorCode);
|
|
void setDigitTags(UErrorCode &errorCode);
|
|
void setLeadSurrogates(UErrorCode &errorCode);
|
|
|
|
void buildMappings(CollationData &data, UErrorCode &errorCode);
|
|
|
|
void clearContexts();
|
|
void buildContexts(UErrorCode &errorCode);
|
|
uint32_t buildContext(ConditionalCE32 *head, UErrorCode &errorCode);
|
|
int32_t addContextTrie(uint32_t defaultCE32, UCharsTrieBuilder &trieBuilder,
|
|
UErrorCode &errorCode);
|
|
|
|
void buildFastLatinTable(CollationData &data, UErrorCode &errorCode);
|
|
|
|
int32_t getCEs(const UnicodeString &s, int32_t start, int64_t ces[], int32_t cesLength);
|
|
|
|
static UChar32 jamoCpFromIndex(int32_t i) {
|
|
// 0 <= i < CollationData::JAMO_CE32S_LENGTH = 19 + 21 + 27
|
|
if(i < Hangul::JAMO_L_COUNT) { return Hangul::JAMO_L_BASE + i; }
|
|
i -= Hangul::JAMO_L_COUNT;
|
|
if(i < Hangul::JAMO_V_COUNT) { return Hangul::JAMO_V_BASE + i; }
|
|
i -= Hangul::JAMO_V_COUNT;
|
|
// i < 27
|
|
return Hangul::JAMO_T_BASE + 1 + i;
|
|
}
|
|
|
|
/** @see Collation::BUILDER_DATA_TAG */
|
|
static const uint32_t IS_BUILDER_JAMO_CE32 = 0x100;
|
|
|
|
const Normalizer2Impl &nfcImpl;
|
|
const CollationData *base;
|
|
const CollationSettings *baseSettings;
|
|
UTrie2 *trie;
|
|
UVector32 ce32s;
|
|
UVector64 ce64s;
|
|
UVector conditionalCE32s; // vector of ConditionalCE32
|
|
// Characters that have context (prefixes or contraction suffixes).
|
|
UnicodeSet contextChars;
|
|
// Serialized UCharsTrie structures for finalized contexts.
|
|
UnicodeString contexts;
|
|
UnicodeSet unsafeBackwardSet;
|
|
UBool modified;
|
|
|
|
UBool fastLatinEnabled;
|
|
CollationFastLatinBuilder *fastLatinBuilder;
|
|
|
|
DataBuilderCollationIterator *collIter;
|
|
};
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif // !UCONFIG_NO_COLLATION
|
|
#endif // __COLLATIONDATABUILDER_H__
|