[apple/icu.git] / icuSources / i18n / coleitr.cpp

/*
*******************************************************************************
* Copyright (C) 1996-2003, 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)

/* synwee : public can't remove */
int32_t const CollationElementIterator::NULLORDER = 0xffffffff;

/* 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) {
        return TRUE;
    }
  
    if (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 = m_data_->iteratordata_.endp -
                     m_data_->iteratordata_.string;
    int thatlength = 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 ((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 
            != that.m_data_->iteratordata_.pos 
            - that.m_data_->iteratordata_.writableBuffer) {
            // not in the same position in the normalization buffer
            return FALSE;
        }
    }
    else if ((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(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;
  }
  uprv_init_collIterate(m_data_->iteratordata_.coll, string, length, 
                   &m_data_->iteratordata_);

  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(m_data_->iteratordata_.string);
  }
  m_data_->isWritable = TRUE;
  uprv_init_collIterate(m_data_->iteratordata_.coll, buffer, length, 
                   &m_data_->iteratordata_);
  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 = 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(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) {
          uint32_t wlength = u_strlen(othercoliter->writableBuffer) + 1;
          if (wlength < coliter->writableBufSize) {
              uprv_memcpy(coliter->stackWritableBuffer, 
                        othercoliter->stackWritableBuffer, 
                        othercoliter->writableBufSize * U_SIZEOF_UCHAR);
          }
          else {
              if (coliter->writableBuffer != coliter->stackWritableBuffer) {
                  uprv_free(coliter->writableBuffer);
              }
              coliter->writableBuffer = (UChar *)uprv_malloc(
                                         wlength * U_SIZEOF_UCHAR);
              if(coliter->writableBuffer != NULL) {
                uprv_memcpy(coliter->writableBuffer, 
                            othercoliter->writableBuffer,
                            wlength * U_SIZEOF_UCHAR);
                coliter->writableBufSize = wlength;
              } else { // Error: couldn't allocate memory for writableBuffer
                coliter->writableBufSize = 0;
              }
          }
      }

      /* current position */
      if (othercoliter->pos >= othercoliter->string && 
          othercoliter->pos <= othercoliter->endp) {
          coliter->pos = coliter->string + 
                        (othercoliter->pos - othercoliter->string);
      }
      else {
        coliter->pos = coliter->writableBuffer + 
                        (othercoliter->pos - othercoliter->writableBuffer);
      }

      /* CE buffer */
      uprv_memcpy(coliter->CEs, othercoliter->CEs, 
                  UCOL_EXPAND_CE_BUFFER_SIZE * sizeof(uint32_t));
      coliter->toReturn = coliter->CEs + 
                         (othercoliter->toReturn - othercoliter->CEs);
      coliter->CEpos    = coliter->CEs + 
                         (othercoliter->CEpos - othercoliter->CEs);
    
      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 */
Commit	Line	Data
b75a7d8f A	1	/*
b75a7d8f A	2	*******************************************************************************
374ca955	3	* Copyright (C) 1996-2003, International Business Machines Corporation and *
b75a7d8f A	4	* others. All Rights Reserved. *
	5	*******************************************************************************
	6	*/
	7
	8	/*
	9	* File coleitr.cpp
	10	*
	11	*
	12	*
	13	* Created by: Helena Shih
	14	*
	15	* Modification History:
	16	*
	17	* Date Name Description
	18	*
	19	* 6/23/97 helena Adding comments to make code more readable.
	20	* 08/03/98 erm Synched with 1.2 version of CollationElementIterator.java
	21	* 12/10/99 aliu Ported Thai collation support from Java.
	22	* 01/25/01 swquek Modified to a C++ wrapper calling C APIs (ucoliter.h)
	23	* 02/19/01 swquek Removed CollationElementsIterator() since it is
	24	* private constructor and no calls are made to it
	25	*/
	26
	27	#include "unicode/utypes.h"
	28
	29	#if !UCONFIG_NO_COLLATION
	30
	31	#include "unicode/coleitr.h"
	32	#include "unicode/ustring.h"
	33	#include "ucol_imp.h"
	34	#include "cmemory.h"
	35
	36
	37	/* Constants --------------------------------------------------------------- */
	38
	39	U_NAMESPACE_BEGIN
	40
374ca955	41	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationElementIterator)
b75a7d8f A	42
	43	/* synwee : public can't remove */
	44	int32_t const CollationElementIterator::NULLORDER = 0xffffffff;
	45
	46	/* CollationElementIterator public constructor/destructor ------------------ */
	47
	48	CollationElementIterator::CollationElementIterator(
	49	const CollationElementIterator& other)
	50	: UObject(other), isDataOwned_(TRUE)
	51	{
	52	UErrorCode status = U_ZERO_ERROR;
	53	m_data_ = ucol_openElements(other.m_data_->iteratordata_.coll, NULL, 0,
	54	&status);
	55
	56	*this = other;
	57	}
	58
	59	CollationElementIterator::~CollationElementIterator()
	60	{
	61	if (isDataOwned_) {
	62	ucol_closeElements(m_data_);
	63	}
	64	}
	65
	66	/* CollationElementIterator public methods --------------------------------- */
	67
	68	int32_t CollationElementIterator::getOffset() const
	69	{
	70	return ucol_getOffset(m_data_);
	71	}
	72
	73	/**
	74	* Get the ordering priority of the next character in the string.
	75	* @return the next character's ordering. Returns NULLORDER if an error has
	76	* occured or if the end of string has been reached
	77	*/
	78	int32_t CollationElementIterator::next(UErrorCode& status)
	79	{
	80	return ucol_next(m_data_, &status);
	81	}
	82
	83	UBool CollationElementIterator::operator!=(
	84	const CollationElementIterator& other) const
	85	{
	86	return !(*this == other);
	87	}
	88
	89	UBool CollationElementIterator::operator==(
	90	const CollationElementIterator& that) const
	91	{
	92	if (this == &that) {
	93	return TRUE;
	94	}
	95
	96	if (m_data_ == that.m_data_) {
	97	return TRUE;
	98	}
	99
	100	// option comparison
374ca955	101	if (m_data_->iteratordata_.coll != that.m_data_->iteratordata_.coll)
b75a7d8f A	102	{
	103	return FALSE;
	104	}
	105
	106	// the constructor and setText always sets a length
	107	// and we only compare the string not the contents of the normalization
	108	// buffer
	109	int thislength = m_data_->iteratordata_.endp -
	110	m_data_->iteratordata_.string;
	111	int thatlength = that.m_data_->iteratordata_.endp -
	112	that.m_data_->iteratordata_.string;
	113
	114	if (thislength != thatlength) {
	115	return FALSE;
	116	}
	117
	118	if (uprv_memcmp(m_data_->iteratordata_.string,
	119	that.m_data_->iteratordata_.string,
	120	thislength * U_SIZEOF_UCHAR) != 0) {
	121	return FALSE;
	122	}
	123	if (getOffset() != that.getOffset()) {
	124	return FALSE;
	125	}
	126
	127	// checking normalization buffer
	128	if ((m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) == 0) {
	129	if ((m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) != 0) {
	130	return FALSE;
	131	}
	132	// both are in the normalization buffer
	133	if (m_data_->iteratordata_.pos
	134	- m_data_->iteratordata_.writableBuffer
	135	!= that.m_data_->iteratordata_.pos
	136	- that.m_data_->iteratordata_.writableBuffer) {
	137	// not in the same position in the normalization buffer
	138	return FALSE;
	139	}
	140	}
	141	else if ((m_data_->iteratordata_.flags & UCOL_ITER_HASLEN) == 0) {
	142	return FALSE;
	143	}
	144	// checking ce position
	145	return (m_data_->iteratordata_.CEpos - m_data_->iteratordata_.CEs)
	146	== (that.m_data_->iteratordata_.CEpos
	147	- that.m_data_->iteratordata_.CEs);
	148	}
	149
	150	/**
	151	* Get the ordering priority of the previous collation element in the string.
	152	* @param status the error code status.
	153	* @return the previous element's ordering. Returns NULLORDER if an error has
	154	* occured or if the start of string has been reached.
	155	*/
	156	int32_t CollationElementIterator::previous(UErrorCode& status)
	157	{
	158	return ucol_previous(m_data_, &status);
	159	}
	160
	161	/**
	162	* Resets the cursor to the beginning of the string.
	163	*/
	164	void CollationElementIterator::reset()
	165	{
166	ucol_reset(m_data_);
167	}
168
169	void CollationElementIterator::setOffset(int32_t newOffset,
170	UErrorCode& status)
171	{
172	ucol_setOffset(m_data_, newOffset, &status);
173	}
174
175	/**
176	* Sets the source to the new source string.
177	*/
178	void CollationElementIterator::setText(const UnicodeString& source,
179	UErrorCode& status)
180	{
181	if (U_FAILURE(status)) {
182	return;
183	}
184
185	int32_t length = source.length();
186	UChar *string = NULL;
187	if (m_data_->isWritable && m_data_->iteratordata_.string != NULL) {
188	uprv_free(m_data_->iteratordata_.string);
189	}
190	m_data_->isWritable = TRUE;
191	if (length > 0) {
192	string = (UChar )uprv_malloc(U_SIZEOF_UCHAR length);
193	/* test for NULL */
194	if (string == NULL) {
195	status = U_MEMORY_ALLOCATION_ERROR;
196	return;
197	}
198	u_memcpy(string, source.getBuffer(), length);
199	}
200	else {
201	string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
202	/* test for NULL */
203	if (string == NULL) {
204	status = U_MEMORY_ALLOCATION_ERROR;
205	return;
206	}
207	*string = 0;
208	}
209	uprv_init_collIterate(m_data_->iteratordata_.coll, string, length,
210	&m_data_->iteratordata_);
211
212	m_data_->reset_ = TRUE;
213	}
214
215	// Sets the source to the new character iterator.
216	void CollationElementIterator::setText(CharacterIterator& source,
217	UErrorCode& status)
218	{
219	if (U_FAILURE(status))
220	return;
221
222	int32_t length = source.getLength();
223	UChar *buffer = NULL;
224
225	if (length == 0) {
226	buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
227	/* test for NULL */
228	if (buffer == NULL) {
229	status = U_MEMORY_ALLOCATION_ERROR;
230	return;
231	}
232	*buffer = 0;
233	}
234	else {
235	buffer = (UChar )uprv_malloc(U_SIZEOF_UCHAR length);
236	/* test for NULL */
237	if (buffer == NULL) {
238	status = U_MEMORY_ALLOCATION_ERROR;
239	return;
240	}
241	/*
242	Using this constructor will prevent buffer from being removed when
243	string gets removed
244	*/
245	UnicodeString string;
246	source.getText(string);
247	u_memcpy(buffer, string.getBuffer(), length);
248	}
249
250	if (m_data_->isWritable && m_data_->iteratordata_.string != NULL) {
251	uprv_free(m_data_->iteratordata_.string);
252	}
253	m_data_->isWritable = TRUE;
254	uprv_init_collIterate(m_data_->iteratordata_.coll, buffer, length,
255	&m_data_->iteratordata_);
256	m_data_->reset_ = TRUE;
257	}
258
259	int32_t CollationElementIterator::strengthOrder(int32_t order) const
260	{
261	UCollationStrength s = ucol_getStrength(m_data_->iteratordata_.coll);
262	// Mask off the unwanted differences.
263	if (s == UCOL_PRIMARY) {
264	order &= RuleBasedCollator::PRIMARYDIFFERENCEONLY;
265	}
266	else if (s == UCOL_SECONDARY) {
267	order &= RuleBasedCollator::SECONDARYDIFFERENCEONLY;
268	}
269
270	return order;
271	}
272
273	/* CollationElementIterator private constructors/destructors --------------- */
274
275	/**
276	* This is the "real" constructor for this class; it constructs an iterator
277	* over the source text using the specified collator
278	*/
279	CollationElementIterator::CollationElementIterator(
280	const UnicodeString& sourceText,
281	const RuleBasedCollator* order,
282	UErrorCode& status)
283	: isDataOwned_(TRUE)
284	{
285	if (U_FAILURE(status)) {
286	return;
287	}
288
289	int32_t length = sourceText.length();
290	UChar *string = NULL;
291
292	if (length > 0) {
293	string = (UChar )uprv_malloc(U_SIZEOF_UCHAR length);
294	/* test for NULL */
295	if (string == NULL) {
296	status = U_MEMORY_ALLOCATION_ERROR;
297	return;
298	}
299	/*
300	Using this constructor will prevent buffer from being removed when
301	string gets removed
302	*/
303	u_memcpy(string, sourceText.getBuffer(), length);
304	}
305	else {
306	string = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
307	/* test for NULL */
308	if (string == NULL) {
309	status = U_MEMORY_ALLOCATION_ERROR;
310	return;
311	}
312	*string = 0;
313	}
314	m_data_ = ucol_openElements(order->ucollator, string, length, &status);
315
316	/* Test for buffer overflows */
317	if (U_FAILURE(status)) {
318	return;
319	}
320	m_data_->isWritable = TRUE;
321	}
322
323	/**
324	* This is the "real" constructor for this class; it constructs an iterator over
325	* the source text using the specified collator
326	*/
327	CollationElementIterator::CollationElementIterator(
328	const CharacterIterator& sourceText,
329	const RuleBasedCollator* order,
330	UErrorCode& status)
331	: isDataOwned_(TRUE)
332	{
333	if (U_FAILURE(status))
334	return;
335
336	// ** should I just drop this test? **
337	/*
338	if ( sourceText.endIndex() != 0 )
339	{
340	// A CollationElementIterator is really a two-layered beast.
341	// Internally it uses a Normalizer to munge the source text into a form
374ca955	342	// where all "composed" Unicode characters (such as \u00FC) are split into a
b75a7d8f A	343	// normal character and a combining accent character.
	344	// Afterward, CollationElementIterator does its own processing to handle
	345	// expanding and contracting collation sequences, ignorables, and so on.
	346
	347	Normalizer::EMode decomp = order->getStrength() == Collator::IDENTICAL
	348	? Normalizer::NO_OP : order->getDecomposition();
	349
	350	text = new Normalizer(sourceText, decomp);
	351	if (text == NULL)
	352	status = U_MEMORY_ALLOCATION_ERROR;
	353	}
	354	*/
	355	int32_t length = sourceText.getLength();
	356	UChar *buffer;
	357	if (length > 0) {
	358	buffer = (UChar )uprv_malloc(U_SIZEOF_UCHAR length);
	359	/* test for NULL */
	360	if (buffer == NULL) {
	361	status = U_MEMORY_ALLOCATION_ERROR;
	362	return;
	363	}
	364	/*
	365	Using this constructor will prevent buffer from being removed when
	366	string gets removed
	367	*/
	368	UnicodeString string(buffer, length, length);
	369	((CharacterIterator &)sourceText).getText(string);
	370	const UChar *temp = string.getBuffer();
	371	u_memcpy(buffer, temp, length);
	372	}
	373	else {
	374	buffer = (UChar *)uprv_malloc(U_SIZEOF_UCHAR);
	375	/* test for NULL */
	376	if (buffer == NULL) {
	377	status = U_MEMORY_ALLOCATION_ERROR;
	378	return;
	379	}
	380	*buffer = 0;
	381	}
	382	m_data_ = ucol_openElements(order->ucollator, buffer, length, &status);
	383
	384	/* Test for buffer overflows */
	385	if (U_FAILURE(status)) {
	386	return;
	387	}
	388	m_data_->isWritable = TRUE;
	389	}
	390
	391	/* CollationElementIterator protected methods ----------------------------- */
	392
	393	const CollationElementIterator& CollationElementIterator::operator=(
	394	const CollationElementIterator& other)
	395	{
	396	if (this != &other)
	397	{
	398	UCollationElements *ucolelem = this->m_data_;
	399	UCollationElements *otherucolelem = other.m_data_;
	400	collIterate *coliter = &(ucolelem->iteratordata_);
	401	collIterate *othercoliter = &(otherucolelem->iteratordata_);
	402	int length = 0;
	403
	404	// checking only UCOL_ITER_HASLEN is not enough here as we may be in
	405	// the normalization buffer
	406	length = othercoliter->endp - othercoliter->string;
407
408	ucolelem->reset_ = otherucolelem->reset_;
409	ucolelem->isWritable = TRUE;
410
411	/* create a duplicate of string */
412	if (length > 0) {
413	coliter->string = (UChar )uprv_malloc(length U_SIZEOF_UCHAR);
414	if(coliter->string != NULL) {
415	uprv_memcpy(coliter->string, othercoliter->string,
416	length * U_SIZEOF_UCHAR);
417	} else { // Error: couldn't allocate memory. No copying should be done
418	length = 0;
419	}
420	}
421	else {
422	coliter->string = NULL;
423	}
424
425	/* start and end of string */
426	coliter->endp = coliter->string + length;
427
428	/* handle writable buffer here */
429
430	if (othercoliter->flags & UCOL_ITER_INNORMBUF) {
431	uint32_t wlength = u_strlen(othercoliter->writableBuffer) + 1;
432	if (wlength < coliter->writableBufSize) {
433	uprv_memcpy(coliter->stackWritableBuffer,
434	othercoliter->stackWritableBuffer,
435	othercoliter->writableBufSize * U_SIZEOF_UCHAR);
436	}
437	else {
438	if (coliter->writableBuffer != coliter->stackWritableBuffer) {
439	uprv_free(coliter->writableBuffer);
440	}
441	coliter->writableBuffer = (UChar *)uprv_malloc(
442	wlength * U_SIZEOF_UCHAR);
443	if(coliter->writableBuffer != NULL) {
444	uprv_memcpy(coliter->writableBuffer,
445	othercoliter->writableBuffer,
446	wlength * U_SIZEOF_UCHAR);
447	coliter->writableBufSize = wlength;
448	} else { // Error: couldn't allocate memory for writableBuffer
449	coliter->writableBufSize = 0;
450	}
451	}
452	}
453
454	/* current position */
455	if (othercoliter->pos >= othercoliter->string &&
456	othercoliter->pos <= othercoliter->endp) {
457	coliter->pos = coliter->string +
458	(othercoliter->pos - othercoliter->string);
459	}
460	else {
461	coliter->pos = coliter->writableBuffer +
462	(othercoliter->pos - othercoliter->writableBuffer);
463	}
464
465	/* CE buffer */
466	uprv_memcpy(coliter->CEs, othercoliter->CEs,
467	UCOL_EXPAND_CE_BUFFER_SIZE * sizeof(uint32_t));
468	coliter->toReturn = coliter->CEs +
469	(othercoliter->toReturn - othercoliter->CEs);
470	coliter->CEpos = coliter->CEs +
471	(othercoliter->CEpos - othercoliter->CEs);
472
473	if (othercoliter->fcdPosition != NULL) {
474	coliter->fcdPosition = coliter->string +
475	(othercoliter->fcdPosition
476	- othercoliter->string);
477	}
478	else {
479	coliter->fcdPosition = NULL;
480	}
481	coliter->flags = othercoliter->flags/\| UCOL_ITER_HASLEN/;
482	coliter->origFlags = othercoliter->origFlags;
483	coliter->coll = othercoliter->coll;
484	this->isDataOwned_ = TRUE;
485	}
486
487	return *this;
488	}
489
490	U_NAMESPACE_END
491
492	#endif /* #if !UCONFIG_NO_COLLATION */
493
494	/* eof */