tblcoll.h

Go to the documentation of this file.
00001 /*
00002 ******************************************************************************
00003 * Copyright (C) 1996-2012, International Business Machines Corporation and
00004 * others. All Rights Reserved.
00005 ******************************************************************************
00006 */
00007 
00059 #ifndef TBLCOLL_H
00060 #define TBLCOLL_H
00061 
00062 #include "unicode/utypes.h"
00063 
00064  
00065 #if !UCONFIG_NO_COLLATION
00066 
00067 #include "unicode/coll.h"
00068 #include "unicode/ucol.h"
00069 #include "unicode/sortkey.h"
00070 #include "unicode/normlzr.h"
00071 
00072 U_NAMESPACE_BEGIN
00073 
00077 class StringSearch;
00081 class CollationElementIterator;
00082 
00111 class U_I18N_API RuleBasedCollator : public Collator
00112 {
00113 public:
00114 
00115   // constructor -------------------------------------------------------------
00116 
00126     RuleBasedCollator(const UnicodeString& rules, UErrorCode& status);
00127 
00138     RuleBasedCollator(const UnicodeString& rules,
00139                        ECollationStrength collationStrength,
00140                        UErrorCode& status);
00141 
00152     RuleBasedCollator(const UnicodeString& rules,
00153                     UColAttributeValue decompositionMode,
00154                     UErrorCode& status);
00155 
00167     RuleBasedCollator(const UnicodeString& rules,
00168                     ECollationStrength collationStrength,
00169                     UColAttributeValue decompositionMode,
00170                     UErrorCode& status);
00171 
00178     RuleBasedCollator(const RuleBasedCollator& other);
00179 
00180 
00198     RuleBasedCollator(const uint8_t *bin, int32_t length, 
00199                     const RuleBasedCollator *base, 
00200                     UErrorCode &status);
00201     // destructor --------------------------------------------------------------
00202 
00207     virtual ~RuleBasedCollator();
00208 
00209     // public methods ----------------------------------------------------------
00210 
00216     RuleBasedCollator& operator=(const RuleBasedCollator& other);
00217 
00224     virtual UBool operator==(const Collator& other) const;
00225 
00231     virtual Collator* clone(void) const;
00232 
00243     virtual CollationElementIterator* createCollationElementIterator(
00244                                            const UnicodeString& source) const;
00245 
00255     virtual CollationElementIterator* createCollationElementIterator(
00256                                          const CharacterIterator& source) const;
00257 
00258     // Make deprecated versions of Collator::compare() visible.
00259     using Collator::compare;
00260 
00273     virtual UCollationResult compare(const UnicodeString& source,
00274                                       const UnicodeString& target,
00275                                       UErrorCode &status) const;
00276 
00290     virtual UCollationResult compare(const UnicodeString& source,
00291                                       const UnicodeString& target,
00292                                       int32_t length,
00293                                       UErrorCode &status) const;
00294 
00311     virtual UCollationResult compare(const UChar* source, int32_t sourceLength,
00312                                       const UChar* target, int32_t targetLength,
00313                                       UErrorCode &status) const;
00314 
00326     virtual UCollationResult compare(UCharIterator &sIter,
00327                                      UCharIterator &tIter,
00328                                      UErrorCode &status) const;
00329 
00342     virtual CollationKey& getCollationKey(const UnicodeString& source,
00343                                           CollationKey& key,
00344                                           UErrorCode& status) const;
00345 
00359     virtual CollationKey& getCollationKey(const UChar *source,
00360                                           int32_t sourceLength,
00361                                           CollationKey& key,
00362                                           UErrorCode& status) const;
00363 
00369     virtual int32_t hashCode(void) const;
00370 
00381     virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
00382 
00388     const UnicodeString& getRules(void) const;
00389 
00395     virtual void getVersion(UVersionInfo info) const;
00396 
00407     int32_t getMaxExpansion(int32_t order) const;
00408 
00419     virtual UClassID getDynamicClassID(void) const;
00420 
00432     static UClassID U_EXPORT2 getStaticClassID(void);
00433 
00442     uint8_t *cloneRuleData(int32_t &length, UErrorCode &status);
00443 
00444 
00455     int32_t cloneBinary(uint8_t *buffer, int32_t capacity, UErrorCode &status);
00456 
00468     void getRules(UColRuleOption delta, UnicodeString &buffer);
00469 
00477     virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
00478                               UErrorCode &status);
00479 
00487     virtual UColAttributeValue getAttribute(UColAttribute attr,
00488                                             UErrorCode &status) const;
00489 
00500     virtual uint32_t setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status);
00501 
00511     virtual uint32_t setVariableTop(const UnicodeString &varTop, UErrorCode &status);
00512 
00520     virtual void setVariableTop(uint32_t varTop, UErrorCode &status);
00521 
00528     virtual uint32_t getVariableTop(UErrorCode &status) const;
00529 
00539     virtual UnicodeSet *getTailoredSet(UErrorCode &status) const;
00540 
00551     virtual int32_t getSortKey(const UnicodeString& source, uint8_t *result,
00552                                int32_t resultLength) const;
00553 
00566     virtual int32_t getSortKey(const UChar *source, int32_t sourceLength,
00567                                uint8_t *result, int32_t resultLength) const;
00568 
00582      virtual int32_t getReorderCodes(int32_t *dest,
00583                                      int32_t destCapacity,
00584                                      UErrorCode& status) const;
00585 
00596      virtual void setReorderCodes(const int32_t* reorderCodes,
00597                                   int32_t reorderCodesLength,
00598                                   UErrorCode& status) ;
00599 
00616     static int32_t U_EXPORT2 getEquivalentReorderCodes(int32_t reorderCode,
00617                                 int32_t* dest,
00618                                 int32_t destCapacity,
00619                                 UErrorCode& status);
00620 
00621 private:
00622 
00623     // private static constants -----------------------------------------------
00624 
00625     enum {
00626         /* need look up in .commit() */
00627         CHARINDEX = 0x70000000,
00628         /* Expand index follows */
00629         EXPANDCHARINDEX = 0x7E000000,
00630         /* contract indexes follows */
00631         CONTRACTCHARINDEX = 0x7F000000,
00632         /* unmapped character values */
00633         UNMAPPED = 0xFFFFFFFF,
00634         /* primary strength increment */
00635         PRIMARYORDERINCREMENT = 0x00010000,
00636         /* secondary strength increment */
00637         SECONDARYORDERINCREMENT = 0x00000100,
00638         /* tertiary strength increment */
00639         TERTIARYORDERINCREMENT = 0x00000001,
00640         /* mask off anything but primary order */
00641         PRIMARYORDERMASK = 0xffff0000,
00642         /* mask off anything but secondary order */
00643         SECONDARYORDERMASK = 0x0000ff00,
00644         /* mask off anything but tertiary order */
00645         TERTIARYORDERMASK = 0x000000ff,
00646         /* mask off ignorable char order */
00647         IGNORABLEMASK = 0x0000ffff,
00648         /* use only the primary difference */
00649         PRIMARYDIFFERENCEONLY = 0xffff0000,
00650         /* use only the primary and secondary difference */
00651         SECONDARYDIFFERENCEONLY = 0xffffff00,
00652         /* primary order shift */
00653         PRIMARYORDERSHIFT = 16,
00654         /* secondary order shift */
00655         SECONDARYORDERSHIFT = 8,
00656         /* starting value for collation elements */
00657         COLELEMENTSTART = 0x02020202,
00658         /* testing mask for primary low element */
00659         PRIMARYLOWZEROMASK = 0x00FF0000,
00660         /* reseting value for secondaries and tertiaries */
00661         RESETSECONDARYTERTIARY = 0x00000202,
00662         /* reseting value for tertiaries */
00663         RESETTERTIARY = 0x00000002,
00664 
00665         PRIMIGNORABLE = 0x0202
00666     };
00667 
00668     // private data members ---------------------------------------------------
00669 
00670     UBool dataIsOwned;
00671 
00672     UBool isWriteThroughAlias;
00673 
00678     UCollator *ucollator;
00679 
00683     UnicodeString urulestring;
00684 
00685     // friend classes --------------------------------------------------------
00686 
00690     friend class CollationElementIterator;
00691 
00696     friend class Collator;
00697 
00701     friend class StringSearch;
00702 
00703     // private constructors --------------------------------------------------
00704 
00708     RuleBasedCollator();
00709 
00720     RuleBasedCollator(const Locale& desiredLocale, UErrorCode& status);
00721 
00730     void
00731     construct(const UnicodeString& rules,
00732               UColAttributeValue collationStrength,
00733               UColAttributeValue decompositionMode,
00734               UErrorCode& status);
00735 
00736     // private methods -------------------------------------------------------
00737 
00743     void setUCollator(const Locale& locale, UErrorCode& status);
00744 
00750     void setUCollator(const char* locale, UErrorCode& status);
00751 
00758     void setUCollator(UCollator *collator);
00759 
00760 public:
00761 #ifndef U_HIDE_INTERNAL_API
00762 
00767     const UCollator * getUCollator();
00768 #endif  /* U_HIDE_INTERNAL_API */
00769 
00770 protected:
00778     virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale);
00779 
00780 private:
00781     // if not owned and not a write through alias, copy the ucollator
00782     void checkOwned(void);
00783 
00784     // utility to init rule string used by checkOwned and construct
00785     void setRuleStringFromCollator();
00786 
00787 public:
00811     virtual int32_t internalGetShortDefinitionString(const char *locale,
00812                                                      char *buffer,
00813                                                      int32_t capacity,
00814                                                      UErrorCode &status) const;
00815 };
00816 
00817 // inline method implementation ---------------------------------------------
00818 
00819 inline void RuleBasedCollator::setUCollator(const Locale &locale,
00820                                                UErrorCode &status)
00821 {
00822     setUCollator(locale.getName(), status);
00823 }
00824 
00825 
00826 inline void RuleBasedCollator::setUCollator(UCollator     *collator)
00827 {
00828 
00829     if (ucollator && dataIsOwned) {
00830         ucol_close(ucollator);
00831     }
00832     ucollator   = collator;
00833     dataIsOwned = FALSE;
00834     isWriteThroughAlias = TRUE;
00835     setRuleStringFromCollator();
00836 }
00837 
00838 #ifndef U_HIDE_INTERNAL_API
00839 inline const UCollator * RuleBasedCollator::getUCollator()
00840 {
00841     return ucollator;
00842 }
00843 #endif
00844 
00845 U_NAMESPACE_END
00846 
00847 #endif /* #if !UCONFIG_NO_COLLATION */
00848 
00849 #endif

Generated on 27 Oct 2013 for ICU 50.1.2 by  doxygen 1.4.7