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