Index: source/i18n/filteredbrk.cpp |
diff --git a/source/i18n/filteredbrk.cpp b/source/i18n/filteredbrk.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..43b2d5337bb4a80b0ea26d432626f0cf9f3c3875 |
--- /dev/null |
+++ b/source/i18n/filteredbrk.cpp |
@@ -0,0 +1,521 @@ |
+/* |
+******************************************************************************* |
+* Copyright (C) 2014, International Business Machines Corporation and |
+* others. All Rights Reserved. |
+******************************************************************************* |
+*/ |
+ |
+#include "unicode/utypes.h" |
+#if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILTERED_BREAK_ITERATION |
+ |
+#include "cmemory.h" |
+ |
+#include "unicode/filteredbrk.h" |
+#include "unicode/ucharstriebuilder.h" |
+#include "unicode/ures.h" |
+ |
+#include "uresimp.h" // ures_getByKeyWithFallback |
+#include "ubrkimpl.h" // U_ICUDATA_BRKITR |
+#include "uvector.h" |
+#include "cmemory.h" |
+ |
+U_NAMESPACE_BEGIN |
+ |
+#ifndef FB_DEBUG |
+#define FB_DEBUG 0 |
+#endif |
+ |
+#if FB_DEBUG |
+#include <stdio.h> |
+static void _fb_trace(const char *m, const UnicodeString *s, UBool b, int32_t d, const char *f, int l) { |
+ char buf[2048]; |
+ if(s) { |
+ s->extract(0,s->length(),buf,2048); |
+ } else { |
+ strcpy(buf,"NULL"); |
+ } |
+ fprintf(stderr,"%s:%d: %s. s='%s'(%p), b=%c, d=%d\n", |
+ f, l, m, buf, (const void*)s, b?'T':'F',(int)d); |
+} |
+ |
+#define FB_TRACE(m,s,b,d) _fb_trace(m,s,b,d,__FILE__,__LINE__) |
+#else |
+#define FB_TRACE(m,s,b,d) |
+#endif |
+ |
+static int8_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) { |
+ const UnicodeString &a = *(const UnicodeString*)t1.pointer; |
+ const UnicodeString &b = *(const UnicodeString*)t2.pointer; |
+ return a.compare(b); |
+} |
+ |
+/** |
+ * A UVector which implements a set of strings. |
+ */ |
+class U_I18N_API UStringSet : public UVector { |
+ public: |
+ UStringSet(UErrorCode &status) : UVector(uprv_deleteUObject, |
+ uhash_compareUnicodeString, |
+ 1, |
+ status) {} |
+ virtual ~UStringSet(); |
+ /** |
+ * Is this UnicodeSet contained? |
+ */ |
+ inline UBool contains(const UnicodeString& s) { |
+ return contains((void*) &s); |
+ } |
+ using UVector::contains; |
+ /** |
+ * Return the ith UnicodeString alias |
+ */ |
+ inline const UnicodeString* getStringAt(int32_t i) const { |
+ return (const UnicodeString*)elementAt(i); |
+ } |
+ /** |
+ * Adopt the UnicodeString if not already contained. |
+ * Caller no longer owns the pointer in any case. |
+ * @return true if adopted successfully, false otherwise (error, or else duplicate) |
+ */ |
+ inline UBool adopt(UnicodeString *str, UErrorCode &status) { |
+ if(U_FAILURE(status) || contains(*str)) { |
+ delete str; |
+ return false; |
+ } else { |
+ sortedInsert(str, compareUnicodeString, status); |
+ if(U_FAILURE(status)) { |
+ delete str; |
+ return false; |
+ } |
+ return true; |
+ } |
+ } |
+ /** |
+ * Add by value. |
+ * @return true if successfully adopted. |
+ */ |
+ inline UBool add(const UnicodeString& str, UErrorCode &status) { |
+ if(U_FAILURE(status)) return false; |
+ UnicodeString *t = new UnicodeString(str); |
+ if(t==NULL) { |
+ status = U_MEMORY_ALLOCATION_ERROR; return false; |
+ } |
+ return adopt(t, status); |
+ } |
+ /** |
+ * Remove this string. |
+ * @return true if successfully removed, false otherwise (error, or else it wasn't there) |
+ */ |
+ inline UBool remove(const UnicodeString &s, UErrorCode &status) { |
+ if(U_FAILURE(status)) return false; |
+ return removeElement((void*) &s); |
+ } |
+}; |
+ |
+/** |
+ * Virtual, won't be inlined |
+ */ |
+UStringSet::~UStringSet() {} |
+ |
+ |
+static const int32_t kPARTIAL = (1<<0); //< partial - need to run through forward trie |
+static const int32_t kMATCH = (1<<1); //< exact match - skip this one. |
+static const int32_t kSuppressInReverse = (1<<0); |
+static const int32_t kAddToForward = (1<<1); |
+static const UChar kFULLSTOP = 0x002E; // '.' |
+ |
+class SimpleFilteredSentenceBreakIterator : public BreakIterator { |
+public: |
+ SimpleFilteredSentenceBreakIterator(BreakIterator *adopt, UCharsTrie *forwards, UCharsTrie *backwards, UErrorCode &status); |
+ SimpleFilteredSentenceBreakIterator(const SimpleFilteredSentenceBreakIterator& other); |
+ virtual ~SimpleFilteredSentenceBreakIterator(); |
+private: |
+ LocalPointer<BreakIterator> fDelegate; |
+ LocalUTextPointer fText; |
+ LocalPointer<UCharsTrie> fBackwardsTrie; // i.e. ".srM" for Mrs. |
+ LocalPointer<UCharsTrie> fForwardsPartialTrie; // Has ".a" for "a.M." |
+ |
+ /* -- subclass interface -- */ |
+public: |
+ /* -- cloning and other subclass stuff -- */ |
+ virtual BreakIterator * createBufferClone(void * /*stackBuffer*/, |
+ int32_t &/*BufferSize*/, |
+ UErrorCode &status) { |
+ // for now - always deep clone |
+ status = U_SAFECLONE_ALLOCATED_WARNING; |
+ return clone(); |
+ } |
+ virtual BreakIterator* clone(void) const { return new SimpleFilteredSentenceBreakIterator(*this); } |
+ virtual UClassID getDynamicClassID(void) const { return NULL; } |
+ virtual UBool operator==(const BreakIterator& o) const { if(*this==o) return true; return false; } |
+ |
+ /* -- text modifying -- */ |
+ virtual void setText(UText *text, UErrorCode &status) { fDelegate->setText(text,status); } |
+ virtual BreakIterator &refreshInputText(UText *input, UErrorCode &status) { fDelegate->refreshInputText(input,status); return *this; } |
+ virtual void adoptText(CharacterIterator* it) { fDelegate->adoptText(it); } |
+ virtual void setText(const UnicodeString &text) { fDelegate->setText(text); } |
+ |
+ /* -- other functions that are just delegated -- */ |
+ virtual UText *getUText(UText *fillIn, UErrorCode &status) const { return fDelegate->getUText(fillIn,status); } |
+ virtual CharacterIterator& getText(void) const { return fDelegate->getText(); } |
+ |
+ /* -- ITERATION -- */ |
+ virtual int32_t first(void) { return fDelegate->first(); } |
+ virtual int32_t preceding(int32_t /*offset*/) { /* TODO: not implemented */ return UBRK_DONE; } |
+ virtual int32_t previous(void) { /* TODO: not implemented */ return UBRK_DONE; } |
+ virtual UBool isBoundary(int32_t offset) { return fDelegate->isBoundary(offset); } |
+ virtual int32_t current(void) const { return fDelegate->current(); } |
+ |
+ virtual int32_t next(void); |
+ |
+ virtual int32_t next(int32_t /*n*/) { /* TODO: not implemented */ return UBRK_DONE; } |
+ virtual int32_t following(int32_t /*offset*/) { /* TODO: not implemented */ return UBRK_DONE; } |
+ virtual int32_t last(void) { return fDelegate->last(); } |
+ |
+}; |
+ |
+SimpleFilteredSentenceBreakIterator::SimpleFilteredSentenceBreakIterator(const SimpleFilteredSentenceBreakIterator& other) |
+ : BreakIterator(other), fDelegate(other.fDelegate->clone()) |
+{ |
+ /* |
+ TODO: not able to clone Tries. Should be a refcounted hidden master instead. |
+ if(other.fBackwardsTrie.isValid()) { |
+ fBackwardsTrie.adoptInstead(other.fBackwardsTrie->clone()); |
+ } |
+ if(other.fForwardsPartialTrie.isValid()) { |
+ fForwardsPartialTrie.adoptInstead(other.fForwardsPartialTrie->clone()); |
+ } |
+ */ |
+} |
+ |
+ |
+SimpleFilteredSentenceBreakIterator::SimpleFilteredSentenceBreakIterator(BreakIterator *adopt, UCharsTrie *forwards, UCharsTrie *backwards, UErrorCode &status) : |
+ BreakIterator(adopt->getLocale(ULOC_VALID_LOCALE,status),adopt->getLocale(ULOC_ACTUAL_LOCALE,status)), |
+ fDelegate(adopt), |
+ fBackwardsTrie(backwards), |
+ fForwardsPartialTrie(forwards) |
+{ |
+ // all set.. |
+} |
+ |
+SimpleFilteredSentenceBreakIterator::~SimpleFilteredSentenceBreakIterator() {} |
+ |
+int32_t SimpleFilteredSentenceBreakIterator::next() { |
+ int32_t n = fDelegate->next(); |
+ if(n == UBRK_DONE || // at end or |
+ fBackwardsTrie.isNull()) { // .. no backwards table loaded == no exceptions |
+ return n; |
+ } |
+ // OK, do we need to break here? |
+ UErrorCode status = U_ZERO_ERROR; |
+ // refresh text |
+ fText.adoptInstead(fDelegate->getUText(fText.orphan(), status)); |
+ //if(debug2) u_printf("str, native len=%d\n", utext_nativeLength(fText.getAlias())); |
+ do { // outer loop runs once per underlying break (from fDelegate). |
+ // loops while 'n' points to an exception. |
+ utext_setNativeIndex(fText.getAlias(), n); // from n.. |
+ fBackwardsTrie->reset(); |
+ UChar32 uch; |
+ //if(debug2) u_printf(" n@ %d\n", n); |
+ // Assume a space is following the '.' (so we handle the case: "Mr. /Brown") |
+ if((uch=utext_previous32(fText.getAlias()))==(UChar32)0x0020) { // TODO: skip a class of chars here?? |
+ // TODO only do this the 1st time? |
+ //if(debug2) u_printf("skipping prev: |%C| \n", (UChar)uch); |
+ } else { |
+ //if(debug2) u_printf("not skipping prev: |%C| \n", (UChar)uch); |
+ uch = utext_next32(fText.getAlias()); |
+ //if(debug2) u_printf(" -> : |%C| \n", (UChar)uch); |
+ } |
+ UStringTrieResult r = USTRINGTRIE_INTERMEDIATE_VALUE; |
+ |
+ int32_t bestPosn = -1; |
+ int32_t bestValue = -1; |
+ |
+ while((uch=utext_previous32(fText.getAlias()))!=U_SENTINEL && // more to consume backwards and.. |
+ USTRINGTRIE_HAS_NEXT(r=fBackwardsTrie->nextForCodePoint(uch))) {// more in the trie |
+ if(USTRINGTRIE_HAS_VALUE(r)) { // remember the best match so far |
+ bestPosn = utext_getNativeIndex(fText.getAlias()); |
+ bestValue = fBackwardsTrie->getValue(); |
+ } |
+ //if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (UChar)uch, r, utext_getNativeIndex(fText.getAlias())); |
+ } |
+ |
+ if(USTRINGTRIE_MATCHES(r)) { // exact match? |
+ //if(debug2) u_printf("rev<?/%C/?end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue); |
+ bestValue = fBackwardsTrie->getValue(); |
+ bestPosn = utext_getNativeIndex(fText.getAlias()); |
+ //if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue); |
+ } |
+ |
+ if(bestPosn>=0) { |
+ //if(debug2) u_printf("rev< /%C/ end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue); |
+ |
+ //if(USTRINGTRIE_MATCHES(r)) { // matched - so, now what? |
+ //int32_t bestValue = fBackwardsTrie->getValue(); |
+ ////if(debug2) u_printf("rev< /%C/ matched, skip..%d bestValue=%d\n", (UChar)uch, r, bestValue); |
+ |
+ if(bestValue == kMATCH) { // exact match! |
+ //if(debug2) u_printf(" exact backward match\n"); |
+ n = fDelegate->next(); // skip this one. Find the next lowerlevel break. |
+ if(n==UBRK_DONE) return n; |
+ continue; // See if the next is another exception. |
+ } else if(bestValue == kPARTIAL |
+ && fForwardsPartialTrie.isValid()) { // make sure there's a forward trie |
+ //if(debug2) u_printf(" partial backward match\n"); |
+ // We matched the "Ph." in "Ph.D." - now we need to run everything through the forwards trie |
+ // to see if it matches something going forward. |
+ fForwardsPartialTrie->reset(); |
+ UStringTrieResult rfwd = USTRINGTRIE_INTERMEDIATE_VALUE; |
+ utext_setNativeIndex(fText.getAlias(), bestPosn); // hope that's close .. |
+ //if(debug2) u_printf("Retrying at %d\n", bestPosn); |
+ while((uch=utext_next32(fText.getAlias()))!=U_SENTINEL && |
+ USTRINGTRIE_HAS_NEXT(rfwd=fForwardsPartialTrie->nextForCodePoint(uch))) { |
+ //if(debug2) u_printf("fwd> /%C/ cont?%d @%d\n", (UChar)uch, rfwd, utext_getNativeIndex(fText.getAlias())); |
+ } |
+ if(USTRINGTRIE_MATCHES(rfwd)) { |
+ //if(debug2) u_printf("fwd> /%C/ == forward match!\n", (UChar)uch); |
+ // only full matches here, nothing to check |
+ // skip the next: |
+ n = fDelegate->next(); |
+ if(n==UBRK_DONE) return n; |
+ continue; |
+ } else { |
+ //if(debug2) u_printf("fwd> /%C/ no match.\n", (UChar)uch); |
+ // no match (no exception) -return the 'underlying' break |
+ return n; |
+ } |
+ } else { |
+ return n; // internal error and/or no forwards trie |
+ } |
+ } else { |
+ //if(debug2) u_printf("rev< /%C/ .. no match..%d\n", (UChar)uch, r); // no best match |
+ return n; // No match - so exit. Not an exception. |
+ } |
+ } while(n != UBRK_DONE); |
+ return n; |
+} |
+ |
+/** |
+ * Concrete implementation of builder class. |
+ */ |
+class U_I18N_API SimpleFilteredBreakIteratorBuilder : public FilteredBreakIteratorBuilder { |
+public: |
+ virtual ~SimpleFilteredBreakIteratorBuilder(); |
+ SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status); |
+ SimpleFilteredBreakIteratorBuilder(UErrorCode &status); |
+ virtual UBool suppressBreakAfter(const UnicodeString& exception, UErrorCode& status); |
+ virtual UBool unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status); |
+ virtual BreakIterator *build(BreakIterator* adoptBreakIterator, UErrorCode& status); |
+private: |
+ UStringSet fSet; |
+}; |
+ |
+SimpleFilteredBreakIteratorBuilder::~SimpleFilteredBreakIteratorBuilder() |
+{ |
+} |
+ |
+SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder(UErrorCode &status) |
+ : fSet(status) |
+{ |
+} |
+ |
+SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status) |
+ : fSet(status) |
+{ |
+ if(U_SUCCESS(status)) { |
+ LocalUResourceBundlePointer b(ures_open(U_ICUDATA_BRKITR, fromLocale.getBaseName(), &status)); |
+ LocalUResourceBundlePointer exceptions(ures_getByKeyWithFallback(b.getAlias(), "exceptions", NULL, &status)); |
+ LocalUResourceBundlePointer breaks(ures_getByKeyWithFallback(exceptions.getAlias(), "SentenceBreak", NULL, &status)); |
+ if(U_FAILURE(status)) return; // leaves the builder empty, if you try to use it. |
+ |
+ LocalUResourceBundlePointer strs; |
+ UErrorCode subStatus = status; |
+ do { |
+ strs.adoptInstead(ures_getNextResource(breaks.getAlias(), strs.orphan(), &subStatus)); |
+ if(strs.isValid() && U_SUCCESS(subStatus)) { |
+ UnicodeString str(ures_getUnicodeString(strs.getAlias(), &status)); |
+ suppressBreakAfter(str, status); // load the string |
+ } |
+ } while (strs.isValid() && U_SUCCESS(subStatus)); |
+ if(U_FAILURE(subStatus)&&subStatus!=U_INDEX_OUTOFBOUNDS_ERROR&&U_SUCCESS(status)) { |
+ status = subStatus; |
+ } |
+ } |
+} |
+ |
+UBool |
+SimpleFilteredBreakIteratorBuilder::suppressBreakAfter(const UnicodeString& exception, UErrorCode& status) |
+{ |
+ UBool r = fSet.add(exception, status); |
+ FB_TRACE("suppressBreakAfter",&exception,r,0); |
+ return r; |
+} |
+ |
+UBool |
+SimpleFilteredBreakIteratorBuilder::unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status) |
+{ |
+ UBool r = fSet.remove(exception, status); |
+ FB_TRACE("unsuppressBreakAfter",&exception,r,0); |
+ return r; |
+} |
+ |
+/** |
+ * Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly. |
+ * Work around this. |
+ * |
+ * Note: "new UnicodeString[subCount]" ends up calling global operator new |
+ * on MSVC2012 for some reason. |
+ */ |
+static inline UnicodeString* newUnicodeStringArray(size_t count) { |
+ return new UnicodeString[count ? count : 1]; |
+} |
+ |
+BreakIterator * |
+SimpleFilteredBreakIteratorBuilder::build(BreakIterator* adoptBreakIterator, UErrorCode& status) { |
+ LocalPointer<BreakIterator> adopt(adoptBreakIterator); |
+ |
+ if(U_FAILURE(status)) { |
+ return NULL; |
+ } |
+ |
+ LocalPointer<UCharsTrieBuilder> builder(new UCharsTrieBuilder(status)); |
+ LocalPointer<UCharsTrieBuilder> builder2(new UCharsTrieBuilder(status)); |
+ |
+ int32_t revCount = 0; |
+ int32_t fwdCount = 0; |
+ |
+ int32_t subCount = fSet.size(); |
+ |
+ UnicodeString *ustrs_ptr = newUnicodeStringArray(subCount); |
+ |
+ LocalArray<UnicodeString> ustrs(ustrs_ptr); |
+ |
+ LocalMemory<int> partials; |
+ partials.allocateInsteadAndReset(subCount); |
+ |
+ LocalPointer<UCharsTrie> backwardsTrie; // i.e. ".srM" for Mrs. |
+ LocalPointer<UCharsTrie> forwardsPartialTrie; // Has ".a" for "a.M." |
+ |
+ int n=0; |
+ for ( int32_t i = 0; |
+ i<fSet.size(); |
+ i++) { |
+ const UnicodeString *abbr = fSet.getStringAt(i); |
+ if(abbr) { |
+ FB_TRACE("build",abbr,TRUE,i); |
+ ustrs[n] = *abbr; // copy by value |
+ FB_TRACE("ustrs[n]",&ustrs[n],TRUE,i); |
+ } else { |
+ FB_TRACE("build",abbr,FALSE,i); |
+ status = U_MEMORY_ALLOCATION_ERROR; |
+ return NULL; |
+ } |
+ partials[n] = 0; // default: not partial |
+ n++; |
+ } |
+ // first pass - find partials. |
+ for(int i=0;i<subCount;i++) { |
+ int nn = ustrs[i].indexOf(kFULLSTOP); // TODO: non-'.' abbreviations |
+ if(nn>-1 && (nn+1)!=ustrs[i].length()) { |
+ FB_TRACE("partial",&ustrs[i],FALSE,i); |
+ // is partial. |
+ // is it unique? |
+ int sameAs = -1; |
+ for(int j=0;j<subCount;j++) { |
+ if(j==i) continue; |
+ if(ustrs[i].compare(0,nn+1,ustrs[j],0,nn+1)==0) { |
+ FB_TRACE("prefix",&ustrs[j],FALSE,nn+1); |
+ //UBool otherIsPartial = ((nn+1)!=ustrs[j].length()); // true if ustrs[j] doesn't end at nn |
+ if(partials[j]==0) { // hasn't been processed yet |
+ partials[j] = kSuppressInReverse | kAddToForward; |
+ FB_TRACE("suppressing",&ustrs[j],FALSE,j); |
+ } else if(partials[j] & kSuppressInReverse) { |
+ sameAs = j; // the other entry is already in the reverse table. |
+ } |
+ } |
+ } |
+ FB_TRACE("for partial same-",&ustrs[i],FALSE,sameAs); |
+ FB_TRACE(" == partial #",&ustrs[i],FALSE,partials[i]); |
+ UnicodeString prefix(ustrs[i], 0, nn+1); |
+ if(sameAs == -1 && partials[i] == 0) { |
+ // first one - add the prefix to the reverse table. |
+ prefix.reverse(); |
+ builder->add(prefix, kPARTIAL, status); |
+ revCount++; |
+ FB_TRACE("Added partial",&prefix,FALSE, i); |
+ FB_TRACE(u_errorName(status),&ustrs[i],FALSE,i); |
+ partials[i] = kSuppressInReverse | kAddToForward; |
+ } else { |
+ FB_TRACE("NOT adding partial",&prefix,FALSE, i); |
+ FB_TRACE(u_errorName(status),&ustrs[i],FALSE,i); |
+ } |
+ } |
+ } |
+ for(int i=0;i<subCount;i++) { |
+ if(partials[i]==0) { |
+ ustrs[i].reverse(); |
+ builder->add(ustrs[i], kMATCH, status); |
+ revCount++; |
+ FB_TRACE(u_errorName(status), &ustrs[i], FALSE, i); |
+ } else { |
+ FB_TRACE("Adding fwd",&ustrs[i], FALSE, i); |
+ |
+ // an optimization would be to only add the portion after the '.' |
+ // for example, for "Ph.D." we store ".hP" in the reverse table. We could just store "D." in the forward, |
+ // instead of "Ph.D." since we already know the "Ph." part is a match. |
+ // would need the trie to be able to hold 0-length strings, though. |
+ builder2->add(ustrs[i], kMATCH, status); // forward |
+ fwdCount++; |
+ //ustrs[i].reverse(); |
+ ////if(debug2) u_printf("SUPPRESS- not Added(%d): /%S/ status=%s\n",partials[i], ustrs[i].getTerminatedBuffer(), u_errorName(status)); |
+ } |
+ } |
+ FB_TRACE("AbbrCount",NULL,FALSE, subCount); |
+ |
+ if(revCount>0) { |
+ backwardsTrie.adoptInstead(builder->build(USTRINGTRIE_BUILD_FAST, status)); |
+ if(U_FAILURE(status)) { |
+ FB_TRACE(u_errorName(status),NULL,FALSE, -1); |
+ return NULL; |
+ } |
+ } |
+ |
+ if(fwdCount>0) { |
+ forwardsPartialTrie.adoptInstead(builder2->build(USTRINGTRIE_BUILD_FAST, status)); |
+ if(U_FAILURE(status)) { |
+ FB_TRACE(u_errorName(status),NULL,FALSE, -1); |
+ return NULL; |
+ } |
+ } |
+ |
+ return new SimpleFilteredSentenceBreakIterator(adopt.orphan(), forwardsPartialTrie.orphan(), backwardsTrie.orphan(), status); |
+} |
+ |
+ |
+// ----------- Base class implementation |
+ |
+FilteredBreakIteratorBuilder::FilteredBreakIteratorBuilder() { |
+} |
+ |
+FilteredBreakIteratorBuilder::~FilteredBreakIteratorBuilder() { |
+} |
+ |
+FilteredBreakIteratorBuilder * |
+FilteredBreakIteratorBuilder::createInstance(const Locale& where, UErrorCode& status) { |
+ if(U_FAILURE(status)) return NULL; |
+ LocalPointer<FilteredBreakIteratorBuilder> ret(new SimpleFilteredBreakIteratorBuilder(where, status)); |
+ if(U_SUCCESS(status) && !ret.isValid()) status = U_MEMORY_ALLOCATION_ERROR; |
+ return ret.orphan(); |
+} |
+ |
+FilteredBreakIteratorBuilder * |
+FilteredBreakIteratorBuilder::createInstance(UErrorCode& status) { |
+ if(U_FAILURE(status)) return NULL; |
+ LocalPointer<FilteredBreakIteratorBuilder> ret(new SimpleFilteredBreakIteratorBuilder(status)); |
+ if(U_SUCCESS(status) && !ret.isValid()) status = U_MEMORY_ALLOCATION_ERROR; |
+ return ret.orphan(); |
+} |
+ |
+U_NAMESPACE_END |
+ |
+#endif //#if !UCONFIG_NO_BREAK_ITERATION && U_HAVE_STD_STRING && !UCONFIG_NO_FILTERED_BREAK_ITERATION |