| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2010-2011, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ******************************************************************************* | |
| * file name: ucharstrieiterator.h | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2010nov15 | |
| * created by: Markus W. Scherer | |
| */ | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #endif // defined(STARBOARD) | |
| #include "unicode/utypes.h" | |
| #include "unicode/ucharstrie.h" | |
| #include "unicode/unistr.h" | |
| #include "uvectr32.h" | |
| U_NAMESPACE_BEGIN | |
| UCharsTrie::Iterator::Iterator(ConstChar16Ptr trieUChars, int32_t maxStringLength, | |
| UErrorCode &errorCode) | |
| : uchars_(trieUChars), | |
| pos_(uchars_), initialPos_(uchars_), | |
| remainingMatchLength_(-1), initialRemainingMatchLength_(-1), | |
| skipValue_(FALSE), | |
| maxLength_(maxStringLength), value_(0), stack_(NULL) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| // stack_ is a pointer so that it's easy to turn ucharstrie.h into | |
| // a public API header for which we would want it to depend only on | |
| // other public headers. | |
| // Unlike UCharsTrie itself, its Iterator performs memory allocations anyway | |
| // via the UnicodeString and UVector32 implementations, so this additional | |
| // cost is minimal. | |
| stack_=new UVector32(errorCode); | |
| if(stack_==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| UCharsTrie::Iterator::Iterator(const UCharsTrie &trie, int32_t maxStringLength, | |
| UErrorCode &errorCode) | |
| : uchars_(trie.uchars_), pos_(trie.pos_), initialPos_(trie.pos_), | |
| remainingMatchLength_(trie.remainingMatchLength_), | |
| initialRemainingMatchLength_(trie.remainingMatchLength_), | |
| skipValue_(FALSE), | |
| maxLength_(maxStringLength), value_(0), stack_(NULL) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| stack_=new UVector32(errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if(stack_==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| int32_t length=remainingMatchLength_; // Actual remaining match length minus 1. | |
| if(length>=0) { | |
| // Pending linear-match node, append remaining UChars to str_. | |
| ++length; | |
| if(maxLength_>0 && length>maxLength_) { | |
| length=maxLength_; // This will leave remainingMatchLength>=0 as a signal. | |
| } | |
| str_.append(pos_, length); | |
| pos_+=length; | |
| remainingMatchLength_-=length; | |
| } | |
| } | |
| UCharsTrie::Iterator::~Iterator() { | |
| delete stack_; | |
| } | |
| UCharsTrie::Iterator & | |
| UCharsTrie::Iterator::reset() { | |
| pos_=initialPos_; | |
| remainingMatchLength_=initialRemainingMatchLength_; | |
| skipValue_=FALSE; | |
| int32_t length=remainingMatchLength_+1; // Remaining match length. | |
| if(maxLength_>0 && length>maxLength_) { | |
| length=maxLength_; | |
| } | |
| str_.truncate(length); | |
| pos_+=length; | |
| remainingMatchLength_-=length; | |
| stack_->setSize(0); | |
| return *this; | |
| } | |
| UBool | |
| UCharsTrie::Iterator::hasNext() const { return pos_!=NULL || !stack_->isEmpty(); } | |
| UBool | |
| UCharsTrie::Iterator::next(UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| const UChar *pos=pos_; | |
| if(pos==NULL) { | |
| if(stack_->isEmpty()) { | |
| return FALSE; | |
| } | |
| // Pop the state off the stack and continue with the next outbound edge of | |
| // the branch node. | |
| int32_t stackSize=stack_->size(); | |
| int32_t length=stack_->elementAti(stackSize-1); | |
| pos=uchars_+stack_->elementAti(stackSize-2); | |
| stack_->setSize(stackSize-2); | |
| str_.truncate(length&0xffff); | |
| length=(int32_t)((uint32_t)length>>16); | |
| if(length>1) { | |
| pos=branchNext(pos, length, errorCode); | |
| if(pos==NULL) { | |
| return TRUE; // Reached a final value. | |
| } | |
| } else { | |
| str_.append(*pos++); | |
| } | |
| } | |
| if(remainingMatchLength_>=0) { | |
| // We only get here if we started in a pending linear-match node | |
| // with more than maxLength remaining units. | |
| return truncateAndStop(); | |
| } | |
| for(;;) { | |
| int32_t node=*pos++; | |
| if(node>=kMinValueLead) { | |
| if(skipValue_) { | |
| pos=skipNodeValue(pos, node); | |
| node&=kNodeTypeMask; | |
| skipValue_=FALSE; | |
| } else { | |
| // Deliver value for the string so far. | |
| UBool isFinal=(UBool)(node>>15); | |
| if(isFinal) { | |
| value_=readValue(pos, node&0x7fff); | |
| } else { | |
| value_=readNodeValue(pos, node); | |
| } | |
| if(isFinal || (maxLength_>0 && str_.length()==maxLength_)) { | |
| pos_=NULL; | |
| } else { | |
| // We cannot skip the value right here because it shares its | |
| // lead unit with a match node which we have to evaluate | |
| // next time. | |
| // Instead, keep pos_ on the node lead unit itself. | |
| pos_=pos-1; | |
| skipValue_=TRUE; | |
| } | |
| return TRUE; | |
| } | |
| } | |
| if(maxLength_>0 && str_.length()==maxLength_) { | |
| return truncateAndStop(); | |
| } | |
| if(node<kMinLinearMatch) { | |
| if(node==0) { | |
| node=*pos++; | |
| } | |
| pos=branchNext(pos, node+1, errorCode); | |
| if(pos==NULL) { | |
| return TRUE; // Reached a final value. | |
| } | |
| } else { | |
| // Linear-match node, append length units to str_. | |
| int32_t length=node-kMinLinearMatch+1; | |
| if(maxLength_>0 && str_.length()+length>maxLength_) { | |
| str_.append(pos, maxLength_-str_.length()); | |
| return truncateAndStop(); | |
| } | |
| str_.append(pos, length); | |
| pos+=length; | |
| } | |
| } | |
| } | |
| // Branch node, needs to take the first outbound edge and push state for the rest. | |
| const UChar * | |
| UCharsTrie::Iterator::branchNext(const UChar *pos, int32_t length, UErrorCode &errorCode) { | |
| while(length>kMaxBranchLinearSubNodeLength) { | |
| ++pos; // ignore the comparison unit | |
| // Push state for the greater-or-equal edge. | |
| stack_->addElement((int32_t)(skipDelta(pos)-uchars_), errorCode); | |
| stack_->addElement(((length-(length>>1))<<16)|str_.length(), errorCode); | |
| // Follow the less-than edge. | |
| length>>=1; | |
| pos=jumpByDelta(pos); | |
| } | |
| // List of key-value pairs where values are either final values or jump deltas. | |
| // Read the first (key, value) pair. | |
| UChar trieUnit=*pos++; | |
| int32_t node=*pos++; | |
| UBool isFinal=(UBool)(node>>15); | |
| int32_t value=readValue(pos, node&=0x7fff); | |
| pos=skipValue(pos, node); | |
| stack_->addElement((int32_t)(pos-uchars_), errorCode); | |
| stack_->addElement(((length-1)<<16)|str_.length(), errorCode); | |
| str_.append(trieUnit); | |
| if(isFinal) { | |
| pos_=NULL; | |
| value_=value; | |
| return NULL; | |
| } else { | |
| return pos+value; | |
| } | |
| } | |
| U_NAMESPACE_END |