ICU-400.37.tar.gz

[apple/icu.git] / icuSources / common / ubrk.cpp

diff --git a/icuSources/common/ubrk.cpp b/icuSources/common/ubrk.cpp
index 710fd980eb71dc9916da30f4b8c75c85605c1bd4..944708ab8db56cba54c31df2552377b529159f6b 100644 (file)
--- a/icuSources/common/ubrk.cpp
+++ b/icuSources/common/ubrk.cpp
@@ -1,8 +1,8 @@
 /*
-*****************************************************************************************
-*   Copyright (C) 1996-2004, International Business Machines
+********************************************************************************
+*   Copyright (C) 1996-2008, International Business Machines
 *   Corporation and others.  All Rights Reserved.
-*****************************************************************************************
+********************************************************************************
 */
 
 #include "unicode/utypes.h"
@@ -17,15 +17,16 @@
 #include "unicode/uchriter.h"
 #include "unicode/rbbi.h"
 #include "rbbirb.h"
+#include "uassert.h"
 
 U_NAMESPACE_USE
 
-//----------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 //
 //    ubrk_open      Create a canned type of break iterator based on type (word, line, etc.)
 //                   and locale.
 //
-//----------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 U_CAPI UBreakIterator* U_EXPORT2
 ubrk_open(UBreakIteratorType type,
       const char *locale,
@@ -59,6 +60,9 @@ ubrk_open(UBreakIteratorType type,
   case UBRK_TITLE:
     result = BreakIterator::createTitleInstance(Locale(locale), *status);
     break;
+
+  default:
+    *status = U_ILLEGAL_ARGUMENT_ERROR;
   }
 
   // check for allocation error
@@ -70,26 +74,22 @@ ubrk_open(UBreakIteratorType type,
     return 0;
   }
 
-  UCharCharacterIterator *iter = 0;
-  iter = new UCharCharacterIterator(text, textLength);
-  if(iter == 0) {
-    *status = U_MEMORY_ALLOCATION_ERROR;
-    delete result;
-    return 0;
-  }
-  result->adoptText(iter);
 
-  return (UBreakIterator*)result;
+  UBreakIterator *uBI = (UBreakIterator *)result;
+  if (text != NULL) {
+      ubrk_setText(uBI, text, textLength, status);
+  }
+  return uBI;
 }
 
 
 
-//----------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 //
 //   ubrk_openRules      open a break iterator from a set of break rules.
 //                       Invokes the rule builder.
 //
-//----------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 U_CAPI UBreakIterator* U_EXPORT2
 ubrk_openRules(  const UChar        *rules,
                        int32_t       rulesLength,
@@ -104,22 +104,16 @@ ubrk_openRules(  const UChar        *rules,
 
     BreakIterator *result = 0;
     UnicodeString ruleString(rules, rulesLength);
-    result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, *parseErr, *status);
+    result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, parseErr, *status);
     if(U_FAILURE(*status)) {
         return 0;
     }
 
+    UBreakIterator *uBI = (UBreakIterator *)result;
     if (text != NULL) {
-        UCharCharacterIterator *iter = 0;
-        iter = new UCharCharacterIterator(text, textLength);
-        if(iter == 0) {
-            *status = U_MEMORY_ALLOCATION_ERROR;
-            delete result;
-            return 0;
-        }
-        result->adoptText(iter);
+        ubrk_setText(uBI, text, textLength, status);
     }
-    return (UBreakIterator *)result;
+    return uBI;
 }
 
 
@@ -140,6 +134,12 @@ ubrk_safeClone(
        *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
+    // Clear any incoming Safe Clone Allocated warning.
+    //  Propagating this through to our return would really
+    //  confuse our caller.
+    if (*status==U_SAFECLONE_ALLOCATED_WARNING) {
+        *status = U_ZERO_ERROR;
+    }
     return (UBreakIterator *)(((BreakIterator*)bi)->
         createBufferClone(stackBuffer, *pBufferSize, *status));
 }
@@ -166,59 +166,62 @@ ubrk_setText(UBreakIterator* bi,
              int32_t         textLength,
              UErrorCode*     status)
 {
+    BreakIterator *brit = (BreakIterator *)bi;
+    UText  ut = UTEXT_INITIALIZER;
+    utext_openUChars(&ut, text, textLength, status);
+    brit->setText(&ut, *status);
+    // A stack allocated UText wrapping a UCHar * string
+    //   can be dumped without explicitly closing it.
+}
 
-  if (U_FAILURE(*status)) return;
 
-  const CharacterIterator& biText = ((BreakIterator*)bi)->getText();
 
-  int32_t textLen = (textLength == -1 ? u_strlen(text) : textLength);
-  if (biText.getDynamicClassID() == UCharCharacterIterator::getStaticClassID()) {
-      ((UCharCharacterIterator&)biText).setText(text, textLen);
-  }
-  else {
-      UCharCharacterIterator *iter = 0;
-      iter = new UCharCharacterIterator(text, textLen);
-      if(iter == 0) {
-        *status = U_MEMORY_ALLOCATION_ERROR;
-        return;
-      }
-      ((BreakIterator*)bi)->adoptText(iter);
-  }
+U_CAPI void U_EXPORT2
+ubrk_setUText(UBreakIterator *bi,
+             UText          *text,
+             UErrorCode     *status)
+{
+    RuleBasedBreakIterator *brit = (RuleBasedBreakIterator *)bi;
+    brit->RuleBasedBreakIterator::setText(text, *status);
 }
 
+
+
+
+
 U_CAPI int32_t U_EXPORT2
 ubrk_current(const UBreakIterator *bi)
 {
 
-  return ((BreakIterator*)bi)->current();
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::current();
 }
 
 U_CAPI int32_t U_EXPORT2
 ubrk_next(UBreakIterator *bi)
 {
 
-  return ((BreakIterator*)bi)->next();
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::next();
 }
 
 U_CAPI int32_t U_EXPORT2
 ubrk_previous(UBreakIterator *bi)
 {
 
-  return ((BreakIterator*)bi)->previous();
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::previous();
 }
 
 U_CAPI int32_t U_EXPORT2
 ubrk_first(UBreakIterator *bi)
 {
 
-  return ((BreakIterator*)bi)->first();
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::first();
 }
 
 U_CAPI int32_t U_EXPORT2
 ubrk_last(UBreakIterator *bi)
 {
 
-  return ((BreakIterator*)bi)->last();
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::last();
 }
 
 U_CAPI int32_t U_EXPORT2
@@ -226,7 +229,7 @@ ubrk_preceding(UBreakIterator *bi,
            int32_t offset)
 {
 
-  return ((BreakIterator*)bi)->preceding(offset);
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::preceding(offset);
 }
 
 U_CAPI int32_t U_EXPORT2
@@ -234,7 +237,7 @@ ubrk_following(UBreakIterator *bi,
            int32_t offset)
 {
 
-  return ((BreakIterator*)bi)->following(offset);
+  return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::following(offset);
 }
 
 U_CAPI const char* U_EXPORT2
@@ -255,26 +258,26 @@ ubrk_countAvailable()
 U_CAPI  UBool U_EXPORT2
 ubrk_isBoundary(UBreakIterator *bi, int32_t offset)
 {
-    return ((BreakIterator *)bi)->isBoundary(offset);
+    return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::isBoundary(offset);
 }
 
 
 U_CAPI  int32_t U_EXPORT2
 ubrk_getRuleStatus(UBreakIterator *bi)
 {
-    return ((RuleBasedBreakIterator *)bi)->getRuleStatus();
+    return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatus();
 }
 
 U_CAPI  int32_t U_EXPORT2
 ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status)
 {
-    return ((RuleBasedBreakIterator *)bi)->getRuleStatusVec(fillInVec, capacity, *status);
+    return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatusVec(fillInVec, capacity, *status);
 }
 
 
 U_CAPI const char* U_EXPORT2
-ubrk_getLocaleByType(const UBreakIterator *bi, 
-                     ULocDataLocaleType type, 
+ubrk_getLocaleByType(const UBreakIterator *bi,
+                     ULocDataLocaleType type,
                      UErrorCode* status)
 {
     if (bi == NULL) {