// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

* Copyright (C) 1997-2015, International Business Machines Corporation and

* others. All Rights Reserved.

*******************************************************************************

*

* File brkiter.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 "unicode/filteredbrk.h"

#include "ucln_cmn.h"

#include "cstring.h"

#include "umutex.h"

#include "servloc.h"

#include "locbased.h"

#include "uresimp.h"

#include "uassert.h"

#include "ubrkimpl.h"

#include "utracimp.h"

#include "charstr.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, UErrorCode &status)

{

    char fnbuff[256];

    char ext[4]={'\0'};

    CharString actualLocale;

    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_openNoDefault(U_ICUDATA_BRKITR, loc.getName(), &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) {

            actualLocale.append(ures_getLocaleInternal(brkName, &status), -1, status);

            UChar* extStart=u_strchr(brkfname, 0x002e);

            int len = 0;

            if(extStart!=NULL){

                len = (int)(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, *(BreakIterator*)result);

        locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), 

                              actualLocale.data());

    }

    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);

}

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

//

// Constructors, destructor and assignment operator

//

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

BreakIterator::BreakIterator()

{

    *validLocale = *actualLocale = 0;

}

BreakIterator::BreakIterator(const BreakIterator &other) : UObject(other) {

    uprv_strncpy(actualLocale, other.actualLocale, sizeof(actualLocale));

    uprv_strncpy(validLocale, other.validLocale, sizeof(validLocale));

}

BreakIterator &BreakIterator::operator =(const BreakIterator &other) {

    if (this != &other) {

        uprv_strncpy(actualLocale, other.actualLocale, sizeof(actualLocale));

        uprv_strncpy(validLocale, other.validLocale, sizeof(validLocale));

    }

    return *this;

}

BreakIterator::~BreakIterator()

{

}

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

//

// Registration

//

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

#if !UCONFIG_NO_SERVICE

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

class ICUBreakIteratorFactory : public ICUResourceBundleFactory {

public:

    virtual ~ICUBreakIteratorFactory();

protected:

    virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {

        return BreakIterator::makeInstance(loc, kind, status);

    }

};

ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {}

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

class ICUBreakIteratorService : public ICULocaleService {

public:

    ICUBreakIteratorService()

        : ICULocaleService(UNICODE_STRING("Break Iterator", 14))

    {

        UErrorCode status = U_ZERO_ERROR;

        registerFactory(new ICUBreakIteratorFactory(), status);

    }

    virtual ~ICUBreakIteratorService();

    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;

    }

};

ICUBreakIteratorService::~ICUBreakIteratorService() {}

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

// defined in ucln_cmn.h

U_NAMESPACE_END

static icu::UInitOnce gInitOnceBrkiter = U_INITONCE_INITIALIZER;

static icu::ICULocaleService* gService = NULL;

/**

 * 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;

    }

    gInitOnceBrkiter.reset();

#endif

    return TRUE;

}

U_CDECL_END

U_NAMESPACE_BEGIN

static void U_CALLCONV 

initService(void) {

    gService = new ICUBreakIteratorService();

    ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);

}

static ICULocaleService*

getService(void)

{

    umtx_initOnce(gInitOnceBrkiter, &initService);

    return gService;

}

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

static inline UBool

hasService(void)

{

    return !gInitOnceBrkiter.isReset() && getService() != NULL;

}

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

URegistryKey U_EXPORT2

BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)

{

    ICULocaleService *service = getService();

    if (service == NULL) {

        status = U_MEMORY_ALLOCATION_ERROR;

        return NULL;

    }

    return service->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_MEMORY_ALLOCATION_ERROR;

    }

    return FALSE;

}

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

StringEnumeration* U_EXPORT2

BreakIterator::getAvailableLocales(void)

{

    ICULocaleService *service = getService();

    if (service == NULL) {

        return NULL;

    }

    return service->getAvailableLocales();

}

#endif /* UCONFIG_NO_SERVICE */

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

BreakIterator*

BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)

{

    if (U_FAILURE(status)) {

        return NULL;

    }

#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);

    }

}

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

enum { kKeyValueLenMax = 32 };

BreakIterator*

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

{

    if (U_FAILURE(status)) {

        return NULL;

    }

    char lbType[kKeyValueLenMax];

    BreakIterator *result = NULL;

    switch (kind) {

    case UBRK_CHARACTER:

        {

            UTRACE_ENTRY(UTRACE_UBRK_CREATE_CHARACTER);

            result = BreakIterator::buildInstance(loc, "grapheme", status);

            UTRACE_EXIT_STATUS(status);

        }

        break;

    case UBRK_WORD:

        {

            UTRACE_ENTRY(UTRACE_UBRK_CREATE_WORD);

            result = BreakIterator::buildInstance(loc, "word", status);

            UTRACE_EXIT_STATUS(status);

        }

        break;

    case UBRK_LINE:

        {

            UTRACE_ENTRY(UTRACE_UBRK_CREATE_LINE);

            uprv_strcpy(lbType, "line");

            char lbKeyValue[kKeyValueLenMax] = {0};

            UErrorCode kvStatus = U_ZERO_ERROR;

            int32_t kLen = loc.getKeywordValue("lb", lbKeyValue, kKeyValueLenMax, kvStatus);

            if (U_SUCCESS(kvStatus) && kLen > 0 && (uprv_strcmp(lbKeyValue,"strict")==0 || uprv_strcmp(lbKeyValue,"normal")==0 || uprv_strcmp(lbKeyValue,"loose")==0)) {

                uprv_strcat(lbType, "_");

                uprv_strcat(lbType, lbKeyValue);

            }

            result = BreakIterator::buildInstance(loc, lbType, status);

            UTRACE_DATA1(UTRACE_INFO, "lb=%s", lbKeyValue);

            UTRACE_EXIT_STATUS(status);

        }

        break;

    case UBRK_SENTENCE:

        {

            UTRACE_ENTRY(UTRACE_UBRK_CREATE_SENTENCE);

            result = BreakIterator::buildInstance(loc, "sentence", status);

#if !UCONFIG_NO_FILTERED_BREAK_ITERATION

            char ssKeyValue[kKeyValueLenMax] = {0};

            UErrorCode kvStatus = U_ZERO_ERROR;

            int32_t kLen = loc.getKeywordValue("ss", ssKeyValue, kKeyValueLenMax, kvStatus);

            if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(ssKeyValue,"standard")==0) {

                FilteredBreakIteratorBuilder* fbiBuilder = FilteredBreakIteratorBuilder::createInstance(loc, kvStatus);

                if (U_SUCCESS(kvStatus)) {

                    result = fbiBuilder->build(result, status);

                    delete fbiBuilder;

                }

            }

#endif

            UTRACE_EXIT_STATUS(status);

        }

        break;

    case UBRK_TITLE:

        {

            UTRACE_ENTRY(UTRACE_UBRK_CREATE_TITLE);

            result = BreakIterator::buildInstance(loc, "title", status);

            UTRACE_EXIT_STATUS(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);

}

// This implementation of getRuleStatus is a do-nothing stub, here to

// provide a default implementation for any derived BreakIterator classes that

// do not implement it themselves.

int32_t BreakIterator::getRuleStatus() const {

    return 0;

}

// This implementation of getRuleStatusVec is a do-nothing stub, here to

// provide a default implementation for any derived BreakIterator classes that

// do not implement it themselves.

int32_t BreakIterator::getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) {

    if (U_FAILURE(status)) {

        return 0;

    }

    if (capacity < 1) {

        status = U_BUFFER_OVERFLOW_ERROR;

        return 1;

    }

    *fillInVec = 0;

    return 1;

}

BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) {

  U_LOCALE_BASED(locBased, (*this));

  locBased.setLocaleIDs(valid, actual);

}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_BREAK_ITERATION */

//eof