icuSources/common/ubrk.cpp

   1 /*
   2 *****************************************************************************************
   3 *   Copyright (C) 1996-2004, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *****************************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_BREAK_ITERATION
  11
  12 #include "unicode/ubrk.h"
  13
  14 #include "unicode/brkiter.h"
  15 #include "unicode/uloc.h"
  16 #include "unicode/ustring.h"
  17 #include "unicode/uchriter.h"
  18 #include "unicode/rbbi.h"
  19 #include "rbbirb.h"
  20
  21 U_NAMESPACE_USE
  22
  23 //----------------------------------------------------------------------------------------
  24 //
  25 //    ubrk_open      Create a canned type of break iterator based on type (word, line, etc.)
  26 //                   and locale.
  27 //
  28 //----------------------------------------------------------------------------------------
  29 U_CAPI UBreakIterator* U_EXPORT2
  30 ubrk_open(UBreakIteratorType type,
  31       const char *locale,
  32       const UChar *text,
  33       int32_t textLength,
  34       UErrorCode *status)
  35 {
  36
  37   if(U_FAILURE(*status)) return 0;
  38
  39   BreakIterator *result = 0;
  40
  41   switch(type) {
  42
  43   case UBRK_CHARACTER:
  44     result = BreakIterator::createCharacterInstance(Locale(locale), *status);
  45     break;
  46
  47   case UBRK_WORD:
  48     result = BreakIterator::createWordInstance(Locale(locale), *status);
  49     break;
  50
  51   case UBRK_LINE:
  52     result = BreakIterator::createLineInstance(Locale(locale), *status);
  53     break;
  54
  55   case UBRK_SENTENCE:
  56     result = BreakIterator::createSentenceInstance(Locale(locale), *status);
  57     break;
  58
  59   case UBRK_TITLE:
  60     result = BreakIterator::createTitleInstance(Locale(locale), *status);
  61     break;
  62   }
  63
  64   // check for allocation error
  65   if (U_FAILURE(*status)) {
  66      return 0;
  67   }
  68   if(result == 0) {
  69     *status = U_MEMORY_ALLOCATION_ERROR;
  70     return 0;
  71   }
  72
  73   UCharCharacterIterator *iter = 0;
  74   iter = new UCharCharacterIterator(text, textLength);
  75   if(iter == 0) {
  76     *status = U_MEMORY_ALLOCATION_ERROR;
  77     delete result;
  78     return 0;
  79   }
  80   result->adoptText(iter);
  81
  82   return (UBreakIterator*)result;
  83 }
  84
  85
  86
  87 //----------------------------------------------------------------------------------------
  88 //
  89 //   ubrk_openRules      open a break iterator from a set of break rules.
  90 //                       Invokes the rule builder.
  91 //
  92 //----------------------------------------------------------------------------------------
  93 U_CAPI UBreakIterator* U_EXPORT2
  94 ubrk_openRules(  const UChar        *rules,
  95                        int32_t       rulesLength,
  96                  const UChar        *text,
  97                        int32_t       textLength,
  98                        UParseError  *parseErr,
  99                        UErrorCode   *status)  {
 100
 101     if (status == NULL || U_FAILURE(*status)){
 102         return 0;
 103     }
 104
 105     BreakIterator *result = 0;
 106     UnicodeString ruleString(rules, rulesLength);
 107     result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, *parseErr, *status);
 108     if(U_FAILURE(*status)) {
 109         return 0;
 110     }
 111
 112     if (text != NULL) {
 113         UCharCharacterIterator *iter = 0;
 114         iter = new UCharCharacterIterator(text, textLength);
 115         if(iter == 0) {
 116             *status = U_MEMORY_ALLOCATION_ERROR;
 117             delete result;
 118             return 0;
 119         }
 120         result->adoptText(iter);
 121     }
 122     return (UBreakIterator *)result;
 123 }
 124
 125
 126
 127
 128
 129 U_CAPI UBreakIterator * U_EXPORT2
 130 ubrk_safeClone(
 131           const UBreakIterator *bi,
 132           void *stackBuffer,
 133           int32_t *pBufferSize,
 134           UErrorCode *status)
 135 {
 136     if (status == NULL || U_FAILURE(*status)){
 137         return 0;
 138     }
 139     if (!pBufferSize || !bi){
 140        *status = U_ILLEGAL_ARGUMENT_ERROR;
 141         return 0;
 142     }
 143     return (UBreakIterator *)(((BreakIterator*)bi)->
 144         createBufferClone(stackBuffer, *pBufferSize, *status));
 145 }
 146
 147
 148
 149 U_CAPI void U_EXPORT2
 150 ubrk_close(UBreakIterator *bi)
 151 {
 152     BreakIterator *ubi = (BreakIterator*) bi;
 153     if (ubi) {
 154         if (ubi->isBufferClone()) {
 155             ubi->~BreakIterator();
 156             *(uint32_t *)ubi = 0xdeadbeef;
 157         } else {
 158             delete ubi;
 159         }
 160     }
 161 }
 162
 163 U_CAPI void U_EXPORT2
 164 ubrk_setText(UBreakIterator* bi,
 165              const UChar*    text,
 166              int32_t         textLength,
 167              UErrorCode*     status)
 168 {
 169
 170   if (U_FAILURE(*status)) return;
 171
 172   const CharacterIterator& biText = ((BreakIterator*)bi)->getText();
 173
 174   int32_t textLen = (textLength == -1 ? u_strlen(text) : textLength);
 175   if (biText.getDynamicClassID() == UCharCharacterIterator::getStaticClassID()) {
 176       ((UCharCharacterIterator&)biText).setText(text, textLen);
 177   }
 178   else {
 179       UCharCharacterIterator *iter = 0;
 180       iter = new UCharCharacterIterator(text, textLen);
 181       if(iter == 0) {
 182         *status = U_MEMORY_ALLOCATION_ERROR;
 183         return;
 184       }
 185       ((BreakIterator*)bi)->adoptText(iter);
 186   }
 187 }
 188
 189 U_CAPI int32_t U_EXPORT2
 190 ubrk_current(const UBreakIterator *bi)
 191 {
 192
 193   return ((BreakIterator*)bi)->current();
 194 }
 195
 196 U_CAPI int32_t U_EXPORT2
 197 ubrk_next(UBreakIterator *bi)
 198 {
 199
 200   return ((BreakIterator*)bi)->next();
 201 }
 202
 203 U_CAPI int32_t U_EXPORT2
 204 ubrk_previous(UBreakIterator *bi)
 205 {
 206
 207   return ((BreakIterator*)bi)->previous();
 208 }
 209
 210 U_CAPI int32_t U_EXPORT2
 211 ubrk_first(UBreakIterator *bi)
 212 {
 213
 214   return ((BreakIterator*)bi)->first();
 215 }
 216
 217 U_CAPI int32_t U_EXPORT2
 218 ubrk_last(UBreakIterator *bi)
 219 {
 220
 221   return ((BreakIterator*)bi)->last();
 222 }
 223
 224 U_CAPI int32_t U_EXPORT2
 225 ubrk_preceding(UBreakIterator *bi,
 226            int32_t offset)
 227 {
 228
 229   return ((BreakIterator*)bi)->preceding(offset);
 230 }
 231
 232 U_CAPI int32_t U_EXPORT2
 233 ubrk_following(UBreakIterator *bi,
 234            int32_t offset)
 235 {
 236
 237   return ((BreakIterator*)bi)->following(offset);
 238 }
 239
 240 U_CAPI const char* U_EXPORT2
 241 ubrk_getAvailable(int32_t index)
 242 {
 243
 244   return uloc_getAvailable(index);
 245 }
 246
 247 U_CAPI int32_t U_EXPORT2
 248 ubrk_countAvailable()
 249 {
 250
 251   return uloc_countAvailable();
 252 }
 253
 254
 255 U_CAPI  UBool U_EXPORT2
 256 ubrk_isBoundary(UBreakIterator *bi, int32_t offset)
 257 {
 258     return ((BreakIterator *)bi)->isBoundary(offset);
 259 }
 260
 261
 262 U_CAPI  int32_t U_EXPORT2
 263 ubrk_getRuleStatus(UBreakIterator *bi)
 264 {
 265     return ((RuleBasedBreakIterator *)bi)->getRuleStatus();
 266 }
 267
 268 U_CAPI  int32_t U_EXPORT2
 269 ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status)
 270 {
 271     return ((RuleBasedBreakIterator *)bi)->getRuleStatusVec(fillInVec, capacity, *status);
 272 }
 273
 274
 275 U_CAPI const char* U_EXPORT2
 276 ubrk_getLocaleByType(const UBreakIterator *bi,
 277                      ULocDataLocaleType type,
 278                      UErrorCode* status)
 279 {
 280     if (bi == NULL) {
 281         if (U_SUCCESS(*status)) {
 282             *status = U_ILLEGAL_ARGUMENT_ERROR;
 283         }
 284         return NULL;
 285     }
 286     return ((BreakIterator*)bi)->getLocaleID(type, *status);
 287 }
 288
 289
 290 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */