1/* 2******************************************************************************* 3* Copyright (C) 1997-2011, International Business Machines Corporation and 4* others. All Rights Reserved. 5******************************************************************************* 6* 7* File TXTBDRY.CPP 8* 9* Modification History: 10* 11* Date Name Description 12* 02/18/97 aliu Converted from OpenClass. Added DONE. 13* 01/13/2000 helena Added UErrorCode parameter to createXXXInstance methods. 14***************************************************************************************** 15*/ 16 17// ***************************************************************************** 18// This file was generated from the java source file BreakIterator.java 19// ***************************************************************************** 20 21#include "unicode/utypes.h" 22 23#if !UCONFIG_NO_BREAK_ITERATION 24 25#include "unicode/rbbi.h" 26#include "unicode/brkiter.h" 27#include "unicode/udata.h" 28#include "unicode/ures.h" 29#include "unicode/ustring.h" 30#include "ucln_cmn.h" 31#include "cstring.h" 32#include "umutex.h" 33#include "servloc.h" 34#include "locbased.h" 35#include "uresimp.h" 36#include "uassert.h" 37#include "ubrkimpl.h" 38 39// ***************************************************************************** 40// class BreakIterator 41// This class implements methods for finding the location of boundaries in text. 42// Instances of BreakIterator maintain a current position and scan over text 43// returning the index of characters where boundaries occur. 44// ***************************************************************************** 45 46U_NAMESPACE_BEGIN 47 48// ------------------------------------- 49 50BreakIterator* 51BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status) 52{ 53 char fnbuff[256]; 54 char ext[4]={'\0'}; 55 char actualLocale[ULOC_FULLNAME_CAPACITY]; 56 int32_t size; 57 const UChar* brkfname = NULL; 58 UResourceBundle brkRulesStack; 59 UResourceBundle brkNameStack; 60 UResourceBundle *brkRules = &brkRulesStack; 61 UResourceBundle *brkName = &brkNameStack; 62 RuleBasedBreakIterator *result = NULL; 63 64 if (U_FAILURE(status)) 65 return NULL; 66 67 ures_initStackObject(brkRules); 68 ures_initStackObject(brkName); 69 70 // Get the locale 71 UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, loc.getName(), &status); 72 /* this is a hack for now. Should be fixed when the data is fetched from 73 brk_index.txt */ 74 if(status==U_USING_DEFAULT_WARNING){ 75 status=U_ZERO_ERROR; 76 ures_openFillIn(b, U_ICUDATA_BRKITR, "", &status); 77 } 78 79 // Get the "boundaries" array. 80 if (U_SUCCESS(status)) { 81 brkRules = ures_getByKeyWithFallback(b, "boundaries", brkRules, &status); 82 // Get the string object naming the rules file 83 brkName = ures_getByKeyWithFallback(brkRules, type, brkName, &status); 84 // Get the actual string 85 brkfname = ures_getString(brkName, &size, &status); 86 U_ASSERT((size_t)size<sizeof(fnbuff)); 87 if ((size_t)size>=sizeof(fnbuff)) { 88 size=0; 89 if (U_SUCCESS(status)) { 90 status = U_BUFFER_OVERFLOW_ERROR; 91 } 92 } 93 94 // Use the string if we found it 95 if (U_SUCCESS(status) && brkfname) { 96 uprv_strncpy(actualLocale, 97 ures_getLocaleInternal(brkName, &status), 98 sizeof(actualLocale)/sizeof(actualLocale[0])); 99 100 UChar* extStart=u_strchr(brkfname, 0x002e); 101 int len = 0; 102 if(extStart!=NULL){ 103 len = (int)(extStart-brkfname); 104 u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff 105 u_UCharsToChars(brkfname, fnbuff, len); 106 } 107 fnbuff[len]=0; // nul terminate 108 } 109 } 110 111 ures_close(brkRules); 112 ures_close(brkName); 113 114 UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status); 115 if (U_FAILURE(status)) { 116 ures_close(b); 117 return NULL; 118 } 119 120 // Create a RuleBasedBreakIterator 121 result = new RuleBasedBreakIterator(file, status); 122 123 // If there is a result, set the valid locale and actual locale, and the kind 124 if (U_SUCCESS(status) && result != NULL) { 125 U_LOCALE_BASED(locBased, *(BreakIterator*)result); 126 locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), actualLocale); 127 result->setBreakType(kind); 128 } 129 130 ures_close(b); 131 132 if (U_FAILURE(status) && result != NULL) { // Sometimes redundant check, but simple 133 delete result; 134 return NULL; 135 } 136 137 if (result == NULL) { 138 udata_close(file); 139 if (U_SUCCESS(status)) { 140 status = U_MEMORY_ALLOCATION_ERROR; 141 } 142 } 143 144 return result; 145} 146 147// Creates a break iterator for word breaks. 148BreakIterator* U_EXPORT2 149BreakIterator::createWordInstance(const Locale& key, UErrorCode& status) 150{ 151 return createInstance(key, UBRK_WORD, status); 152} 153 154// ------------------------------------- 155 156// Creates a break iterator for line breaks. 157BreakIterator* U_EXPORT2 158BreakIterator::createLineInstance(const Locale& key, UErrorCode& status) 159{ 160 return createInstance(key, UBRK_LINE, status); 161} 162 163// ------------------------------------- 164 165// Creates a break iterator for character breaks. 166BreakIterator* U_EXPORT2 167BreakIterator::createCharacterInstance(const Locale& key, UErrorCode& status) 168{ 169 return createInstance(key, UBRK_CHARACTER, status); 170} 171 172// ------------------------------------- 173 174// Creates a break iterator for sentence breaks. 175BreakIterator* U_EXPORT2 176BreakIterator::createSentenceInstance(const Locale& key, UErrorCode& status) 177{ 178 return createInstance(key, UBRK_SENTENCE, status); 179} 180 181// ------------------------------------- 182 183// Creates a break iterator for title casing breaks. 184BreakIterator* U_EXPORT2 185BreakIterator::createTitleInstance(const Locale& key, UErrorCode& status) 186{ 187 return createInstance(key, UBRK_TITLE, status); 188} 189 190// ------------------------------------- 191 192// Gets all the available locales that has localized text boundary data. 193const Locale* U_EXPORT2 194BreakIterator::getAvailableLocales(int32_t& count) 195{ 196 return Locale::getAvailableLocales(count); 197} 198 199// ------------------------------------------ 200// 201// Default constructor and destructor 202// 203//------------------------------------------- 204 205BreakIterator::BreakIterator() 206{ 207 fBufferClone = FALSE; 208 *validLocale = *actualLocale = 0; 209} 210 211BreakIterator::~BreakIterator() 212{ 213} 214 215// ------------------------------------------ 216// 217// Registration 218// 219//------------------------------------------- 220#if !UCONFIG_NO_SERVICE 221 222// ------------------------------------- 223 224class ICUBreakIteratorFactory : public ICUResourceBundleFactory { 225public: 226 virtual ~ICUBreakIteratorFactory(); 227protected: 228 virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const { 229 return BreakIterator::makeInstance(loc, kind, status); 230 } 231}; 232 233ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {} 234 235// ------------------------------------- 236 237class ICUBreakIteratorService : public ICULocaleService { 238public: 239 ICUBreakIteratorService() 240 : ICULocaleService(UNICODE_STRING("Break Iterator", 14)) 241 { 242 UErrorCode status = U_ZERO_ERROR; 243 registerFactory(new ICUBreakIteratorFactory(), status); 244 } 245 246 virtual ~ICUBreakIteratorService(); 247 248 virtual UObject* cloneInstance(UObject* instance) const { 249 return ((BreakIterator*)instance)->clone(); 250 } 251 252 virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const { 253 LocaleKey& lkey = (LocaleKey&)key; 254 int32_t kind = lkey.kind(); 255 Locale loc; 256 lkey.currentLocale(loc); 257 return BreakIterator::makeInstance(loc, kind, status); 258 } 259 260 virtual UBool isDefault() const { 261 return countFactories() == 1; 262 } 263}; 264 265ICUBreakIteratorService::~ICUBreakIteratorService() {} 266 267// ------------------------------------- 268 269U_NAMESPACE_END 270 271// defined in ucln_cmn.h 272 273static icu::ICULocaleService* gService = NULL; 274 275/** 276 * Release all static memory held by breakiterator. 277 */ 278U_CDECL_BEGIN 279static UBool U_CALLCONV breakiterator_cleanup(void) { 280#if !UCONFIG_NO_SERVICE 281 if (gService) { 282 delete gService; 283 gService = NULL; 284 } 285#endif 286 return TRUE; 287} 288U_CDECL_END 289U_NAMESPACE_BEGIN 290 291static ICULocaleService* 292getService(void) 293{ 294 UBool needsInit; 295 UMTX_CHECK(NULL, (UBool)(gService == NULL), needsInit); 296 297 if (needsInit) { 298 ICULocaleService *tService = new ICUBreakIteratorService(); 299 umtx_lock(NULL); 300 if (gService == NULL) { 301 gService = tService; 302 tService = NULL; 303 ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup); 304 } 305 umtx_unlock(NULL); 306 delete tService; 307 } 308 return gService; 309} 310 311// ------------------------------------- 312 313static inline UBool 314hasService(void) 315{ 316 UBool retVal; 317 UMTX_CHECK(NULL, gService != NULL, retVal); 318 return retVal; 319} 320 321// ------------------------------------- 322 323URegistryKey U_EXPORT2 324BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status) 325{ 326 ICULocaleService *service = getService(); 327 if (service == NULL) { 328 status = U_MEMORY_ALLOCATION_ERROR; 329 return NULL; 330 } 331 return service->registerInstance(toAdopt, locale, kind, status); 332} 333 334// ------------------------------------- 335 336UBool U_EXPORT2 337BreakIterator::unregister(URegistryKey key, UErrorCode& status) 338{ 339 if (U_SUCCESS(status)) { 340 if (hasService()) { 341 return gService->unregister(key, status); 342 } 343 status = U_MEMORY_ALLOCATION_ERROR; 344 } 345 return FALSE; 346} 347 348// ------------------------------------- 349 350StringEnumeration* U_EXPORT2 351BreakIterator::getAvailableLocales(void) 352{ 353 ICULocaleService *service = getService(); 354 if (service == NULL) { 355 return NULL; 356 } 357 return service->getAvailableLocales(); 358} 359#endif /* UCONFIG_NO_SERVICE */ 360 361// ------------------------------------- 362 363BreakIterator* 364BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status) 365{ 366 if (U_FAILURE(status)) { 367 return NULL; 368 } 369 370#if !UCONFIG_NO_SERVICE 371 if (hasService()) { 372 Locale actualLoc(""); 373 BreakIterator *result = (BreakIterator*)gService->get(loc, kind, &actualLoc, status); 374 // TODO: The way the service code works in ICU 2.8 is that if 375 // there is a real registered break iterator, the actualLoc 376 // will be populated, but if the handleDefault path is taken 377 // (because nothing is registered that can handle the 378 // requested locale) then the actualLoc comes back empty. In 379 // that case, the returned object already has its actual/valid 380 // locale data populated (by makeInstance, which is what 381 // handleDefault calls), so we don't touch it. YES, A COMMENT 382 // THIS LONG is a sign of bad code -- so the action item is to 383 // revisit this in ICU 3.0 and clean it up/fix it/remove it. 384 if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) { 385 U_LOCALE_BASED(locBased, *result); 386 locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName()); 387 } 388 return result; 389 } 390 else 391#endif 392 { 393 return makeInstance(loc, kind, status); 394 } 395} 396 397// ------------------------------------- 398 399BreakIterator* 400BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status) 401{ 402 403 if (U_FAILURE(status)) { 404 return NULL; 405 } 406 407 BreakIterator *result = NULL; 408 switch (kind) { 409 case UBRK_CHARACTER: 410 result = BreakIterator::buildInstance(loc, "grapheme", kind, status); 411 break; 412 case UBRK_WORD: 413 result = BreakIterator::buildInstance(loc, "word", kind, status); 414 break; 415 case UBRK_LINE: 416 result = BreakIterator::buildInstance(loc, "line", kind, status); 417 break; 418 case UBRK_SENTENCE: 419 result = BreakIterator::buildInstance(loc, "sentence", kind, status); 420 break; 421 case UBRK_TITLE: 422 result = BreakIterator::buildInstance(loc, "title", kind, status); 423 break; 424 default: 425 status = U_ILLEGAL_ARGUMENT_ERROR; 426 } 427 428 if (U_FAILURE(status)) { 429 return NULL; 430 } 431 432 return result; 433} 434 435Locale 436BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const { 437 U_LOCALE_BASED(locBased, *this); 438 return locBased.getLocale(type, status); 439} 440 441const char * 442BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const { 443 U_LOCALE_BASED(locBased, *this); 444 return locBased.getLocaleID(type, status); 445} 446 447U_NAMESPACE_END 448 449#endif /* #if !UCONFIG_NO_BREAK_ITERATION */ 450 451//eof 452