#include "unicode/filteredbrk.h"
#if !UCONFIG_NO_BREAK_ITERATION && U_HAVE_STD_STRING && !UCONFIG_NO_FILTERED_BREAK_ITERATION
#include <unicode/ucharstriebuilder.h>
#include <set>
#include <string>
#include <functional>
#include "uresimp.h"
#include "ubrkimpl.h"
U_NAMESPACE_BEGIN
using namespace std;
static const int32_t kPARTIAL = (1<<0); static const int32_t kMATCH = (1<<1); static const int32_t kSuppressInReverse = (1<<0);
static const int32_t kAddToForward = (1<<1);
static const UChar kFULLSTOP = 0x002E;
class ULISentenceBreakIterator : public BreakIterator {
public:
ULISentenceBreakIterator(BreakIterator *adopt, UCharsTrie *forwards, UCharsTrie *backwards, UErrorCode &status);
virtual ~ULISentenceBreakIterator() {}
ULISentenceBreakIterator(const ULISentenceBreakIterator& other);
private:
LocalPointer<BreakIterator> fDelegate;
LocalUTextPointer fText;
LocalPointer<UCharsTrie> fBackwardsTrie; LocalPointer<UCharsTrie> fForwardsPartialTrie;
public:
virtual BreakIterator * createBufferClone(void * ,
int32_t &,
UErrorCode &status) {
status = U_SAFECLONE_ALLOCATED_WARNING;
return clone();
}
virtual BreakIterator* clone(void) const { return new ULISentenceBreakIterator(*this); }
virtual UClassID getDynamicClassID(void) const { return NULL; }
virtual UBool operator==(const BreakIterator& o) const { if(*this==o) return true; return false; }
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); }
virtual UText *getUText(UText *fillIn, UErrorCode &status) const { return fDelegate->getUText(fillIn,status); }
virtual CharacterIterator& getText(void) const { return fDelegate->getText(); }
virtual int32_t first(void) { return fDelegate->first(); }
virtual int32_t preceding(int32_t offset) { return fDelegate->preceding(offset); }
virtual int32_t previous(void) { return fDelegate->previous(); }
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) { return fDelegate->next(n); }
virtual int32_t following(int32_t offset) { return fDelegate->following(offset); }
virtual int32_t last(void) { return fDelegate->last(); }
};
ULISentenceBreakIterator::ULISentenceBreakIterator(const ULISentenceBreakIterator& other)
: BreakIterator(other), fDelegate(other.fDelegate->clone())
{
}
ULISentenceBreakIterator::ULISentenceBreakIterator(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)
{
}
int32_t ULISentenceBreakIterator::next() {
int32_t n = fDelegate->next();
if(n == UBRK_DONE || fBackwardsTrie.isNull()) { return n;
}
UErrorCode status = U_ZERO_ERROR;
fText.adoptInstead(fDelegate->getUText(fText.orphan(), status));
do { utext_setNativeIndex(fText.getAlias(), n); fBackwardsTrie->reset();
UChar32 uch;
if((uch=utext_previous32(fText.getAlias()))==(UChar32)0x0020) { } else {
uch = utext_next32(fText.getAlias());
}
UStringTrieResult r = USTRINGTRIE_INTERMEDIATE_VALUE;
int32_t bestPosn = -1;
int32_t bestValue = -1;
while((uch=utext_previous32(fText.getAlias()))!=U_SENTINEL && USTRINGTRIE_HAS_NEXT(r=fBackwardsTrie->nextForCodePoint(uch))) { if(USTRINGTRIE_HAS_VALUE(r)) { bestPosn = utext_getNativeIndex(fText.getAlias());
bestValue = fBackwardsTrie->getValue();
}
}
if(USTRINGTRIE_MATCHES(r)) { bestValue = fBackwardsTrie->getValue();
bestPosn = utext_getNativeIndex(fText.getAlias());
}
if(bestPosn>=0) {
if(bestValue == kMATCH) { n = fDelegate->next(); if(n==UBRK_DONE) return n;
continue; } else if(bestValue == kPARTIAL
&& fForwardsPartialTrie.isValid()) { fForwardsPartialTrie->reset();
UStringTrieResult rfwd = USTRINGTRIE_INTERMEDIATE_VALUE;
utext_setNativeIndex(fText.getAlias(), bestPosn); while((uch=utext_next32(fText.getAlias()))!=U_SENTINEL &&
USTRINGTRIE_HAS_NEXT(rfwd=fForwardsPartialTrie->nextForCodePoint(uch))) {
}
if(USTRINGTRIE_MATCHES(rfwd)) {
n = fDelegate->next();
if(n==UBRK_DONE) return n;
continue;
} else {
return n;
}
} else {
return n; }
} else {
return n; }
} while(n != UBRK_DONE);
return n;
}
U_NAMESPACE_END
#if 0
namespace std {
template <> struct hash<icu::UnicodeString> {
size_t operator()( const UnicodeString& str ) const {
return (size_t)str.hashCode();
}
};
}
#endif
U_NAMESPACE_BEGIN
class SimpleFilteredBreakIteratorBuilder : public FilteredBreakIteratorBuilder {
public:
virtual ~SimpleFilteredBreakIteratorBuilder();
SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status);
SimpleFilteredBreakIteratorBuilder();
virtual UBool suppressBreakAfter(const UnicodeString& exception, UErrorCode& status);
virtual UBool unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status);
virtual BreakIterator *build(BreakIterator* adoptBreakIterator, UErrorCode& status);
private:
set<UnicodeString> fSet;
};
SimpleFilteredBreakIteratorBuilder::~SimpleFilteredBreakIteratorBuilder()
{
}
SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status)
: fSet()
{
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;
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); }
} while (strs.isValid() && U_SUCCESS(subStatus));
if(U_FAILURE(subStatus)&&subStatus!=U_INDEX_OUTOFBOUNDS_ERROR&&U_SUCCESS(status)) {
status = subStatus;
}
}
}
SimpleFilteredBreakIteratorBuilder::SimpleFilteredBreakIteratorBuilder()
: fSet()
{
}
UBool
SimpleFilteredBreakIteratorBuilder::suppressBreakAfter(const UnicodeString& exception, UErrorCode& status)
{
if( U_FAILURE(status) ) return FALSE;
return fSet.insert(exception).second;
}
UBool
SimpleFilteredBreakIteratorBuilder::unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status)
{
if( U_FAILURE(status) ) return FALSE;
return ((fSet.erase(exception)) != 0);
}
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();
LocalArray<UnicodeString> ustrs(new UnicodeString[subCount]);
LocalArray<int> partials(new int[subCount]);
LocalPointer<UCharsTrie> backwardsTrie; LocalPointer<UCharsTrie> forwardsPartialTrie;
int n=0;
for ( set<UnicodeString>::iterator i = fSet.begin();
i != fSet.end();
i++) {
const UnicodeString &abbr = *i;
ustrs[n] = abbr;
partials[n] = 0; n++;
}
for(int i=0;i<subCount;i++) {
int nn = ustrs[i].indexOf(kFULLSTOP); if(nn>-1 && (nn+1)!=ustrs[i].length()) {
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) {
if(partials[j]==0) { partials[j] = kSuppressInReverse | kAddToForward;
} else if(partials[j] & kSuppressInReverse) {
sameAs = j; }
}
}
UnicodeString prefix(ustrs[i], 0, nn+1);
if(sameAs == -1 && partials[i] == 0) {
prefix.reverse();
builder->add(prefix, kPARTIAL, status);
revCount++;
partials[i] = kSuppressInReverse | kAddToForward;
} else {
}
}
}
for(int i=0;i<subCount;i++) {
if(partials[i]==0) {
ustrs[i].reverse();
builder->add(ustrs[i], kMATCH, status);
revCount++;
} else {
builder2->add(ustrs[i], kMATCH, status); fwdCount++;
}
}
if(revCount>0) {
backwardsTrie.adoptInstead(builder->build(USTRINGTRIE_BUILD_FAST, status));
if(U_FAILURE(status)) {
return NULL;
}
}
if(fwdCount>0) {
forwardsPartialTrie.adoptInstead(builder2->build(USTRINGTRIE_BUILD_FAST, status));
if(U_FAILURE(status)) {
return NULL;
}
}
return new ULISentenceBreakIterator(adopt.orphan(), forwardsPartialTrie.orphan(), backwardsTrie.orphan(), status);
}
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(!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());
if(!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