1 /* GENERATED SOURCE. DO NOT MODIFY. */ 2 // © 2016 and later: Unicode, Inc. and others. 3 // License & terms of use: http://www.unicode.org/copyright.html#License 4 /* 5 ******************************************************************************* 6 * 7 * Copyright (C) 2004-2010, International Business Machines 8 * Corporation and others. All Rights Reserved. 9 * 10 ******************************************************************************* 11 * file name: ReplaceableContextIterator.java 12 * encoding: US-ASCII 13 * tab size: 8 (not used) 14 * indentation:4 15 * 16 * created on: 2005feb04 17 * created by: Markus W. Scherer 18 * 19 * Implementation of UCaseProps.ContextIterator, iterates over a Replaceable. 20 * Java port of casetrn.cpp/utrans_rep_caseContextIterator(). 21 */ 22 23 package ohos.global.icu.text; 24 25 import ohos.global.icu.impl.UCaseProps; 26 27 /** 28 * Implementation of UCaseProps.ContextIterator, iterates over a Replaceable. 29 * See casetrn.cpp/utrans_rep_caseContextIterator(). 30 * See also UCharacter.StringContextIterator. 31 */ 32 class ReplaceableContextIterator implements UCaseProps.ContextIterator { 33 /** 34 * Constructor. 35 * @param rep Replaceable to iterate over. 36 */ ReplaceableContextIterator()37 ReplaceableContextIterator() { 38 this.rep=null; 39 limit=cpStart=cpLimit=index=contextStart=contextLimit=0; 40 dir=0; 41 reachedLimit=false; 42 } 43 44 /** 45 * Set the text for iteration. 46 * @param rep Iteration text. 47 */ setText(Replaceable rep)48 public void setText(Replaceable rep) { 49 this.rep=rep; 50 limit=contextLimit=rep.length(); 51 cpStart=cpLimit=index=contextStart=0; 52 dir=0; 53 reachedLimit=false; 54 } 55 56 /** 57 * Set the index where nextCaseMapCP() is to start iterating. 58 * @param index Iteration start index for nextCaseMapCP(). 59 */ setIndex(int index)60 public void setIndex(int index) { 61 cpStart=cpLimit=index; 62 this.index=0; 63 dir=0; 64 reachedLimit=false; 65 } 66 67 /** 68 * Get the index of where the code point currently being case-mapped starts. 69 * @return The start index of the current code point. 70 */ getCaseMapCPStart()71 public int getCaseMapCPStart() { 72 return cpStart; 73 } 74 75 /** 76 * Set the iteration limit for nextCaseMapCP() to an index within the string. 77 * If the limit parameter is negative or past the string, then the 78 * string length is restored as the iteration limit. 79 * 80 * @param lim The iteration limit. 81 */ setLimit(int lim)82 public void setLimit(int lim) { 83 if(0<=lim && lim<=rep.length()) { 84 limit=lim; 85 } else { 86 limit=rep.length(); 87 } 88 reachedLimit=false; 89 } 90 91 /** 92 * Set the start and limit indexes for context iteration with next(). 93 * @param contextStart Start of context for next(). 94 * @param contextLimit Limit of context for next(). 95 */ setContextLimits(int contextStart, int contextLimit)96 public void setContextLimits(int contextStart, int contextLimit) { 97 if(contextStart<0) { 98 this.contextStart=0; 99 } else if(contextStart<=rep.length()) { 100 this.contextStart=contextStart; 101 } else { 102 this.contextStart=rep.length(); 103 } 104 if(contextLimit<this.contextStart) { 105 this.contextLimit=this.contextStart; 106 } else if(contextLimit<=rep.length()) { 107 this.contextLimit=contextLimit; 108 } else { 109 this.contextLimit=rep.length(); 110 } 111 reachedLimit=false; 112 } 113 114 /** 115 * Iterate forward through the string to fetch the next code point 116 * to be case-mapped, and set the context indexes for it. 117 * 118 * @return The next code point to be case-mapped, or <0 when the iteration is done. 119 */ nextCaseMapCP()120 public int nextCaseMapCP() { 121 int c; 122 if(cpLimit<limit) { 123 cpStart=cpLimit; 124 c=rep.char32At(cpLimit); 125 cpLimit+=UTF16.getCharCount(c); 126 return c; 127 } else { 128 return -1; 129 } 130 } 131 132 /** 133 * Replace the current code point by its case mapping, 134 * and update the indexes. 135 * 136 * @param text Replacement text. 137 * @return The delta for the change of the text length. 138 */ replace(String text)139 public int replace(String text) { 140 int delta=text.length()-(cpLimit-cpStart); 141 rep.replace(cpStart, cpLimit, text); 142 cpLimit+=delta; 143 limit+=delta; 144 contextLimit+=delta; 145 return delta; 146 } 147 148 /** 149 * Did forward context iteration with next() reach the iteration limit? 150 * @return Boolean value. 151 */ didReachLimit()152 public boolean didReachLimit() { 153 return reachedLimit; 154 } 155 156 // implement UCaseProps.ContextIterator reset(int direction)157 public void reset(int direction) { 158 if(direction>0) { 159 /* reset for forward iteration */ 160 this.dir=1; 161 index=cpLimit; 162 } else if(direction<0) { 163 /* reset for backward iteration */ 164 this.dir=-1; 165 index=cpStart; 166 } else { 167 // not a valid direction 168 this.dir=0; 169 index=0; 170 } 171 reachedLimit=false; 172 } 173 next()174 public int next() { 175 int c; 176 177 if(dir>0) { 178 if(index<contextLimit) { 179 c=rep.char32At(index); 180 index+=UTF16.getCharCount(c); 181 return c; 182 } else { 183 // forward context iteration reached the limit 184 reachedLimit=true; 185 } 186 } else if(dir<0 && index>contextStart) { 187 c=rep.char32At(index-1); 188 index-=UTF16.getCharCount(c); 189 return c; 190 } 191 return -1; 192 } 193 194 // variables 195 protected Replaceable rep; 196 protected int index, limit, cpStart, cpLimit, contextStart, contextLimit; 197 protected int dir; // 0=initial state >0=forward <0=backward 198 protected boolean reachedLimit; 199 } 200