diff options
Diffstat (limited to 'libjava/java/text/FormatCharacterIterator.java')
| -rw-r--r-- | libjava/java/text/FormatCharacterIterator.java | 405 |
1 files changed, 405 insertions, 0 deletions
diff --git a/libjava/java/text/FormatCharacterIterator.java b/libjava/java/text/FormatCharacterIterator.java new file mode 100644 index 00000000000..8693707715c --- /dev/null +++ b/libjava/java/text/FormatCharacterIterator.java @@ -0,0 +1,405 @@ +/* FormatCharacter.java -- Implementation of AttributedCharacterIterator for + formatters. + Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ +package java.text; + +import java.util.Set; +import java.util.HashSet; +import java.util.Map; +import java.util.HashMap; +import java.util.Vector; + +class FormatCharacterIterator implements AttributedCharacterIterator +{ + private String formattedString; + private int charIndex; + private int attributeIndex; + private int[] ranges; + private HashMap[] attributes; + + FormatCharacterIterator() + { + formattedString = ""; + ranges = new int[0]; + attributes = new HashMap[0]; + } + + FormatCharacterIterator(String s, int[] ranges, HashMap[] attributes) + { + formattedString = s; + this.ranges = ranges; + this.attributes = attributes; + } + + /* + * ----------------------------------- + * AttributedCharacterIterator methods + * ----------------------------------- + */ + public Set getAllAttributeKeys() + { + if (attributes != null && attributes[attributeIndex] != null) + return attributes[attributeIndex].keySet(); + else + return new HashSet(); + } + + public Map getAttributes() + { + if (attributes != null && attributes[attributeIndex] != null) + return attributes[attributeIndex]; + else + return new HashMap(); + } + + public Object getAttribute(AttributedCharacterIterator.Attribute attrib) + { + if (attributes != null && attributes[attributeIndex] != null) + return attributes[attributeIndex].get(attrib); + else + return null; + } + + public int getRunLimit(Set reqAttrs) + { + if (attributes == null) + return formattedString.length(); + + int currentAttrIndex = attributeIndex; + Set newKeys; + + do + { + currentAttrIndex++; + if (currentAttrIndex == attributes.length) + return formattedString.length(); + if (attributes[currentAttrIndex] == null) + break; + newKeys = attributes[currentAttrIndex].keySet(); + } + while (newKeys.containsAll(reqAttrs)); + + return ranges[currentAttrIndex-1]; + } + + public int getRunLimit(AttributedCharacterIterator.Attribute attribute) + { + Set s = new HashSet(); + + s.add(attribute); + return getRunLimit(s); + } + + public int getRunLimit() + { + if (attributes == null) + return formattedString.length(); + if (attributes[attributeIndex] == null) + { + for (int i=attributeIndex+1;i<attributes.length;i++) + if (attributes[i] != null) + return ranges[i-1]; + return formattedString.length(); + } + + return getRunLimit (attributes[attributeIndex].keySet()); + } + + public int getRunStart(Set reqAttrs) + { + if (attributes == null) + return formattedString.length(); + + int currentAttrIndex = attributeIndex; + Set newKeys = null; + + do + { + if (currentAttrIndex == 0) + return 0; + + currentAttrIndex--; + if (attributes[currentAttrIndex] == null) + break; + newKeys = attributes[currentAttrIndex].keySet(); + } + while (newKeys.containsAll(reqAttrs)); + + return (currentAttrIndex > 0) ? ranges[currentAttrIndex-1] : 0; + } + + public int getRunStart() + { + if (attributes == null) + return 0; + + if (attributes[attributeIndex] == null) + { + for (int i=attributeIndex;i>0;i--) + if (attributes[i] != null) + return ranges[attributeIndex-1]; + return 0; + } + + return getRunStart(attributes[attributeIndex].keySet()); + } + + public int getRunStart(AttributedCharacterIterator.Attribute attribute) + { + Set s = new HashSet(); + + s.add(attribute); + return getRunStart(s); + } + + public Object clone() + { + return new FormatCharacterIterator(formattedString, ranges, attributes); + } + + /* + * --------------------------------- + * CharacterIterator methods + * --------------------------------- + */ + public char current() + { + return formattedString.charAt(charIndex); + } + + public char first() + { + charIndex = 0; + attributeIndex = 0; + return formattedString.charAt(0); + } + + public int getBeginIndex() + { + return 0; + } + + public int getEndIndex() + { + return formattedString.length(); + } + + public int getIndex() + { + return charIndex; + } + + public char last() + { + charIndex = formattedString.length()-1; + if (attributes != null) + attributeIndex = attributes.length-1; + return formattedString.charAt(charIndex); + } + + public char next() + { + charIndex++; + if (charIndex >= formattedString.length()) + { + charIndex = getEndIndex(); + return DONE; + } + if (attributes != null) + { + if (charIndex >= ranges[attributeIndex]) + attributeIndex++; + } + return formattedString.charAt(charIndex); + } + + public char previous() + { + charIndex--; + if (charIndex < 0) + { + charIndex = 0; + return DONE; + } + + if (attributes != null) + { + if (charIndex < ranges[attributeIndex]) + attributeIndex--; + } + return formattedString.charAt(charIndex); + } + + public char setIndex(int position) + { + if (position < 0 || position > formattedString.length()) + throw new IllegalArgumentException("position is out of range"); + + charIndex = position; + if (attributes != null) + { + for (attributeIndex=0;attributeIndex<attributes.length; + attributeIndex++) + if (ranges[attributeIndex] > charIndex) + break; + attributeIndex--; + } + if (charIndex == formattedString.length()) + return DONE; + else + return formattedString.charAt(charIndex); + } + + protected void mergeAttributes(HashMap[] attributes, int[] ranges) + { + Vector new_ranges = new Vector(); + Vector new_attributes = new Vector(); + int i = 0, j = 0; + + while (i < this.ranges.length && j < ranges.length) + { + if (this.attributes[i] != null) + { + new_attributes.add(this.attributes[i]); + if (attributes[j] != null) + this.attributes[i].putAll(attributes[j]); + } + else + { + new_attributes.add(attributes[j]); + } + if (this.ranges[i] == ranges[j]) + { + new_ranges.add(new Integer(ranges[j])); + i++; + j++; + } + else if (this.ranges[i] < ranges[j]) + { + new_ranges.add(new Integer(this.ranges[i])); + i++; + } + else + { + new_ranges.add(new Integer(ranges[j])); + j++; + } + } + + if (i != this.ranges.length) + { + for (;i<this.ranges.length;i++) + { + new_attributes.add(this.attributes[i]); + new_ranges.add(new Integer(this.ranges[i])); + } + } + if (j != ranges.length) + { + for (;j<ranges.length;j++) + { + new_attributes.add(attributes[j]); + new_ranges.add(new Integer(ranges[j])); + } + } + + this.attributes = new HashMap[new_attributes.size()]; + this.ranges = new int[new_ranges.size()]; + System.arraycopy(new_attributes.toArray(), 0, this.attributes, + 0, this.attributes.length); + + for (i=0;i<new_ranges.size();i++) + { + this.ranges[i] = ((Integer)new_ranges.elementAt(i)).intValue(); + } + + } + + protected void append(AttributedCharacterIterator iterator) + { + char c = iterator.first(); + Vector more_ranges = new Vector(); + Vector more_attributes = new Vector(); + + do + { + formattedString = formattedString + String.valueOf(c); + // TODO: Reduce the size of the output array. + more_attributes.add (iterator.getAttributes()); + more_ranges.add(new Integer(formattedString.length())); + // END TOOD + c = iterator.next(); + } + while (c != DONE); + + HashMap[] new_attributes = new HashMap[attributes.length + + more_attributes.size()]; + int[] new_ranges = new int[ranges.length + more_ranges.size()]; + + System.arraycopy(attributes, 0, new_attributes, 0, attributes.length); + System.arraycopy(more_attributes.toArray(), 0, new_attributes, + attributes.length, more_attributes.size()); + + System.arraycopy(ranges, 0, new_ranges, 0, ranges.length); + Object[] new_ranges_array = more_ranges.toArray(); + for (int i=0;i<more_ranges.size();i++) + new_ranges[i+ranges.length] = ((Integer)new_ranges_array[i]).intValue(); + + attributes = new_attributes; + ranges = new_ranges; + } + + protected void append(String text, HashMap local_attributes) + { + int[] new_ranges = new int[ranges.length+1]; + HashMap[] new_attributes = new HashMap[attributes.length+1]; + + formattedString += text; + System.arraycopy(attributes, 0, new_attributes, 0, attributes.length); + System.arraycopy(ranges, 0, new_ranges, 0, ranges.length); + new_ranges[ranges.length] = formattedString.length(); + new_attributes[attributes.length] = local_attributes; + + ranges = new_ranges; + attributes = new_attributes; + } + + protected void append(String text) + { + append(text, null); + } +} |
