Update ICU to 54.1 step 1

source/i18n/stsearch.cpp

 /*
 **********************************************************************
-*   Copyright (C) 2001-2008 IBM and others. All rights reserved.
+*   Copyright (C) 2001-2014 IBM and others. All rights reserved.
 **********************************************************************
 *   Date        Name        Description
 *  03/22/2000   helena      Creation.
 **********************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION
 
 #include "unicode/stsearch.h"
 #include "usrchimp.h"
 #include "cmemory.h"
 
 U_NAMESPACE_BEGIN
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringSearch)
 
 // public constructors and destructors -----------------------------------
 
 StringSearch::StringSearch(const UnicodeString &pattern,
                            const UnicodeString &text,
                            const Locale        &locale,
                                  BreakIterator *breakiter,
                                  UErrorCode    &status) :
                            SearchIterator(text, breakiter),
-                           m_collator_(),
                            m_pattern_(pattern)
 {
     if (U_FAILURE(status)) {
         m_strsrch_ = NULL;
         return;
     }
 
     m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
                               m_text_.getBuffer(), m_text_.length(),
                               locale.getName(), (UBreakIterator *)breakiter,
                               &status);
     uprv_free(m_search_);
     m_search_ = NULL;
 
-    // !!! dlf m_collator_ is an odd beast.  basically it is an aliasing
-    // wrapper around the internal collator and rules, which (here) are
-    // owned by this stringsearch object.  this means 1) it's destructor
-    // _should not_ delete the ucollator or rules, and 2) changes made
-    // to the exposed collator (setStrength etc) _should_ modify the
-    // ucollator.  thus the collator is not a copy-on-write alias, and it
-    // needs to distinguish itself not merely from 'stand alone' colators
-    // but also from copy-on-write ones.  it needs additional state, which
-    // setUCollator should set.
-
     if (U_SUCCESS(status)) {
-        // Alias the collator
-        m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
         // m_search_ has been created by the base SearchIterator class
         m_search_        = m_strsrch_->search;
     }
 }
 
 StringSearch::StringSearch(const UnicodeString     &pattern,
                            const UnicodeString     &text,
                                  RuleBasedCollator *coll,
                                  BreakIterator     *breakiter,
                                  UErrorCode        &status) :
                            SearchIterator(text, breakiter),
-                           m_collator_(),
                            m_pattern_(pattern)
 {
     if (U_FAILURE(status)) {
         m_strsrch_ = NULL;
         return;
     }
     if (coll == NULL) {
         status     = U_ILLEGAL_ARGUMENT_ERROR;
         m_strsrch_ = NULL;
         return;
     }
     m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                           m_pattern_.length(),
                                           m_text_.getBuffer(),
-                                          m_text_.length(), coll->ucollator,
+                                          m_text_.length(), coll->toUCollator(),
                                           (UBreakIterator *)breakiter,
                                           &status);
     uprv_free(m_search_);
     m_search_ = NULL;
 
     if (U_SUCCESS(status)) {
-        // Alias the collator
-        m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
         // m_search_ has been created by the base SearchIterator class
         m_search_ = m_strsrch_->search;
     }
 }
 
 StringSearch::StringSearch(const UnicodeString     &pattern,
                                  CharacterIterator &text,
                            const Locale            &locale,
                                  BreakIterator     *breakiter,
                                  UErrorCode        &status) :
                            SearchIterator(text, breakiter),
-                           m_collator_(),
                            m_pattern_(pattern)
 {
     if (U_FAILURE(status)) {
         m_strsrch_ = NULL;
         return;
     }
     m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
                               m_text_.getBuffer(), m_text_.length(),
                               locale.getName(), (UBreakIterator *)breakiter,
                               &status);
     uprv_free(m_search_);
     m_search_ = NULL;
 
     if (U_SUCCESS(status)) {
-        // Alias the collator
-        m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
         // m_search_ has been created by the base SearchIterator class
         m_search_ = m_strsrch_->search;
     }
 }
 
 StringSearch::StringSearch(const UnicodeString     &pattern,
                                  CharacterIterator &text,
                                  RuleBasedCollator *coll,
                                  BreakIterator     *breakiter,
                                  UErrorCode        &status) :
                            SearchIterator(text, breakiter),
-                           m_collator_(),
                            m_pattern_(pattern)
 {
     if (U_FAILURE(status)) {
         m_strsrch_ = NULL;
         return;
     }
     if (coll == NULL) {
         status     = U_ILLEGAL_ARGUMENT_ERROR;
         m_strsrch_ = NULL;
         return;
     }
     m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                           m_pattern_.length(),
                                           m_text_.getBuffer(),
-                                          m_text_.length(), coll->ucollator,
+                                          m_text_.length(), coll->toUCollator(),
                                           (UBreakIterator *)breakiter,
                                           &status);
     uprv_free(m_search_);
     m_search_ = NULL;
 
     if (U_SUCCESS(status)) {
-        // Alias the collator
-        m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
         // m_search_ has been created by the base SearchIterator class
         m_search_ = m_strsrch_->search;
     }
 }
 
 StringSearch::StringSearch(const StringSearch &that) :
                        SearchIterator(that.m_text_, that.m_breakiterator_),
-                       m_collator_(),
                        m_pattern_(that.m_pattern_)
 {
     UErrorCode status = U_ZERO_ERROR;
 
     // Free m_search_ from the superclass
     uprv_free(m_search_);
     m_search_ = NULL;
 
     if (that.m_strsrch_ == NULL) {
         // This was not a good copy
         m_strsrch_ = NULL;
     }
     else {
         // Make a deep copy
         m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                               m_pattern_.length(),
                                               m_text_.getBuffer(),
                                               m_text_.length(),
                                               that.m_strsrch_->collator,
                                              (UBreakIterator *)that.m_breakiterator_,
                                               &status);
         if (U_SUCCESS(status)) {
-            // Alias the collator
-            m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
             // m_search_ has been created by the base SearchIterator class
             m_search_        = m_strsrch_->search;
         }
     }
 }
 
 StringSearch::~StringSearch()
 {
     if (m_strsrch_ != NULL) {
         usearch_close(m_strsrch_);
@@ skipping 17 matching lines @@
         // all m_search_ in the parent class is linked up with m_strsrch_
         usearch_close(m_strsrch_);
         m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                               m_pattern_.length(),
                                               m_text_.getBuffer(),
                                               m_text_.length(),
                                               that.m_strsrch_->collator,
                                               NULL, &status);
         // Check null pointer
         if (m_strsrch_ != NULL) {
-                // Alias the collator
-                m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
-                m_search_ = m_strsrch_->search;
+            m_search_ = m_strsrch_->search;
         }
     }
     return *this;
 }
 
 UBool StringSearch::operator==(const SearchIterator &that) const
 {
     if (this == &that) {
         return TRUE;
     }
@@ skipping 29 matching lines @@
 void StringSearch::setText(CharacterIterator &text, UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
         text.getText(m_text_);
         usearch_setText(m_strsrch_, m_text_.getBuffer(), m_text_.length(), &status);
     }
 }
 
 RuleBasedCollator * StringSearch::getCollator() const
 {
-    return (RuleBasedCollator *)&m_collator_;
+    // Note the const_cast. It would be cleaner if this const method returned a const collator.
+    return RuleBasedCollator::rbcFromUCollator(const_cast<UCollator *>(m_strsrch_->collator));
 }
 
 void StringSearch::setCollator(RuleBasedCollator *coll, UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
-        usearch_setCollator(m_strsrch_, coll->getUCollator(), &status);
-        // Alias the collator
-        m_collator_.setUCollator((UCollator *)m_strsrch_->collator);
+        usearch_setCollator(m_strsrch_, coll->toUCollator(), &status);
     }
 }
 
 void StringSearch::setPattern(const UnicodeString &pattern,
                                     UErrorCode    &status)
 {
     if (U_SUCCESS(status)) {
         m_pattern_ = pattern;
         usearch_setPattern(m_strsrch_, m_pattern_.getBuffer(), m_pattern_.length(),
                            &status);
     }
 }
 
 const UnicodeString & StringSearch::getPattern() const
 {
     return m_pattern_;
 }
 
 // public methods ----------------------------------------------------
 
 void StringSearch::reset()
 {
     usearch_reset(m_strsrch_);
 }
 
 SearchIterator * StringSearch::safeClone(void) const
 {
     UErrorCode status = U_ZERO_ERROR;
     StringSearch *result = new StringSearch(m_pattern_, m_text_,
-                                            (RuleBasedCollator *)&m_collator_,
+                                            getCollator(),
                                             m_breakiterator_,
                                             status);
     /* test for NULL */
     if (result == 0) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return 0;
     }
     result->setOffset(getOffset(), status);
     result->setMatchStart(m_strsrch_->search->matchedIndex);
     result->setMatchLength(m_strsrch_->search->matchedLength);
     if (U_FAILURE(status)) {
         return NULL;
     }
     return result;
 }
 
 // protected method -------------------------------------------------
 
 int32_t StringSearch::handleNext(int32_t position, UErrorCode &status)
 {
     // values passed here are already in the pre-shift position
     if (U_SUCCESS(status)) {
-        if (m_strsrch_->pattern.CELength == 0) {
+        if (m_strsrch_->pattern.cesLength == 0) {
             m_search_->matchedIndex =
                                     m_search_->matchedIndex == USEARCH_DONE ?
                                     getOffset() : m_search_->matchedIndex + 1;
             m_search_->matchedLength = 0;
             ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
                            &status);
             if (m_search_->matchedIndex == m_search_->textLength) {
                 m_search_->matchedIndex = USEARCH_DONE;
             }
         }
@@ skipping 77 matching lines @@
 #endif
         }
     }
     return USEARCH_DONE;
 }
 
 int32_t StringSearch::handlePrev(int32_t position, UErrorCode &status)
 {
     // values passed here are already in the pre-shift position
     if (U_SUCCESS(status)) {
-        if (m_strsrch_->pattern.CELength == 0) {
+        if (m_strsrch_->pattern.cesLength == 0) {
             m_search_->matchedIndex =
                   (m_search_->matchedIndex == USEARCH_DONE ? getOffset() :
                    m_search_->matchedIndex);
             if (m_search_->matchedIndex == 0) {
                 setMatchNotFound();
             }
             else {
                 m_search_->matchedIndex --;
                 ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
                                &status);
@@ skipping 53 matching lines @@
         }
 
         return m_search_->matchedIndex;
     }
     return USEARCH_DONE;
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_COLLATION */