Main Page   Class Hierarchy   Alphabetical List   Data Structures   File List   Data Fields   Globals  

tblcoll.h

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 
00063 class StringSearch;
00064 class CollationElementIterator;
00065 
00093 class U_I18N_API RuleBasedCollator : public Collator
00094 {
00095 public:
00096 
00097   // constructor -------------------------------------------------------------
00098 
00108     RuleBasedCollator(const UnicodeString& rules, UErrorCode& status);
00109 
00120   RuleBasedCollator(const UnicodeString& rules,
00121                        ECollationStrength collationStrength,
00122                        UErrorCode& status);
00123 
00134   RuleBasedCollator(const UnicodeString& rules,
00135                     UColAttributeValue decompositionMode,
00136                     UErrorCode& status);
00137 
00149   RuleBasedCollator(const UnicodeString& rules,
00150                     ECollationStrength collationStrength,
00151                     UColAttributeValue decompositionMode,
00152                     UErrorCode& status);
00153 
00160     RuleBasedCollator(const RuleBasedCollator& other);
00161 
00162   // destructor --------------------------------------------------------------
00163 
00168     virtual ~RuleBasedCollator();
00169 
00170   // public methods ----------------------------------------------------------
00171 
00177     RuleBasedCollator& operator=(const RuleBasedCollator& other);
00178 
00185   virtual UBool operator==(const Collator& other) const;
00186 
00193   virtual UBool operator!=(const Collator& other) const;
00194 
00201   virtual Collator* clone(void) const;
00202 
00213     virtual CollationElementIterator* createCollationElementIterator(
00214                                            const UnicodeString& source) const;
00215 
00225   virtual CollationElementIterator* createCollationElementIterator(
00226                                        const CharacterIterator& source) const;
00227 
00240   virtual EComparisonResult compare(const UnicodeString& source,
00241                                     const UnicodeString& target) const;
00242 
00243 
00257   virtual EComparisonResult compare(const UnicodeString& source,
00258                                     const UnicodeString&  target,
00259                                     int32_t length) const;
00260 
00293   virtual EComparisonResult compare(const UChar* source, int32_t sourceLength,
00294                                     const UChar* target, int32_t targetLength)
00295                                     const;
00296 
00309   virtual CollationKey& getCollationKey(const UnicodeString& source,
00310                                         CollationKey& key,
00311                                         UErrorCode& status) const;
00312 
00325   virtual CollationKey& getCollationKey(const UChar *source,
00326                                         int32_t sourceLength,
00327                                         CollationKey& key,
00328                                         UErrorCode& status) const;
00329 
00335   virtual int32_t hashCode(void) const;
00336 
00343   virtual const Locale getLocale(UErrorCode& status) const;
00344 
00351   const UnicodeString& getRules(void) const;
00352 
00358   virtual void getVersion(UVersionInfo info) const;
00359 
00370   int32_t getMaxExpansion(int32_t order) const;
00371 
00382   virtual UClassID getDynamicClassID(void) const
00383   {
00384     return RuleBasedCollator::getStaticClassID();
00385   }
00386 
00398   static UClassID getStaticClassID(void)
00399   {
00400     return (UClassID)&fgClassID;
00401   }
00402 
00411   uint8_t *cloneRuleData(int32_t &length, UErrorCode &status);
00412 
00420   void getRules(UColRuleOption delta, UnicodeString &buffer);
00421 
00429   virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
00430                             UErrorCode &status);
00431 
00439   virtual UColAttributeValue getAttribute(UColAttribute attr,
00440                                           UErrorCode &status);
00441 
00452   virtual uint32_t setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status);
00453 
00463   virtual uint32_t setVariableTop(const UnicodeString varTop, UErrorCode &status);
00464 
00472   virtual void setVariableTop(const uint32_t varTop, UErrorCode &status);
00473 
00480   virtual uint32_t getVariableTop(UErrorCode &status) const;
00481 
00487   virtual Collator* safeClone(void);
00488 
00498   virtual int32_t getSortKey(const UnicodeString& source, uint8_t *result,
00499                              int32_t resultLength) const;
00500 
00513   virtual int32_t getSortKey(const UChar *source, int32_t sourceLength,
00514                              uint8_t *result, int32_t resultLength) const;
00515 
00526   virtual ECollationStrength getStrength(void) const;
00527 
00534   virtual void setStrength(ECollationStrength newStrength);
00535 
00536   // deprecated functions ---------------------------------------------------
00537 
00548   RuleBasedCollator(const UnicodeString& rules,
00549                     Normalizer::EMode decompositionMode,
00550                     UErrorCode& status);
00551 
00563   RuleBasedCollator(const UnicodeString& rules,
00564                     ECollationStrength collationStrength,
00565                     Normalizer::EMode decompositionMode,
00566                     UErrorCode& status);
00567 
00575   virtual void setDecomposition(Normalizer::EMode  mode);
00576 
00583   virtual Normalizer::EMode getDecomposition(void) const;
00584 
00585 private:
00586 
00587   // private static constants -----------------------------------------------
00588 
00589   static const int32_t UNMAPPED;
00590   static const int32_t CHARINDEX;  // need look up in .commit()
00591   static const int32_t EXPANDCHARINDEX; // Expand index follows
00592   static const int32_t CONTRACTCHARINDEX;  // contract indexes follow
00593 
00594   static const int32_t PRIMARYORDERINCREMENT;
00595   static const int32_t SECONDARYORDERINCREMENT;
00596   static const int32_t TERTIARYORDERINCREMENT;
00597   static const int32_t PRIMARYORDERMASK;
00598   static const int32_t SECONDARYORDERMASK;
00599   static const int32_t TERTIARYORDERMASK;
00600   static const int32_t IGNORABLEMASK;
00601   static const int32_t PRIMARYDIFFERENCEONLY;
00602   static const int32_t SECONDARYDIFFERENCEONLY;
00603   static const int32_t PRIMARYORDERSHIFT;
00604   static const int32_t SECONDARYORDERSHIFT;
00605 
00606   static const int32_t COLELEMENTSTART;
00607   static const int32_t PRIMARYLOWZEROMASK;
00608   static const int32_t RESETSECONDARYTERTIARY;
00609   static const int32_t RESETTERTIARY;
00610 
00611   static const int32_t PRIMIGNORABLE;
00612 
00613   static const int16_t FILEID;
00614   static const char    kFilenameSuffix[];
00615 
00616   // private static variables -----------------------------------------------
00617 
00621   static const char fgClassID;
00622 
00623   // private data members ---------------------------------------------------
00624 
00625   UBool dataIsOwned;
00626 
00631   UCollator *ucollator;
00632 
00636   UnicodeString *urulestring;
00637 
00638   // friend classes --------------------------------------------------------
00639 
00643   friend class CollationElementIterator;
00644 
00649   friend class Collator;
00650 
00654   friend class StringSearch;
00655 
00656   // private constructors --------------------------------------------------
00657 
00661   RuleBasedCollator();
00662 
00667   RuleBasedCollator(UCollator *collator, UnicodeString *rule);
00668 
00679   RuleBasedCollator(const Locale& desiredLocale, UErrorCode& status);
00680 
00682   void
00683   construct(const UnicodeString& rules,
00684             UColAttributeValue collationStrength,
00685             UColAttributeValue decompositionMode,
00686             UErrorCode& status);
00687 
00688   // private methods -------------------------------------------------------
00689 
00695   void setUCollator(const Locale& locale, UErrorCode& status);
00696 
00702   void setUCollator(const char* locale, UErrorCode& status);
00703 
00708   void setUCollator(UCollator *collator);
00709 
00717   void setUCollator(UCollator *collator, UnicodeString *rules);
00718 
00723   const UCollator * getUCollator();
00724 
00730   Collator::EComparisonResult getEComparisonResult(
00731                                           const UCollationResult &result) const;
00732 
00738   Collator::ECollationStrength getECollationStrength(
00739                                       const UCollationStrength &strength) const;
00740 
00746   UCollationStrength getUCollationStrength(
00747     const Collator::ECollationStrength &strength) const;
00748 };
00749 
00750 // inline method implementation ---------------------------------------------
00751 
00752 inline UBool RuleBasedCollator::operator!=(const Collator& other) const
00753 {
00754   return !(*this == other);
00755 }
00756 
00757 inline void RuleBasedCollator::setUCollator(const char *locale,
00758                                                UErrorCode &status)
00759 {
00760   if (U_FAILURE(status))
00761     return;
00762   if (ucollator && dataIsOwned)
00763     ucol_close(ucollator);
00764   ucollator = ucol_open(locale, &status);
00765 }
00766 
00767 inline void RuleBasedCollator::setUCollator(const Locale &locale,
00768                                                UErrorCode &status)
00769 {
00770   setUCollator(locale.getName(), status);
00771 }
00772 
00773 inline void RuleBasedCollator::setUCollator(UCollator *collator)
00774 {
00775   if (ucollator && dataIsOwned) {
00776     ucol_close(ucollator);
00777   }
00778   ucollator = collator;
00779 }
00780 
00781 inline void RuleBasedCollator::setUCollator(UCollator     *collator, 
00782                                             UnicodeString *rules)
00783 {
00784     if (ucollator && dataIsOwned) {
00785         ucol_close(ucollator);
00786         delete urulestring;
00787     }
00788     ucollator   = collator;
00789     urulestring = rules;
00790     dataIsOwned = FALSE;
00791 }
00792 
00793 inline const UCollator * RuleBasedCollator::getUCollator()
00794 {
00795     return ucollator;
00796 }
00797 
00798 inline Collator::EComparisonResult RuleBasedCollator::getEComparisonResult(
00799                                            const UCollationResult &result) const
00800 {
00801   switch (result)
00802   {
00803   case UCOL_LESS :
00804     return Collator::LESS;
00805   case UCOL_EQUAL :
00806     return Collator::EQUAL;
00807   default :
00808     return Collator::GREATER;
00809   }
00810 }
00811 
00812 inline Collator::ECollationStrength RuleBasedCollator::getECollationStrength(
00813                                        const UCollationStrength &strength) const
00814 {
00815   switch (strength)
00816   {
00817   case UCOL_PRIMARY :
00818     return Collator::PRIMARY;
00819   case UCOL_SECONDARY :
00820     return Collator::SECONDARY;
00821   case UCOL_TERTIARY :
00822     return Collator::TERTIARY;
00823   case UCOL_QUATERNARY :
00824     return Collator::QUATERNARY;   
00825   default :
00826     return Collator::IDENTICAL;
00827   }
00828 }
00829 
00830 inline UCollationStrength RuleBasedCollator::getUCollationStrength(
00831                              const Collator::ECollationStrength &strength) const
00832 {
00833   switch (strength)
00834   {
00835   case Collator::PRIMARY :
00836     return UCOL_PRIMARY;
00837   case Collator::SECONDARY :
00838     return UCOL_SECONDARY;
00839   case Collator::TERTIARY :
00840     return UCOL_TERTIARY;
00841   case Collator::QUATERNARY :
00842     return UCOL_QUATERNARY;
00843   default :
00844     return UCOL_IDENTICAL;
00845   }
00846 }
00847 
00848 U_NAMESPACE_END
00849 
00850 #endif

Generated on Mon Mar 4 22:08:40 2002 for ICU 2.0 by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002