[apple/icu.git] / icuSources / common / brkiter.cpp

/*
*******************************************************************************
* Copyright (C) 1997-2006, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* File TXTBDRY.CPP
*
* Modification History:
*
*   Date        Name        Description
*   02/18/97    aliu        Converted from OpenClass.  Added DONE.
*   01/13/2000  helena      Added UErrorCode parameter to createXXXInstance methods.
*****************************************************************************************
*/

// *****************************************************************************
// This file was generated from the java source file BreakIterator.java
// *****************************************************************************

#include "unicode/utypes.h"

#if !UCONFIG_NO_BREAK_ITERATION

#include "unicode/rbbi.h"
#include "unicode/brkiter.h"
#include "unicode/udata.h"
#include "unicode/ures.h"
#include "unicode/ustring.h"
#include "ucln_cmn.h"
#include "cstring.h"
#include "mutex.h"
#include "servloc.h"
#include "locbased.h"
#include "uresimp.h"
#include "uassert.h"
#include "ubrkimpl.h"

// *****************************************************************************
// class BreakIterator
// This class implements methods for finding the location of boundaries in text.
// Instances of BreakIterator maintain a current position and scan over text
// returning the index of characters where boundaries occur.
// *****************************************************************************

U_NAMESPACE_BEGIN

// -------------------------------------

BreakIterator*
BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status)
{
    char fnbuff[256];
    char ext[4]={'\0'};
    char actualLocale[ULOC_FULLNAME_CAPACITY];
    int32_t size;
    const UChar* brkfname = NULL;
    UResourceBundle brkRulesStack;
    UResourceBundle brkNameStack;
    UResourceBundle *brkRules = &brkRulesStack;
    UResourceBundle *brkName  = &brkNameStack;
    RuleBasedBreakIterator *result = NULL;
    
    if (U_FAILURE(status))
        return NULL;

    ures_initStackObject(brkRules);
    ures_initStackObject(brkName);

    // Get the locale
    UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, loc.getName(), &status);
    /* this is a hack for now. Should be fixed when the data is fetched from
        brk_index.txt */
    if(status==U_USING_DEFAULT_WARNING){
        status=U_ZERO_ERROR;
        ures_openFillIn(b, U_ICUDATA_BRKITR, "", &status);
    }

    // Get the "boundaries" array.
    if (U_SUCCESS(status)) {
        brkRules = ures_getByKeyWithFallback(b, "boundaries", brkRules, &status);
        // Get the string object naming the rules file
        brkName = ures_getByKeyWithFallback(brkRules, type, brkName, &status);
        // Get the actual string
        brkfname = ures_getString(brkName, &size, &status);
        U_ASSERT((size_t)size<sizeof(fnbuff));
        if ((size_t)size>=sizeof(fnbuff)) {
            size=0;
            if (U_SUCCESS(status)) {
                status = U_BUFFER_OVERFLOW_ERROR;
            }
        }

        // Use the string if we found it
        if (U_SUCCESS(status) && brkfname) {
            uprv_strncpy(actualLocale,
                ures_getLocale(brkName, &status),
                sizeof(actualLocale)/sizeof(actualLocale[0]));
            
            UChar* extStart=u_strchr(brkfname, 0x002e);
            int len = 0;
            if(extStart!=NULL){
                len = extStart-brkfname;
                u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff
                u_UCharsToChars(brkfname, fnbuff, len);
            }
            fnbuff[len]=0; // nul terminate
        }
    }

    ures_close(brkRules);
    ures_close(brkName);
    
    UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status);
    if (U_FAILURE(status)) {
        ures_close(b);
        return NULL;
    }

    // Create a RuleBasedBreakIterator
    result = new RuleBasedBreakIterator(file, status);

    // If there is a result, set the valid locale and actual locale, and the kind
    if (U_SUCCESS(status) && result != NULL) {
        U_LOCALE_BASED(locBased, *result);
        locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), actualLocale);
        result->setBreakType(kind);
    }

    ures_close(b);
    
    if (U_FAILURE(status) && result != NULL) {  // Sometimes redundant check, but simple
        delete result;
        return NULL;
    }

    if (result == NULL) {
        udata_close(file);
        if (U_SUCCESS(status)) {
            status = U_MEMORY_ALLOCATION_ERROR;
        }
    }

    return result;
}

// Creates a break iterator for word breaks.
BreakIterator* U_EXPORT2
BreakIterator::createWordInstance(const Locale& key, UErrorCode& status)
{
    return createInstance(key, UBRK_WORD, status);
}

// -------------------------------------

// Creates a break iterator  for line breaks.
BreakIterator* U_EXPORT2
BreakIterator::createLineInstance(const Locale& key, UErrorCode& status)
{
    return createInstance(key, UBRK_LINE, status);
}

// -------------------------------------

// Creates a break iterator  for character breaks.
BreakIterator* U_EXPORT2
BreakIterator::createCharacterInstance(const Locale& key, UErrorCode& status)
{
    return createInstance(key, UBRK_CHARACTER, status);
}

// -------------------------------------

// Creates a break iterator  for sentence breaks.
BreakIterator* U_EXPORT2
BreakIterator::createSentenceInstance(const Locale& key, UErrorCode& status)
{
    return createInstance(key, UBRK_SENTENCE, status);
}

// -------------------------------------

// Creates a break iterator for title casing breaks.
BreakIterator* U_EXPORT2
BreakIterator::createTitleInstance(const Locale& key, UErrorCode& status)
{
    return createInstance(key, UBRK_TITLE, status);
}

// -------------------------------------

// Gets all the available locales that has localized text boundary data.
const Locale* U_EXPORT2
BreakIterator::getAvailableLocales(int32_t& count)
{
    return Locale::getAvailableLocales(count);
}

// -------------------------------------
// Gets the objectLocale display name in the default locale language.
UnicodeString& U_EXPORT2
BreakIterator::getDisplayName(const Locale& objectLocale,
                             UnicodeString& name)
{
    return objectLocale.getDisplayName(name);
}

// -------------------------------------
// Gets the objectLocale display name in the displayLocale language.
UnicodeString& U_EXPORT2
BreakIterator::getDisplayName(const Locale& objectLocale,
                             const Locale& displayLocale,
                             UnicodeString& name)
{
    return objectLocale.getDisplayName(displayLocale, name);
}

// ------------------------------------------
//
// Default constructor and destructor
//
//-------------------------------------------

BreakIterator::BreakIterator()
{
    fBufferClone = FALSE;
    *validLocale = *actualLocale = 0;
}

BreakIterator::~BreakIterator()
{
}

// ------------------------------------------
//
// Registration
//
//-------------------------------------------
#if !UCONFIG_NO_SERVICE

static ICULocaleService* gService = NULL;

// -------------------------------------

class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
protected:
    virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {
        return BreakIterator::makeInstance(loc, kind, status);
    }
};

// -------------------------------------

class ICUBreakIteratorService : public ICULocaleService {
public:
    ICUBreakIteratorService()
        : ICULocaleService(UNICODE_STRING("Break Iterator", 14))
    {
        UErrorCode status = U_ZERO_ERROR;
        registerFactory(new ICUBreakIteratorFactory(), status);
    }
    
    virtual UObject* cloneInstance(UObject* instance) const {
        return ((BreakIterator*)instance)->clone();
    }
    
    virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
        LocaleKey& lkey = (LocaleKey&)key;
        int32_t kind = lkey.kind();
        Locale loc;
        lkey.currentLocale(loc);
        return BreakIterator::makeInstance(loc, kind, status);
    }
    
    virtual UBool isDefault() const {
        return countFactories() == 1;
    }
};

// -------------------------------------

U_NAMESPACE_END

// defined in ucln_cmn.h

/**
 * Release all static memory held by breakiterator.  
 */
U_CDECL_BEGIN
static UBool U_CALLCONV breakiterator_cleanup(void) {
#if !UCONFIG_NO_SERVICE
    if (gService) {
        delete gService;
        gService = NULL;
    }
#endif
    return TRUE;
}
U_CDECL_END
U_NAMESPACE_BEGIN

static ICULocaleService* 
getService(void)
{
    UBool needsInit;
    umtx_lock(NULL);
    needsInit = (UBool)(gService == NULL);
    umtx_unlock(NULL);
    
    if (needsInit) {
        ICULocaleService  *tService = new ICUBreakIteratorService();
        umtx_lock(NULL);
        if (gService == NULL) {
            gService = tService;
            tService = NULL;
            ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
        }
        umtx_unlock(NULL);
        delete tService;
    }
    return gService;
}

// -------------------------------------

static UBool
hasService(void) 
{
    Mutex mutex;
    return gService != NULL;
}

// -------------------------------------

URegistryKey U_EXPORT2
BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status) 
{
    return getService()->registerInstance(toAdopt, locale, kind, status);
}

// -------------------------------------

UBool U_EXPORT2
BreakIterator::unregister(URegistryKey key, UErrorCode& status) 
{
    if (U_SUCCESS(status)) {
        if (hasService()) {
            return gService->unregister(key, status);
        }
        status = U_ILLEGAL_ARGUMENT_ERROR;
    }
    return FALSE;
}

// -------------------------------------

StringEnumeration* U_EXPORT2
BreakIterator::getAvailableLocales(void)
{
  return getService()->getAvailableLocales();
}
#endif /* UCONFIG_NO_SERVICE */

// -------------------------------------

BreakIterator*
BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)
{
    if (U_FAILURE(status)) {
        return NULL;
    }
    
    u_init(&status);
#if !UCONFIG_NO_SERVICE
    if (hasService()) {
        Locale actualLoc("");
        BreakIterator *result = (BreakIterator*)gService->get(loc, kind, &actualLoc, status);
        // TODO: The way the service code works in ICU 2.8 is that if
        // there is a real registered break iterator, the actualLoc
        // will be populated, but if the handleDefault path is taken
        // (because nothing is registered that can handle the
        // requested locale) then the actualLoc comes back empty.  In
        // that case, the returned object already has its actual/valid
        // locale data populated (by makeInstance, which is what
        // handleDefault calls), so we don't touch it.  YES, A COMMENT
        // THIS LONG is a sign of bad code -- so the action item is to
        // revisit this in ICU 3.0 and clean it up/fix it/remove it.
        if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) {
            U_LOCALE_BASED(locBased, *result);
            locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName());
        }
        return result;
    }
    else
#endif
    {
        return makeInstance(loc, kind, status);
    }
}

// -------------------------------------

BreakIterator* 
BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status)
{

    if (U_FAILURE(status)) {
        return NULL;
    }

    BreakIterator *result = NULL;
    switch (kind) {
    case UBRK_CHARACTER: 
        result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
        break;
    case UBRK_WORD:
        result = BreakIterator::buildInstance(loc, "word", kind, status);
        break;
    case UBRK_LINE:
        result = BreakIterator::buildInstance(loc, "line", kind, status);
        break;
    case UBRK_SENTENCE:
        result = BreakIterator::buildInstance(loc, "sentence", kind, status);
        break;
    case UBRK_TITLE:
        result = BreakIterator::buildInstance(loc, "title", kind, status);
        break;
    default:
        status = U_ILLEGAL_ARGUMENT_ERROR;
    }

    if (U_FAILURE(status)) {
        return NULL;
    }

    return result;
}

Locale 
BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
    U_LOCALE_BASED(locBased, *this);
    return locBased.getLocale(type, status);
}

const char *
BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
    U_LOCALE_BASED(locBased, *this);
    return locBased.getLocaleID(type, status);
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_BREAK_ITERATION */

//eof
Commit	Line	Data
b75a7d8f A	1	/*
b75a7d8f A	2	*******************************************************************************
73c04bcf	3	* Copyright (C) 1997-2006, International Business Machines Corporation and *
b75a7d8f A	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
73c04bcf	25	#include "unicode/rbbi.h"
b75a7d8f A	26	#include "unicode/brkiter.h"
b75a7d8f A	27	#include "unicode/udata.h"
374ca955	28	#include "unicode/ures.h"
73c04bcf	29	#include "unicode/ustring.h"
374ca955	30	#include "ucln_cmn.h"
b75a7d8f A	31	#include "cstring.h"
b75a7d8f A	32	#include "mutex.h"
73c04bcf	33	#include "servloc.h"
374ca955 A	34	#include "locbased.h"
374ca955 A	35	#include "uresimp.h"
73c04bcf A	36	#include "uassert.h"
73c04bcf A	37	#include "ubrkimpl.h"
b75a7d8f A	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
b75a7d8f A	48	// -------------------------------------
b75a7d8f A	49
b75a7d8f	50	BreakIterator*
73c04bcf	51	BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status)
b75a7d8f	52	{
374ca955	53	char fnbuff[256];
73c04bcf	54	char ext[4]={'\0'};
374ca955 A	55	char actualLocale[ULOC_FULLNAME_CAPACITY];
	56	int32_t size;
	57	const UChar* brkfname = NULL;
73c04bcf A	58	UResourceBundle brkRulesStack;
	59	UResourceBundle brkNameStack;
	60	UResourceBundle *brkRules = &brkRulesStack;
	61	UResourceBundle *brkName = &brkNameStack;
	62	RuleBasedBreakIterator *result = NULL;
374ca955	63
b75a7d8f A	64	if (U_FAILURE(status))
	65	return NULL;
	66
374ca955 A	67	ures_initStackObject(brkRules);
	68	ures_initStackObject(brkName);
	69
	70	// Get the locale
73c04bcf A	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	}
374ca955 A	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);
73c04bcf A	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	}
374ca955 A	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]));
73c04bcf A	99
	100	UChar* extStart=u_strchr(brkfname, 0x002e);
	101	int len = 0;
	102	if(extStart!=NULL){
	103	len = 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
374ca955	108	}
b75a7d8f A	109	}
b75a7d8f A	110
374ca955 A	111	ures_close(brkRules);
	112	ures_close(brkName);
	113
73c04bcf	114	UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status);
b75a7d8f	115	if (U_FAILURE(status)) {
374ca955	116	ures_close(b);
b75a7d8f A	117	return NULL;
b75a7d8f A	118	}
b75a7d8f	119
73c04bcf A	120	// Create a RuleBasedBreakIterator
73c04bcf A	121	result = new RuleBasedBreakIterator(file, status);
374ca955	122
73c04bcf	123	// If there is a result, set the valid locale and actual locale, and the kind
374ca955 A	124	if (U_SUCCESS(status) && result != NULL) {
	125	U_LOCALE_BASED(locBased, *result);
	126	locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), actualLocale);
73c04bcf	127	result->setBreakType(kind);
b75a7d8f	128	}
374ca955 A	129
	130	ures_close(b);
	131
	132	if (U_FAILURE(status) && result != NULL) { // Sometimes redundant check, but simple
b75a7d8f	133	delete result;
374ca955 A	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	}
b75a7d8f A	142	}
	143
	144	return result;
	145	}
	146
374ca955 A	147	// Creates a break iterator for word breaks.
	148	BreakIterator* U_EXPORT2
	149	BreakIterator::createWordInstance(const Locale& key, UErrorCode& status)
	150	{
	151	return createInstance(key, UBRK_WORD, status);
	152	}
	153
b75a7d8f A	154	// -------------------------------------
	155
	156	// Creates a break iterator for line breaks.
374ca955	157	BreakIterator* U_EXPORT2
b75a7d8f A	158	BreakIterator::createLineInstance(const Locale& key, UErrorCode& status)
b75a7d8f A	159	{
374ca955	160	return createInstance(key, UBRK_LINE, status);
b75a7d8f A	161	}
	162
	163	// -------------------------------------
	164
	165	// Creates a break iterator for character breaks.
374ca955	166	BreakIterator* U_EXPORT2
b75a7d8f A	167	BreakIterator::createCharacterInstance(const Locale& key, UErrorCode& status)
b75a7d8f A	168	{
374ca955	169	return createInstance(key, UBRK_CHARACTER, status);
b75a7d8f A	170	}
	171
	172	// -------------------------------------
	173
	174	// Creates a break iterator for sentence breaks.
374ca955	175	BreakIterator* U_EXPORT2
b75a7d8f A	176	BreakIterator::createSentenceInstance(const Locale& key, UErrorCode& status)
b75a7d8f A	177	{
374ca955	178	return createInstance(key, UBRK_SENTENCE, status);
b75a7d8f A	179	}
	180
	181	// -------------------------------------
	182
	183	// Creates a break iterator for title casing breaks.
374ca955	184	BreakIterator* U_EXPORT2
b75a7d8f A	185	BreakIterator::createTitleInstance(const Locale& key, UErrorCode& status)
b75a7d8f A	186	{
374ca955	187	return createInstance(key, UBRK_TITLE, status);
b75a7d8f A	188	}
	189
	190	// -------------------------------------
	191
	192	// Gets all the available locales that has localized text boundary data.
374ca955	193	const Locale* U_EXPORT2
b75a7d8f A	194	BreakIterator::getAvailableLocales(int32_t& count)
	195	{
	196	return Locale::getAvailableLocales(count);
	197	}
	198
	199	// -------------------------------------
	200	// Gets the objectLocale display name in the default locale language.
374ca955	201	UnicodeString& U_EXPORT2
b75a7d8f A	202	BreakIterator::getDisplayName(const Locale& objectLocale,
	203	UnicodeString& name)
	204	{
	205	return objectLocale.getDisplayName(name);
	206	}
	207
	208	// -------------------------------------
	209	// Gets the objectLocale display name in the displayLocale language.
374ca955	210	UnicodeString& U_EXPORT2
b75a7d8f A	211	BreakIterator::getDisplayName(const Locale& objectLocale,
	212	const Locale& displayLocale,
	213	UnicodeString& name)
	214	{
	215	return objectLocale.getDisplayName(displayLocale, name);
	216	}
	217
	218	// ------------------------------------------
	219	//
	220	// Default constructor and destructor
	221	//
	222	//-------------------------------------------
	223
	224	BreakIterator::BreakIterator()
	225	{
	226	fBufferClone = FALSE;
374ca955	227	validLocale = actualLocale = 0;
b75a7d8f A	228	}
	229
	230	BreakIterator::~BreakIterator()
	231	{
	232	}
	233
	234	// ------------------------------------------
	235	//
	236	// Registration
	237	//
	238	//-------------------------------------------
374ca955	239	#if !UCONFIG_NO_SERVICE
b75a7d8f A	240
	241	static ICULocaleService* gService = NULL;
	242
	243	// -------------------------------------
	244
	245	class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
	246	protected:
374ca955 A	247	virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /service/, UErrorCode& status) const {
	248	return BreakIterator::makeInstance(loc, kind, status);
	249	}
b75a7d8f A	250	};
	251
	252	// -------------------------------------
	253
	254	class ICUBreakIteratorService : public ICULocaleService {
	255	public:
374ca955 A	256	ICUBreakIteratorService()
	257	: ICULocaleService(UNICODE_STRING("Break Iterator", 14))
	258	{
	259	UErrorCode status = U_ZERO_ERROR;
	260	registerFactory(new ICUBreakIteratorFactory(), status);
	261	}
	262
	263	virtual UObject* cloneInstance(UObject* instance) const {
	264	return ((BreakIterator*)instance)->clone();
	265	}
	266
	267	virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /actualID/, UErrorCode& status) const {
	268	LocaleKey& lkey = (LocaleKey&)key;
	269	int32_t kind = lkey.kind();
	270	Locale loc;
	271	lkey.currentLocale(loc);
	272	return BreakIterator::makeInstance(loc, kind, status);
	273	}
	274
	275	virtual UBool isDefault() const {
	276	return countFactories() == 1;
	277	}
b75a7d8f A	278	};
	279
	280	// -------------------------------------
	281
374ca955 A	282	U_NAMESPACE_END
	283
	284	// defined in ucln_cmn.h
	285
	286	/**
	287	* Release all static memory held by breakiterator.
	288	*/
	289	U_CDECL_BEGIN
	290	static UBool U_CALLCONV breakiterator_cleanup(void) {
	291	#if !UCONFIG_NO_SERVICE
	292	if (gService) {
	293	delete gService;
	294	gService = NULL;
	295	}
	296	#endif
	297	return TRUE;
	298	}
	299	U_CDECL_END
	300	U_NAMESPACE_BEGIN
	301
b75a7d8f A	302	static ICULocaleService*
	303	getService(void)
	304	{
	305	UBool needsInit;
	306	umtx_lock(NULL);
	307	needsInit = (UBool)(gService == NULL);
	308	umtx_unlock(NULL);
	309
	310	if (needsInit) {
	311	ICULocaleService *tService = new ICUBreakIteratorService();
	312	umtx_lock(NULL);
	313	if (gService == NULL) {
	314	gService = tService;
	315	tService = NULL;
374ca955	316	ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
b75a7d8f A	317	}
	318	umtx_unlock(NULL);
	319	delete tService;
	320	}
	321	return gService;
	322	}
	323
	324	// -------------------------------------
	325
	326	static UBool
	327	hasService(void)
	328	{
374ca955 A	329	Mutex mutex;
374ca955 A	330	return gService != NULL;
b75a7d8f A	331	}
	332
	333	// -------------------------------------
	334
374ca955	335	URegistryKey U_EXPORT2
b75a7d8f A	336	BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)
b75a7d8f A	337	{
374ca955	338	return getService()->registerInstance(toAdopt, locale, kind, status);
b75a7d8f A	339	}
	340
	341	// -------------------------------------
	342
374ca955	343	UBool U_EXPORT2
b75a7d8f A	344	BreakIterator::unregister(URegistryKey key, UErrorCode& status)
	345	{
	346	if (U_SUCCESS(status)) {
	347	if (hasService()) {
	348	return gService->unregister(key, status);
	349	}
	350	status = U_ILLEGAL_ARGUMENT_ERROR;
	351	}
	352	return FALSE;
	353	}
	354
	355	// -------------------------------------
	356
374ca955	357	StringEnumeration* U_EXPORT2
b75a7d8f A	358	BreakIterator::getAvailableLocales(void)
	359	{
	360	return getService()->getAvailableLocales();
	361	}
374ca955 A	362	#endif /* UCONFIG_NO_SERVICE */
	363
	364	// -------------------------------------
	365
	366	BreakIterator*
73c04bcf	367	BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)
374ca955 A	368	{
	369	if (U_FAILURE(status)) {
	370	return NULL;
	371	}
	372
	373	u_init(&status);
	374	#if !UCONFIG_NO_SERVICE
	375	if (hasService()) {
73c04bcf	376	Locale actualLoc("");
374ca955 A	377	BreakIterator result = (BreakIterator)gService->get(loc, kind, &actualLoc, status);
	378	// TODO: The way the service code works in ICU 2.8 is that if
	379	// there is a real registered break iterator, the actualLoc
	380	// will be populated, but if the handleDefault path is taken
	381	// (because nothing is registered that can handle the
	382	// requested locale) then the actualLoc comes back empty. In
	383	// that case, the returned object already has its actual/valid
	384	// locale data populated (by makeInstance, which is what
	385	// handleDefault calls), so we don't touch it. YES, A COMMENT
	386	// THIS LONG is a sign of bad code -- so the action item is to
	387	// revisit this in ICU 3.0 and clean it up/fix it/remove it.
	388	if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) {
	389	U_LOCALE_BASED(locBased, *result);
	390	locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName());
	391	}
	392	return result;
	393	}
	394	else
	395	#endif
	396	{
	397	return makeInstance(loc, kind, status);
	398	}
	399	}
b75a7d8f A	400
	401	// -------------------------------------
	402
	403	BreakIterator*
	404	BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status)
	405	{
374ca955 A	406
	407	if (U_FAILURE(status)) {
	408	return NULL;
	409	}
	410
	411	BreakIterator *result = NULL;
b75a7d8f	412	switch (kind) {
374ca955	413	case UBRK_CHARACTER:
73c04bcf	414	result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
374ca955 A	415	break;
374ca955 A	416	case UBRK_WORD:
73c04bcf	417	result = BreakIterator::buildInstance(loc, "word", kind, status);
374ca955 A	418	break;
374ca955 A	419	case UBRK_LINE:
73c04bcf	420	result = BreakIterator::buildInstance(loc, "line", kind, status);
374ca955 A	421	break;
374ca955 A	422	case UBRK_SENTENCE:
73c04bcf	423	result = BreakIterator::buildInstance(loc, "sentence", kind, status);
374ca955 A	424	break;
374ca955 A	425	case UBRK_TITLE:
73c04bcf	426	result = BreakIterator::buildInstance(loc, "title", kind, status);
374ca955	427	break;
b75a7d8f	428	default:
374ca955	429	status = U_ILLEGAL_ARGUMENT_ERROR;
b75a7d8f	430	}
b75a7d8f	431
374ca955 A	432	if (U_FAILURE(status)) {
	433	return NULL;
	434	}
b75a7d8f	435
374ca955 A	436	return result;
374ca955 A	437	}
b75a7d8f	438
374ca955 A	439	Locale
	440	BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
	441	U_LOCALE_BASED(locBased, *this);
	442	return locBased.getLocale(type, status);
	443	}
	444
	445	const char *
	446	BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
	447	U_LOCALE_BASED(locBased, *this);
	448	return locBased.getLocaleID(type, status);
b75a7d8f A	449	}
b75a7d8f A	450
374ca955 A	451	U_NAMESPACE_END
374ca955 A	452
b75a7d8f A	453	#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
	454
	455	//eof