| /* |
| ******************************************************************************** |
| * Copyright (C) 1996-2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_BREAK_ITERATION |
| |
| #include "unicode/ubrk.h" |
| |
| #include "unicode/brkiter.h" |
| #include "unicode/uloc.h" |
| #include "unicode/ustring.h" |
| #include "unicode/uchriter.h" |
| #include "unicode/rbbi.h" |
| #include "rbbirb.h" |
| #include "uassert.h" |
| |
| U_NAMESPACE_USE |
| |
| //------------------------------------------------------------------------------ |
| // |
| // ubrk_open Create a canned type of break iterator based on type (word, line, etc.) |
| // and locale. |
| // |
| //------------------------------------------------------------------------------ |
| U_CAPI UBreakIterator* U_EXPORT2 |
| ubrk_open(UBreakIteratorType type, |
| const char *locale, |
| const UChar *text, |
| int32_t textLength, |
| UErrorCode *status) |
| { |
| |
| if(U_FAILURE(*status)) return 0; |
| |
| BreakIterator *result = 0; |
| |
| switch(type) { |
| |
| case UBRK_CHARACTER: |
| result = BreakIterator::createCharacterInstance(Locale(locale), *status); |
| break; |
| |
| case UBRK_WORD: |
| result = BreakIterator::createWordInstance(Locale(locale), *status); |
| break; |
| |
| case UBRK_LINE: |
| result = BreakIterator::createLineInstance(Locale(locale), *status); |
| break; |
| |
| case UBRK_SENTENCE: |
| result = BreakIterator::createSentenceInstance(Locale(locale), *status); |
| break; |
| |
| case UBRK_TITLE: |
| result = BreakIterator::createTitleInstance(Locale(locale), *status); |
| break; |
| |
| default: |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| |
| // check for allocation error |
| if (U_FAILURE(*status)) { |
| return 0; |
| } |
| if(result == 0) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return 0; |
| } |
| |
| |
| UBreakIterator *uBI = (UBreakIterator *)result; |
| if (text != NULL) { |
| ubrk_setText(uBI, text, textLength, status); |
| } |
| return uBI; |
| } |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // ubrk_openRules open a break iterator from a set of break rules. |
| // Invokes the rule builder. |
| // |
| //------------------------------------------------------------------------------ |
| U_CAPI UBreakIterator* U_EXPORT2 |
| ubrk_openRules( const UChar *rules, |
| int32_t rulesLength, |
| const UChar *text, |
| int32_t textLength, |
| UParseError *parseErr, |
| UErrorCode *status) { |
| |
| if (status == NULL || U_FAILURE(*status)){ |
| return 0; |
| } |
| |
| BreakIterator *result = 0; |
| UnicodeString ruleString(rules, rulesLength); |
| result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, parseErr, *status); |
| if(U_FAILURE(*status)) { |
| return 0; |
| } |
| |
| UBreakIterator *uBI = (UBreakIterator *)result; |
| if (text != NULL) { |
| ubrk_setText(uBI, text, textLength, status); |
| } |
| return uBI; |
| } |
| |
| |
| |
| |
| |
| U_CAPI UBreakIterator * U_EXPORT2 |
| ubrk_safeClone( |
| const UBreakIterator *bi, |
| void * /*stackBuffer*/, |
| int32_t *pBufferSize, |
| UErrorCode *status) |
| { |
| if (status == NULL || U_FAILURE(*status)){ |
| return NULL; |
| } |
| if (bi == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| if (pBufferSize != NULL) { |
| int32_t inputSize = *pBufferSize; |
| *pBufferSize = 1; |
| if (inputSize == 0) { |
| return NULL; // preflighting for deprecated functionality |
| } |
| } |
| BreakIterator *newBI = ((BreakIterator *)bi)->clone(); |
| if (newBI == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| } else { |
| *status = U_SAFECLONE_ALLOCATED_WARNING; |
| } |
| return (UBreakIterator *)newBI; |
| } |
| |
| |
| |
| U_CAPI void U_EXPORT2 |
| ubrk_close(UBreakIterator *bi) |
| { |
| delete (BreakIterator *)bi; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ubrk_setText(UBreakIterator* bi, |
| const UChar* text, |
| int32_t textLength, |
| UErrorCode* status) |
| { |
| UText ut = UTEXT_INITIALIZER; |
| utext_openUChars(&ut, text, textLength, status); |
| ((BreakIterator*)bi)->setText(&ut, *status); |
| // A stack allocated UText wrapping a UChar * string |
| // can be dumped without explicitly closing it. |
| } |
| |
| |
| |
| U_CAPI void U_EXPORT2 |
| ubrk_setUText(UBreakIterator *bi, |
| UText *text, |
| UErrorCode *status) |
| { |
| ((BreakIterator*)bi)->setText(text, *status); |
| } |
| |
| |
| |
| |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_current(const UBreakIterator *bi) |
| { |
| |
| return ((BreakIterator*)bi)->current(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_next(UBreakIterator *bi) |
| { |
| |
| return ((BreakIterator*)bi)->next(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_previous(UBreakIterator *bi) |
| { |
| |
| return ((BreakIterator*)bi)->previous(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_first(UBreakIterator *bi) |
| { |
| |
| return ((BreakIterator*)bi)->first(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_last(UBreakIterator *bi) |
| { |
| |
| return ((BreakIterator*)bi)->last(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_preceding(UBreakIterator *bi, |
| int32_t offset) |
| { |
| |
| return ((BreakIterator*)bi)->preceding(offset); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_following(UBreakIterator *bi, |
| int32_t offset) |
| { |
| |
| return ((BreakIterator*)bi)->following(offset); |
| } |
| |
| U_CAPI const char* U_EXPORT2 |
| ubrk_getAvailable(int32_t index) |
| { |
| |
| return uloc_getAvailable(index); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_countAvailable() |
| { |
| |
| return uloc_countAvailable(); |
| } |
| |
| |
| U_CAPI UBool U_EXPORT2 |
| ubrk_isBoundary(UBreakIterator *bi, int32_t offset) |
| { |
| return ((BreakIterator*)bi)->isBoundary(offset); |
| } |
| |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_getRuleStatus(UBreakIterator *bi) |
| { |
| return ((BreakIterator*)bi)->getRuleStatus(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status) |
| { |
| return ((BreakIterator*)bi)->getRuleStatusVec(fillInVec, capacity, *status); |
| } |
| |
| |
| U_CAPI const char* U_EXPORT2 |
| ubrk_getLocaleByType(const UBreakIterator *bi, |
| ULocDataLocaleType type, |
| UErrorCode* status) |
| { |
| if (bi == NULL) { |
| if (U_SUCCESS(*status)) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return NULL; |
| } |
| return ((BreakIterator*)bi)->getLocaleID(type, *status); |
| } |
| |
| |
| void ubrk_refreshUText(UBreakIterator *bi, |
| UText *text, |
| UErrorCode *status) |
| { |
| BreakIterator *bii = reinterpret_cast<BreakIterator *>(bi); |
| bii->refreshInputText(text, *status); |
| } |
| |
| |
| |
| #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ |