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
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_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.
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 {
225protected:
226    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
233class ICUBreakIteratorService : public ICULocaleService {
234public:
235    ICUBreakIteratorService()
236        : ICULocaleService(UNICODE_STRING("Break Iterator", 14))
237    {
238        UErrorCode status = U_ZERO_ERROR;
239        registerFactory(new ICUBreakIteratorFactory(), status);
240    }
241
242    virtual UObject* cloneInstance(UObject* instance) const {
243        return ((BreakIterator*)instance)->clone();
244    }
245
246    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
254    virtual UBool isDefault() const {
255        return countFactories() == 1;
256    }
257};
258
259// -------------------------------------
260
261U_NAMESPACE_END
262
263// defined in ucln_cmn.h
264
265static U_NAMESPACE_QUALIFIER ICULocaleService* gService = NULL;
266
267/**
268 * Release all static memory held by breakiterator.
269 */
270U_CDECL_BEGIN
271static 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}
280U_CDECL_END
281U_NAMESPACE_BEGIN
282
283static ICULocaleService*
284getService(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
305static inline UBool
306hasService(void)
307{
308    UBool retVal;
309    UMTX_CHECK(NULL, gService != NULL, retVal);
310    return retVal;
311}
312
313// -------------------------------------
314
315URegistryKey U_EXPORT2
316BreakIterator::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
328UBool U_EXPORT2
329BreakIterator::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
342StringEnumeration* U_EXPORT2
343BreakIterator::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
355BreakIterator*
356BreakIterator::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
391BreakIterator*
392BreakIterator::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
427Locale
428BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
429    U_LOCALE_BASED(locBased, *this);
430    return locBased.getLocale(type, status);
431}
432
433const char *
434BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
435    U_LOCALE_BASED(locBased, *this);
436    return locBased.getLocaleID(type, status);
437}
438
439U_NAMESPACE_END
440
441#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
442
443//eof
444