Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Search  

tblcoll.h

Go to the documentation of this file.
00001 /*
00002 ******************************************************************************
00003 * Copyright (C) 1996-2001, International Business Machines Corporation and
00004 * others. All Rights Reserved.
00005 ******************************************************************************
00006 */
00007 
00054 #ifndef TBLCOLL_H
00055 #define TBLCOLL_H
00056 
00057 #include "unicode/coll.h"
00058 #include "unicode/sortkey.h"
00059 #include "unicode/normlzr.h"
00060 
00061 U_NAMESPACE_BEGIN
00062 
00066 class StringSearch;
00070 class CollationElementIterator;
00071 
00099 class U_I18N_API RuleBasedCollator : public Collator
00100 {
00101 public:
00102 
00103   // constructor -------------------------------------------------------------
00104 
00114     RuleBasedCollator(const UnicodeString& rules, UErrorCode& status);
00115 
00126   RuleBasedCollator(const UnicodeString& rules,
00127                        ECollationStrength collationStrength,
00128                        UErrorCode& status);
00129 
00140   RuleBasedCollator(const UnicodeString& rules,
00141                     UColAttributeValue decompositionMode,
00142                     UErrorCode& status);
00143 
00155   RuleBasedCollator(const UnicodeString& rules,
00156                     ECollationStrength collationStrength,
00157                     UColAttributeValue decompositionMode,
00158                     UErrorCode& status);
00159 
00166     RuleBasedCollator(const RuleBasedCollator& other);
00167 
00168   // destructor --------------------------------------------------------------
00169 
00174     virtual ~RuleBasedCollator();
00175 
00176   // public methods ----------------------------------------------------------
00177 
00183     RuleBasedCollator& operator=(const RuleBasedCollator& other);
00184 
00191   virtual UBool operator==(const Collator& other) const;
00192 
00199   virtual UBool operator!=(const Collator& other) const;
00200 
00207   virtual Collator* clone(void) const;
00208 
00219     virtual CollationElementIterator* createCollationElementIterator(
00220                                            const UnicodeString& source) const;
00221 
00231   virtual CollationElementIterator* createCollationElementIterator(
00232                                        const CharacterIterator& source) const;
00233 
00246   virtual EComparisonResult compare(const UnicodeString& source,
00247                                     const UnicodeString& target) const;
00248 
00249 
00263   virtual EComparisonResult compare(const UnicodeString& source,
00264                                     const UnicodeString&  target,
00265                                     int32_t length) const;
00266 
00300   virtual EComparisonResult compare(const UChar* source, int32_t sourceLength,
00301                                     const UChar* target, int32_t targetLength)
00302                                     const;
00303 
00316   virtual CollationKey& getCollationKey(const UnicodeString& source,
00317                                         CollationKey& key,
00318                                         UErrorCode& status) const;
00319 
00332   virtual CollationKey& getCollationKey(const UChar *source,
00333                                         int32_t sourceLength,
00334                                         CollationKey& key,
00335                                         UErrorCode& status) const;
00336 
00342   virtual int32_t hashCode(void) const;
00343 
00354   virtual const Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
00355 
00362   const UnicodeString& getRules(void) const;
00363 
00369   virtual void getVersion(UVersionInfo info) const;
00370 
00381   int32_t getMaxExpansion(int32_t order) const;
00382 
00393   virtual UClassID getDynamicClassID(void) const
00394   {
00395     return RuleBasedCollator::getStaticClassID();
00396   }
00397 
00409   static UClassID getStaticClassID(void)
00410   {
00411     return (UClassID)&fgClassID;
00412   }
00413 
00422   uint8_t *cloneRuleData(int32_t &length, UErrorCode &status);
00423 
00431   void getRules(UColRuleOption delta, UnicodeString &buffer);
00432 
00440   virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
00441                             UErrorCode &status);
00442 
00450   virtual UColAttributeValue getAttribute(UColAttribute attr,
00451                                           UErrorCode &status);
00452 
00463   virtual uint32_t setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status);
00464 
00474   virtual uint32_t setVariableTop(const UnicodeString varTop, UErrorCode &status);
00475 
00483   virtual void setVariableTop(const uint32_t varTop, UErrorCode &status);
00484 
00491   virtual uint32_t getVariableTop(UErrorCode &status) const;
00492 
00498   virtual Collator* safeClone(void);
00499 
00510   virtual int32_t getSortKey(const UnicodeString& source, uint8_t *result,
00511                              int32_t resultLength) const;
00512 
00525   virtual int32_t getSortKey(const UChar *source, int32_t sourceLength,
00526                              uint8_t *result, int32_t resultLength) const;
00527 
00538   virtual ECollationStrength getStrength(void) const;
00539 
00546   virtual void setStrength(ECollationStrength newStrength);
00547 
00548   // deprecated functions ---------------------------------------------------
00549 
00560   RuleBasedCollator(const UnicodeString& rules,
00561                     Normalizer::EMode decompositionMode,
00562                     UErrorCode& status);
00563 
00575   RuleBasedCollator(const UnicodeString& rules,
00576                     ECollationStrength collationStrength,
00577                     Normalizer::EMode decompositionMode,
00578                     UErrorCode& status);
00579 
00587   virtual void setDecomposition(Normalizer::EMode  mode);
00588 
00595   virtual Normalizer::EMode getDecomposition(void) const;
00596 
00597 private:
00598 
00599   // private static constants -----------------------------------------------
00600 
00601   static const int32_t UNMAPPED;
00602   static const int32_t CHARINDEX;  // need look up in .commit()
00603   static const int32_t EXPANDCHARINDEX; // Expand index follows
00604   static const int32_t CONTRACTCHARINDEX;  // contract indexes follow
00605 
00606   static const int32_t PRIMARYORDERINCREMENT;
00607   static const int32_t SECONDARYORDERINCREMENT;
00608   static const int32_t TERTIARYORDERINCREMENT;
00609   static const int32_t PRIMARYORDERMASK;
00610   static const int32_t SECONDARYORDERMASK;
00611   static const int32_t TERTIARYORDERMASK;
00612   static const int32_t IGNORABLEMASK;
00613   static const int32_t PRIMARYDIFFERENCEONLY;
00614   static const int32_t SECONDARYDIFFERENCEONLY;
00615   static const int32_t PRIMARYORDERSHIFT;
00616   static const int32_t SECONDARYORDERSHIFT;
00617 
00618   static const int32_t COLELEMENTSTART;
00619   static const int32_t PRIMARYLOWZEROMASK;
00620   static const int32_t RESETSECONDARYTERTIARY;
00621   static const int32_t RESETTERTIARY;
00622 
00623   static const int32_t PRIMIGNORABLE;
00624 
00625   static const int16_t FILEID;
00626   static const char    kFilenameSuffix[];
00627 
00628   // private static variables -----------------------------------------------
00629 
00633   static const char fgClassID;
00634 
00635   // private data members ---------------------------------------------------
00636 
00637   UBool dataIsOwned;
00638 
00643   UCollator *ucollator;
00644 
00648   UnicodeString *urulestring;
00649 
00650   // friend classes --------------------------------------------------------
00651 
00655   friend class CollationElementIterator;
00656 
00661   friend class Collator;
00662 
00666   friend class StringSearch;
00667 
00668   // private constructors --------------------------------------------------
00669 
00673   RuleBasedCollator();
00674 
00680   RuleBasedCollator(UCollator *collator, UnicodeString *rule);
00681 
00692   RuleBasedCollator(const Locale& desiredLocale, UErrorCode& status);
00693 
00702   void
00703   construct(const UnicodeString& rules,
00704             UColAttributeValue collationStrength,
00705             UColAttributeValue decompositionMode,
00706             UErrorCode& status);
00707 
00708   // private methods -------------------------------------------------------
00709 
00715   void setUCollator(const Locale& locale, UErrorCode& status);
00716 
00722   void setUCollator(const char* locale, UErrorCode& status);
00723 
00728   void setUCollator(UCollator *collator);
00729 
00737   void setUCollator(UCollator *collator, UnicodeString *rules);
00738 
00743   const UCollator * getUCollator();
00744 
00750   Collator::EComparisonResult getEComparisonResult(
00751                                           const UCollationResult &result) const;
00752 
00758   Collator::ECollationStrength getECollationStrength(
00759                                       const UCollationStrength &strength) const;
00760 
00766   UCollationStrength getUCollationStrength(
00767     const Collator::ECollationStrength &strength) const;
00768 };
00769 
00770 // inline method implementation ---------------------------------------------
00771 
00772 inline UBool RuleBasedCollator::operator!=(const Collator& other) const
00773 {
00774   return !(*this == other);
00775 }
00776 
00777 inline void RuleBasedCollator::setUCollator(const char *locale,
00778                                                UErrorCode &status)
00779 {
00780   if (U_FAILURE(status))
00781     return;
00782   if (ucollator && dataIsOwned)
00783     ucol_close(ucollator);
00784   ucollator = ucol_open(locale, &status);
00785 }
00786 
00787 inline void RuleBasedCollator::setUCollator(const Locale &locale,
00788                                                UErrorCode &status)
00789 {
00790   setUCollator(locale.getName(), status);
00791 }
00792 
00793 inline void RuleBasedCollator::setUCollator(UCollator *collator)
00794 {
00795   if (ucollator && dataIsOwned) {
00796     ucol_close(ucollator);
00797   }
00798   ucollator = collator;
00799 }
00800 
00801 inline void RuleBasedCollator::setUCollator(UCollator     *collator, 
00802                                             UnicodeString *rules)
00803 {
00804     if (ucollator && dataIsOwned) {
00805         ucol_close(ucollator);
00806         delete urulestring;
00807     }
00808     ucollator   = collator;
00809     urulestring = rules;
00810     dataIsOwned = FALSE;
00811 }
00812 
00813 inline const UCollator * RuleBasedCollator::getUCollator()
00814 {
00815     return ucollator;
00816 }
00817 
00818 inline Collator::EComparisonResult RuleBasedCollator::getEComparisonResult(
00819                                            const UCollationResult &result) const
00820 {
00821   switch (result)
00822   {
00823   case UCOL_LESS :
00824     return Collator::LESS;
00825   case UCOL_EQUAL :
00826     return Collator::EQUAL;
00827   default :
00828     return Collator::GREATER;
00829   }
00830 }
00831 
00832 inline Collator::ECollationStrength RuleBasedCollator::getECollationStrength(
00833                                        const UCollationStrength &strength) const
00834 {
00835   switch (strength)
00836   {
00837   case UCOL_PRIMARY :
00838     return Collator::PRIMARY;
00839   case UCOL_SECONDARY :
00840     return Collator::SECONDARY;
00841   case UCOL_TERTIARY :
00842     return Collator::TERTIARY;
00843   case UCOL_QUATERNARY :
00844     return Collator::QUATERNARY;   
00845   default :
00846     return Collator::IDENTICAL;
00847   }
00848 }
00849 
00850 inline UCollationStrength RuleBasedCollator::getUCollationStrength(
00851                              const Collator::ECollationStrength &strength) const
00852 {
00853   switch (strength)
00854   {
00855   case Collator::PRIMARY :
00856     return UCOL_PRIMARY;
00857   case Collator::SECONDARY :
00858     return UCOL_SECONDARY;
00859   case Collator::TERTIARY :
00860     return UCOL_TERTIARY;
00861   case Collator::QUATERNARY :
00862     return UCOL_QUATERNARY;
00863   default :
00864     return UCOL_IDENTICAL;
00865   }
00866 }
00867 
00868 U_NAMESPACE_END
00869 
00870 #endif

Generated on Thu Aug 15 14:13:29 2002 for ICU 2.2 by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001