• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2010, 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 
46 U_NAMESPACE_BEGIN
47 
48 // -------------------------------------
49 
50 BreakIterator*
buildInstance(const Locale & loc,const char * type,int32_t kind,UErrorCode & status)51 BreakIterator::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_getLocale(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.
148 BreakIterator* U_EXPORT2
createWordInstance(const Locale & key,UErrorCode & status)149 BreakIterator::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.
157 BreakIterator* U_EXPORT2
createLineInstance(const Locale & key,UErrorCode & status)158 BreakIterator::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.
166 BreakIterator* U_EXPORT2
createCharacterInstance(const Locale & key,UErrorCode & status)167 BreakIterator::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.
175 BreakIterator* U_EXPORT2
createSentenceInstance(const Locale & key,UErrorCode & status)176 BreakIterator::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.
184 BreakIterator* U_EXPORT2
createTitleInstance(const Locale & key,UErrorCode & status)185 BreakIterator::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.
193 const Locale* U_EXPORT2
getAvailableLocales(int32_t & count)194 BreakIterator::getAvailableLocales(int32_t& count)
195 {
196     return Locale::getAvailableLocales(count);
197 }
198 
199 // ------------------------------------------
200 //
201 // Default constructor and destructor
202 //
203 //-------------------------------------------
204 
BreakIterator()205 BreakIterator::BreakIterator()
206 {
207     fBufferClone = FALSE;
208     *validLocale = *actualLocale = 0;
209 }
210 
~BreakIterator()211 BreakIterator::~BreakIterator()
212 {
213 }
214 
215 // ------------------------------------------
216 //
217 // Registration
218 //
219 //-------------------------------------------
220 #if !UCONFIG_NO_SERVICE
221 
222 // -------------------------------------
223 
224 class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
225 protected:
handleCreate(const Locale & loc,int32_t kind,const ICUService *,UErrorCode & status) const226     virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {
227         return BreakIterator::makeInstance(loc, kind, status);
228     }
229 };
230 
231 // -------------------------------------
232 
233 class ICUBreakIteratorService : public ICULocaleService {
234 public:
ICUBreakIteratorService()235     ICUBreakIteratorService()
236         : ICULocaleService(UNICODE_STRING("Break Iterator", 14))
237     {
238         UErrorCode status = U_ZERO_ERROR;
239         registerFactory(new ICUBreakIteratorFactory(), status);
240     }
241 
cloneInstance(UObject * instance) const242     virtual UObject* cloneInstance(UObject* instance) const {
243         return ((BreakIterator*)instance)->clone();
244     }
245 
handleDefault(const ICUServiceKey & key,UnicodeString *,UErrorCode & status) const246     virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
247         LocaleKey& lkey = (LocaleKey&)key;
248         int32_t kind = lkey.kind();
249         Locale loc;
250         lkey.currentLocale(loc);
251         return BreakIterator::makeInstance(loc, kind, status);
252     }
253 
isDefault() const254     virtual UBool isDefault() const {
255         return countFactories() == 1;
256     }
257 };
258 
259 // -------------------------------------
260 
261 U_NAMESPACE_END
262 
263 // defined in ucln_cmn.h
264 
265 static U_NAMESPACE_QUALIFIER ICULocaleService* gService = NULL;
266 
267 /**
268  * Release all static memory held by breakiterator.
269  */
270 U_CDECL_BEGIN
breakiterator_cleanup(void)271 static UBool U_CALLCONV breakiterator_cleanup(void) {
272 #if !UCONFIG_NO_SERVICE
273     if (gService) {
274         delete gService;
275         gService = NULL;
276     }
277 #endif
278     return TRUE;
279 }
280 U_CDECL_END
281 U_NAMESPACE_BEGIN
282 
283 static ICULocaleService*
getService(void)284 getService(void)
285 {
286     UBool needsInit;
287     UMTX_CHECK(NULL, (UBool)(gService == NULL), needsInit);
288 
289     if (needsInit) {
290         ICULocaleService  *tService = new ICUBreakIteratorService();
291         umtx_lock(NULL);
292         if (gService == NULL) {
293             gService = tService;
294             tService = NULL;
295             ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
296         }
297         umtx_unlock(NULL);
298         delete tService;
299     }
300     return gService;
301 }
302 
303 // -------------------------------------
304 
305 static inline UBool
hasService(void)306 hasService(void)
307 {
308     UBool retVal;
309     UMTX_CHECK(NULL, gService != NULL, retVal);
310     return retVal;
311 }
312 
313 // -------------------------------------
314 
315 URegistryKey U_EXPORT2
registerInstance(BreakIterator * toAdopt,const Locale & locale,UBreakIteratorType kind,UErrorCode & status)316 BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)
317 {
318     ICULocaleService *service = getService();
319     if (service == NULL) {
320         status = U_MEMORY_ALLOCATION_ERROR;
321         return NULL;
322     }
323     return service->registerInstance(toAdopt, locale, kind, status);
324 }
325 
326 // -------------------------------------
327 
328 UBool U_EXPORT2
unregister(URegistryKey key,UErrorCode & status)329 BreakIterator::unregister(URegistryKey key, UErrorCode& status)
330 {
331     if (U_SUCCESS(status)) {
332         if (hasService()) {
333             return gService->unregister(key, status);
334         }
335         status = U_MEMORY_ALLOCATION_ERROR;
336     }
337     return FALSE;
338 }
339 
340 // -------------------------------------
341 
342 StringEnumeration* U_EXPORT2
getAvailableLocales(void)343 BreakIterator::getAvailableLocales(void)
344 {
345     ICULocaleService *service = getService();
346     if (service == NULL) {
347         return NULL;
348     }
349     return service->getAvailableLocales();
350 }
351 #endif /* UCONFIG_NO_SERVICE */
352 
353 // -------------------------------------
354 
355 BreakIterator*
createInstance(const Locale & loc,int32_t kind,UErrorCode & status)356 BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)
357 {
358     if (U_FAILURE(status)) {
359         return NULL;
360     }
361 
362 #if !UCONFIG_NO_SERVICE
363     if (hasService()) {
364         Locale actualLoc("");
365         BreakIterator *result = (BreakIterator*)gService->get(loc, kind, &actualLoc, status);
366         // TODO: The way the service code works in ICU 2.8 is that if
367         // there is a real registered break iterator, the actualLoc
368         // will be populated, but if the handleDefault path is taken
369         // (because nothing is registered that can handle the
370         // requested locale) then the actualLoc comes back empty.  In
371         // that case, the returned object already has its actual/valid
372         // locale data populated (by makeInstance, which is what
373         // handleDefault calls), so we don't touch it.  YES, A COMMENT
374         // THIS LONG is a sign of bad code -- so the action item is to
375         // revisit this in ICU 3.0 and clean it up/fix it/remove it.
376         if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) {
377             U_LOCALE_BASED(locBased, *result);
378             locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName());
379         }
380         return result;
381     }
382     else
383 #endif
384     {
385         return makeInstance(loc, kind, status);
386     }
387 }
388 
389 // -------------------------------------
390 
391 BreakIterator*
makeInstance(const Locale & loc,int32_t kind,UErrorCode & status)392 BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status)
393 {
394 
395     if (U_FAILURE(status)) {
396         return NULL;
397     }
398 
399     BreakIterator *result = NULL;
400     switch (kind) {
401     case UBRK_CHARACTER:
402         result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
403         break;
404     case UBRK_WORD:
405         result = BreakIterator::buildInstance(loc, "word", kind, status);
406         break;
407     case UBRK_LINE:
408         result = BreakIterator::buildInstance(loc, "line", kind, status);
409         break;
410     case UBRK_SENTENCE:
411         result = BreakIterator::buildInstance(loc, "sentence", kind, status);
412         break;
413     case UBRK_TITLE:
414         result = BreakIterator::buildInstance(loc, "title", kind, status);
415         break;
416     default:
417         status = U_ILLEGAL_ARGUMENT_ERROR;
418     }
419 
420     if (U_FAILURE(status)) {
421         return NULL;
422     }
423 
424     return result;
425 }
426 
427 Locale
getLocale(ULocDataLocaleType type,UErrorCode & status) const428 BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
429     U_LOCALE_BASED(locBased, *this);
430     return locBased.getLocale(type, status);
431 }
432 
433 const char *
getLocaleID(ULocDataLocaleType type,UErrorCode & status) const434 BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
435     U_LOCALE_BASED(locBased, *this);
436     return locBased.getLocaleID(type, status);
437 }
438 
439 // This implementation of getRuleStatus is a do-nothing stub, here to
440 // provide a default implementation for any derived BreakIterator classes that
441 // do not implement it themselves.
getRuleStatus() const442 int32_t BreakIterator::getRuleStatus() const {
443     return 0;
444 }
445 
446 U_NAMESPACE_END
447 
448 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
449 
450 //eof
451