| /* | |
| ********************************************************************** | |
| * Copyright (C) 2008-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ********************************************************************** | |
| * Date Name Description | |
| * 05/11/2008 Andy Heninger Port from Java | |
| ********************************************************************** | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_TRANSLITERATION && !UCONFIG_NO_BREAK_ITERATION | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/brkiter.h" | |
| #include "unicode/localpointer.h" | |
| #include "unicode/uchar.h" | |
| #include "unicode/unifilt.h" | |
| #include "unicode/uniset.h" | |
| #include "brktrans.h" | |
| #include "cmemory.h" | |
| #include "mutex.h" | |
| #include "uprops.h" | |
| #include "uinvchar.h" | |
| #include "util.h" | |
| #include "uvectr32.h" | |
| U_NAMESPACE_BEGIN | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(BreakTransliterator) | |
| static const UChar SPACE = 32; // ' ' | |
| /** | |
| * Constructs a transliterator with the default delimiters '{' and | |
| * '}'. | |
| */ | |
| BreakTransliterator::BreakTransliterator(UnicodeFilter* adoptedFilter) : | |
| Transliterator(UNICODE_STRING("Any-BreakInternal", 17), adoptedFilter), | |
| cachedBI(NULL), cachedBoundaries(NULL), fInsertion(SPACE) { | |
| } | |
| /** | |
| * Destructor. | |
| */ | |
| BreakTransliterator::~BreakTransliterator() { | |
| } | |
| /** | |
| * Copy constructor. | |
| */ | |
| BreakTransliterator::BreakTransliterator(const BreakTransliterator& o) : | |
| Transliterator(o), cachedBI(NULL), cachedBoundaries(NULL), fInsertion(o.fInsertion) { | |
| } | |
| /** | |
| * Transliterator API. | |
| */ | |
| Transliterator* BreakTransliterator::clone(void) const { | |
| return new BreakTransliterator(*this); | |
| } | |
| /** | |
| * Implements {@link Transliterator#handleTransliterate}. | |
| */ | |
| void BreakTransliterator::handleTransliterate(Replaceable& text, UTransPosition& offsets, | |
| UBool isIncremental ) const { | |
| UErrorCode status = U_ZERO_ERROR; | |
| LocalPointer<BreakIterator> bi; | |
| LocalPointer<UVector32> boundaries; | |
| { | |
| Mutex m; | |
| BreakTransliterator *nonConstThis = const_cast<BreakTransliterator *>(this); | |
| boundaries.moveFrom(nonConstThis->cachedBoundaries); | |
| bi.moveFrom(nonConstThis->cachedBI); | |
| } | |
| if (bi.isNull()) { | |
| bi.adoptInstead(BreakIterator::createWordInstance(Locale::getEnglish(), status)); | |
| } | |
| if (boundaries.isNull()) { | |
| boundaries.adoptInstead(new UVector32(status)); | |
| } | |
| if (bi.isNull() || boundaries.isNull() || U_FAILURE(status)) { | |
| return; | |
| } | |
| boundaries->removeAllElements(); | |
| UnicodeString sText = replaceableAsString(text); | |
| bi->setText(sText); | |
| bi->preceding(offsets.start); | |
| // To make things much easier, we will stack the boundaries, and then insert at the end. | |
| // generally, we won't need too many, since we will be filtered. | |
| int32_t boundary; | |
| for(boundary = bi->next(); boundary != UBRK_DONE && boundary < offsets.limit; boundary = bi->next()) { | |
| if (boundary == 0) continue; | |
| // HACK: Check to see that preceeding item was a letter | |
| UChar32 cp = sText.char32At(boundary-1); | |
| int type = u_charType(cp); | |
| //System.out.println(Integer.toString(cp,16) + " (before): " + type); | |
| if ((U_MASK(type) & (U_GC_L_MASK | U_GC_M_MASK)) == 0) continue; | |
| cp = sText.char32At(boundary); | |
| type = u_charType(cp); | |
| //System.out.println(Integer.toString(cp,16) + " (after): " + type); | |
| if ((U_MASK(type) & (U_GC_L_MASK | U_GC_M_MASK)) == 0) continue; | |
| boundaries->addElement(boundary, status); | |
| // printf("Boundary at %d\n", boundary); | |
| } | |
| int delta = 0; | |
| int lastBoundary = 0; | |
| if (boundaries->size() != 0) { // if we found something, adjust | |
| delta = boundaries->size() * fInsertion.length(); | |
| lastBoundary = boundaries->lastElementi(); | |
| // we do this from the end backwards, so that we don't have to keep updating. | |
| while (boundaries->size() > 0) { | |
| boundary = boundaries->popi(); | |
| text.handleReplaceBetween(boundary, boundary, fInsertion); | |
| } | |
| } | |
| // Now fix up the return values | |
| offsets.contextLimit += delta; | |
| offsets.limit += delta; | |
| offsets.start = isIncremental ? lastBoundary + delta : offsets.limit; | |
| // Return break iterator & boundaries vector to the cache. | |
| { | |
| Mutex m; | |
| BreakTransliterator *nonConstThis = const_cast<BreakTransliterator *>(this); | |
| if (nonConstThis->cachedBI.isNull()) { | |
| nonConstThis->cachedBI.moveFrom(bi); | |
| } | |
| if (nonConstThis->cachedBoundaries.isNull()) { | |
| nonConstThis->cachedBoundaries.moveFrom(boundaries); | |
| } | |
| } | |
| // TODO: do something with U_FAILURE(status); | |
| // (need to look at transliterators overall, not just here.) | |
| } | |
| // | |
| // getInsertion() | |
| // | |
| const UnicodeString &BreakTransliterator::getInsertion() const { | |
| return fInsertion; | |
| } | |
| // | |
| // setInsertion() | |
| // | |
| void BreakTransliterator::setInsertion(const UnicodeString &insertion) { | |
| this->fInsertion = insertion; | |
| } | |
| // | |
| // replaceableAsString Hack to let break iterators work | |
| // on the replaceable text from transliterators. | |
| // In practice, the only real Replaceable type that we | |
| // will be seeing is UnicodeString, so this function | |
| // will normally be efficient. | |
| // | |
| UnicodeString BreakTransliterator::replaceableAsString(Replaceable &r) { | |
| UnicodeString s; | |
| UnicodeString *rs = dynamic_cast<UnicodeString *>(&r); | |
| if (rs != NULL) { | |
| s = *rs; | |
| } else { | |
| r.extractBetween(0, r.length(), s); | |
| } | |
| return s; | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_TRANSLITERATION */ |