Check in the pristine copy of ICU 4.6...

icu46/source/i18n/coleitr.cpp

+/*
+*******************************************************************************
+* Copyright (C) 1996-2010, International Business Machines Corporation and    *
+* others. All Rights Reserved.                                                *
+*******************************************************************************
+*/
+
+/*
+* File coleitr.cpp
+*
+* 
+*
+* Created by: Helena Shih
+*
+* Modification History:
+*
+*  Date      Name        Description
+*
+*  6/23/97   helena      Adding comments to make code more readable.
+* 08/03/98   erm         Synched with 1.2 version of CollationElementIterator.java
+* 12/10/99   aliu        Ported Thai collation support from Java.
+* 01/25/01   swquek      Modified to a C++ wrapper calling C APIs (ucoliter.h)
+* 02/19/01   swquek      Removed CollationElementsIterator() since it is 
+*                        private constructor and no calls are made to it
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_COLLATION
+
+#include "unicode/coleitr.h"
+#include "unicode/ustring.h"
+#include "ucol_imp.h"
+#include "cmemory.h"
+
+
+/* Constants --------------------------------------------------------------- */
+
+U_NAMESPACE_BEGIN
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationElementIterator)
+
+/* CollationElementIterator public constructor/destructor ------------------ */
+
+CollationElementIterator::CollationElementIterator(
+                                         const CollationElementIterator& other) 
+                                         : UObject(other), isDataOwned_(TRUE)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    m_data_ = ucol_openElements(other.m_data_->iteratordata_.coll, NULL, 0, 
+                                &status);
+
+    *this = other;
+}
+
+CollationElementIterator::~CollationElementIterator()
+{
+    if (isDataOwned_) {
+        ucol_closeElements(m_data_);
+    }
+}
+
+/* CollationElementIterator public methods --------------------------------- */
+
+int32_t CollationElementIterator::getOffset() const
+{
+    return ucol_getOffset(m_data_);
+}
+
+/**
+* Get the ordering priority of the next character in the string.
+* @return the next character's ordering. Returns NULLORDER if an error has 
+*         occured or if the end of string has been reached
+*/
+int32_t CollationElementIterator::next(UErrorCode& status)
+{
+    return ucol_next(m_data_, &status);
+}
+
+UBool CollationElementIterator::operator!=(
+                                  const CollationElementIterator& other) const
+{
+    return !(*this == other);
+}
+
+UBool CollationElementIterator::operator==(
+                                    const CollationElementIterator& that) const
+{
+    if (this == &that || m_data_ == that.m_data_) {
+        return TRUE;
+    }
+
+    // option comparison
+    if (m_data_->iteratordata_.coll != that.m_data_->iteratordata_.coll)
+    {
+        return FALSE;
+    }
+
+    // the constructor and setText always sets a length
+    // and we only compare the string not the contents of the normalization
+    // buffer
+    int thislength = (int)(m_data_->iteratordata_.endp - m_data_->iteratordata_.string);
+    int thatlength = (int)(that.m_data_->iteratordata_.endp - that.m_data_->iteratordata_.string);
+    
+    if (thislength != thatlength) {
+        return FALSE;
+    }
+
+    if (uprv_memcmp(m_data_->iteratordata_.string, 
+                    that.m_data_->iteratordata_.string, 
+                    thislength * U_SIZEOF_UCHAR) != 0) {
+        return FALSE;
+    }
+    if (getOffset() != that.getOffset()) {
+        return FALSE;
+    }
+
+    // checking normalization buffer
+    if ((m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) == 0) {
+        if ((that.m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) != 0) {
+            return FALSE;
+        }
+        // both are in the normalization buffer
+        if (m_data_->iteratordata_.pos 
+            - m_data_->iteratordata_.writableBuffer.getBuffer()
+            != that.m_data_->iteratordata_.pos 
+            - that.m_data_->iteratordata_.writableBuffer.getBuffer()) {
+            // not in the same position in the normalization buffer
+            return FALSE;
+        }
+    }
+    else if ((that.m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) == 0) {
+        return FALSE;
+    }
+    // checking ce position
+    return (m_data_->iteratordata_.CEpos - m_data_->iteratordata_.CEs)
+            == (that.m_data_->iteratordata_.CEpos 
+                                        - that.m_data_->iteratordata_.CEs);
+}
+
+/**
+* Get the ordering priority of the previous collation element in the string.
+* @param status the error code status.
+* @return the previous element's ordering. Returns NULLORDER if an error has 
+*         occured or if the start of string has been reached.
+*/
+int32_t CollationElementIterator::previous(UErrorCode& status)
+{
+    return ucol_previous(m_data_, &status);
+}
+
+/**
+* Resets the cursor to the beginning of the string.
+*/
+void CollationElementIterator::reset()
+{
+    ucol_reset(m_data_);
+}
+
+void CollationElementIterator::setOffset(int32_t newOffset, 
+                                         UErrorCode& status)
+{
+    ucol_setOffset(m_data_, newOffset, &status);
+}
+
+/**
+* Sets the source to the new source string.
+*/
+void CollationElementIterator::setText(const UnicodeString& source,
+                                       UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    int32_t length = source.length();
+    UChar *string = NULL;
+    if (m_data_->isWritable && m_data_->iteratordata_.string != NULL) {
+        uprv_free((UChar *)m_data_->iteratordata_.string);
+    }
+    m_data_->isWritable = TRUE;
+    if (length > 0) {
+        string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR * length);
+        /* test for NULL */
+        if (string == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        u_memcpy(string, source.getBuffer(), length);
+    }
+    else {
+        string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
+        /* test for NULL */
+        if (string == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        *string = 0;
+    }
+    /* Free offsetBuffer before initializing it. */
+    ucol_freeOffsetBuffer(&(m_data_->iteratordata_));
+    uprv_init_collIterate(m_data_->iteratordata_.coll, string, length, 
+        &m_data_->iteratordata_, &status);
+
+    m_data_->reset_   = TRUE;
+}
+
+// Sets the source to the new character iterator.
+void CollationElementIterator::setText(CharacterIterator& source, 
+                                       UErrorCode& status)
+{
+    if (U_FAILURE(status)) 
+        return;
+
+    int32_t length = source.getLength();
+    UChar *buffer = NULL;
+
+    if (length == 0) {
+        buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
+        /* test for NULL */
+        if (buffer == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        *buffer = 0;
+    }
+    else {
+        buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR * length);
+        /* test for NULL */
+        if (buffer == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        /* 
+        Using this constructor will prevent buffer from being removed when
+        string gets removed
+        */
+        UnicodeString string;
+        source.getText(string);
+        u_memcpy(buffer, string.getBuffer(), length);
+    }
+
+    if (m_data_->isWritable && m_data_->iteratordata_.string != NULL) {
+        uprv_free((UChar *)m_data_->iteratordata_.string);
+    }
+    m_data_->isWritable = TRUE;
+    /* Free offsetBuffer before initializing it. */
+    ucol_freeOffsetBuffer(&(m_data_->iteratordata_));
+    uprv_init_collIterate(m_data_->iteratordata_.coll, buffer, length, 
+        &m_data_->iteratordata_, &status);
+    m_data_->reset_   = TRUE;
+}
+
+int32_t CollationElementIterator::strengthOrder(int32_t order) const
+{
+    UCollationStrength s = ucol_getStrength(m_data_->iteratordata_.coll);
+    // Mask off the unwanted differences.
+    if (s == UCOL_PRIMARY) {
+        order &= RuleBasedCollator::PRIMARYDIFFERENCEONLY;
+    }
+    else if (s == UCOL_SECONDARY) {
+        order &= RuleBasedCollator::SECONDARYDIFFERENCEONLY;
+    }
+
+    return order;
+}
+
+/* CollationElementIterator private constructors/destructors --------------- */
+
+/** 
+* This is the "real" constructor for this class; it constructs an iterator
+* over the source text using the specified collator
+*/
+CollationElementIterator::CollationElementIterator(
+                                               const UnicodeString& sourceText,
+                                               const RuleBasedCollator* order,
+                                               UErrorCode& status)
+                                               : isDataOwned_(TRUE)
+{
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    int32_t length = sourceText.length();
+    UChar *string = NULL;
+
+    if (length > 0) {
+        string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR * length);
+        /* test for NULL */
+        if (string == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        /* 
+        Using this constructor will prevent buffer from being removed when
+        string gets removed
+        */
+        u_memcpy(string, sourceText.getBuffer(), length);
+    }
+    else {
+        string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
+        /* test for NULL */
+        if (string == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        *string = 0;
+    }
+    m_data_ = ucol_openElements(order->ucollator, string, length, &status);
+
+    /* Test for buffer overflows */
+    if (U_FAILURE(status)) {
+        return;
+    }
+    m_data_->isWritable = TRUE;
+}
+
+/** 
+* This is the "real" constructor for this class; it constructs an iterator over 
+* the source text using the specified collator
+*/
+CollationElementIterator::CollationElementIterator(
+                                           const CharacterIterator& sourceText,
+                                           const RuleBasedCollator* order,
+                                           UErrorCode& status)
+                                           : isDataOwned_(TRUE)
+{
+    if (U_FAILURE(status))
+        return;
+
+    // **** should I just drop this test? ****
+    /*
+    if ( sourceText.endIndex() != 0 )
+    {
+        // A CollationElementIterator is really a two-layered beast.
+        // Internally it uses a Normalizer to munge the source text into a form 
+        // where all "composed" Unicode characters (such as \u00FC) are split into a 
+        // normal character and a combining accent character.  
+        // Afterward, CollationElementIterator does its own processing to handle
+        // expanding and contracting collation sequences, ignorables, and so on.
+        
+        Normalizer::EMode decomp = order->getStrength() == Collator::IDENTICAL
+                                ? Normalizer::NO_OP : order->getDecomposition();
+          
+        text = new Normalizer(sourceText, decomp);
+        if (text == NULL)
+        status = U_MEMORY_ALLOCATION_ERROR;    
+    }
+    */
+    int32_t length = sourceText.getLength();
+    UChar *buffer;
+    if (length > 0) {
+        buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR * length);
+        /* test for NULL */
+        if (buffer == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        /* 
+        Using this constructor will prevent buffer from being removed when
+        string gets removed
+        */
+        UnicodeString string(buffer, length, length);
+        ((CharacterIterator &)sourceText).getText(string);
+        const UChar *temp = string.getBuffer();
+        u_memcpy(buffer, temp, length);
+    }
+    else {
+        buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
+        /* test for NULL */
+        if (buffer == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        *buffer = 0;
+    }
+    m_data_ = ucol_openElements(order->ucollator, buffer, length, &status);
+
+    /* Test for buffer overflows */
+    if (U_FAILURE(status)) {
+        return;
+    }
+    m_data_->isWritable = TRUE;
+}
+
+/* CollationElementIterator protected methods ----------------------------- */
+
+const CollationElementIterator& CollationElementIterator::operator=(
+                                         const CollationElementIterator& other)
+{
+    if (this != &other)
+    {
+        UCollationElements *ucolelem      = this->m_data_;
+        UCollationElements *otherucolelem = other.m_data_;
+        collIterate        *coliter       = &(ucolelem->iteratordata_);
+        collIterate        *othercoliter  = &(otherucolelem->iteratordata_);
+        int                length         = 0;
+
+        // checking only UCOL_ITER_HASLEN is not enough here as we may be in 
+        // the normalization buffer
+        length = (int)(othercoliter->endp - othercoliter->string);
+
+        ucolelem->reset_         = otherucolelem->reset_;
+        ucolelem->isWritable     = TRUE;
+
+        /* create a duplicate of string */
+        if (length > 0) {
+            coliter->string = (UChar *)uprv_malloc(length * U_SIZEOF_UCHAR);
+            if(coliter->string != NULL) {
+                uprv_memcpy((UChar *)coliter->string, othercoliter->string,
+                    length * U_SIZEOF_UCHAR);
+            } else { // Error: couldn't allocate memory. No copying should be done
+                length = 0;
+            }
+        }
+        else {
+            coliter->string = NULL;
+        }
+
+        /* start and end of string */
+        coliter->endp = coliter->string + length;
+
+        /* handle writable buffer here */
+
+        if (othercoliter->flags & UCOL_ITER_INNORMBUF) {
+            coliter->writableBuffer = othercoliter->writableBuffer;
+            coliter->writableBuffer.getTerminatedBuffer();
+        }
+
+        /* current position */
+        if (othercoliter->pos >= othercoliter->string && 
+            othercoliter->pos <= othercoliter->endp)
+        {
+            coliter->pos = coliter->string + 
+                (othercoliter->pos - othercoliter->string);
+        }
+        else {
+            coliter->pos = coliter->writableBuffer.getTerminatedBuffer() + 
+                (othercoliter->pos - othercoliter->writableBuffer.getBuffer());
+        }
+
+        /* CE buffer */
+        int32_t CEsize;
+        if (coliter->extendCEs) {
+            uprv_memcpy(coliter->CEs, othercoliter->CEs, sizeof(uint32_t) * UCOL_EXPAND_CE_BUFFER_SIZE);
+            CEsize = sizeof(othercoliter->extendCEs);
+            if (CEsize > 0) {
+                othercoliter->extendCEs = (uint32_t *)uprv_malloc(CEsize);
+                uprv_memcpy(coliter->extendCEs, othercoliter->extendCEs, CEsize);
+            }
+            coliter->toReturn = coliter->extendCEs + 
+                (othercoliter->toReturn - othercoliter->extendCEs);
+            coliter->CEpos    = coliter->extendCEs + CEsize;
+        } else {
+            CEsize = (int32_t)(othercoliter->CEpos - othercoliter->CEs);
+            if (CEsize > 0) {
+                uprv_memcpy(coliter->CEs, othercoliter->CEs, CEsize);
+            }
+            coliter->toReturn = coliter->CEs + 
+                (othercoliter->toReturn - othercoliter->CEs);
+            coliter->CEpos    = coliter->CEs + CEsize;
+        }
+
+        if (othercoliter->fcdPosition != NULL) {
+            coliter->fcdPosition = coliter->string + 
+                (othercoliter->fcdPosition 
+                - othercoliter->string);
+        }
+        else {
+            coliter->fcdPosition = NULL;
+        }
+        coliter->flags       = othercoliter->flags/*| UCOL_ITER_HASLEN*/;
+        coliter->origFlags   = othercoliter->origFlags;
+        coliter->coll = othercoliter->coll;
+        this->isDataOwned_ = TRUE;
+    }
+
+    return *this;
+}
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_COLLATION */
+
+/* eof */