From 8b941eec31d98619765dec95929a2a86058d5843 Mon Sep 17 00:00:00 2001 From: Michael Koch Date: Wed, 29 Oct 2003 16:07:59 +0000 Subject: [multiple changes] 2003-10-29 Mark Wielaard From Guilhem Lavaux * java/text/DateFormat.java (Field): New public static inner class. * java/text/Format.java (Field): Likewise. (formatToCharacterIterator): New method. * java/text/FormatCharacterIterator.java: New file. 2003-10-29 Mark Wielaard From Guilhem Lavaux * java/util/Currency.java: New file. 2003-10-29 Michael Koch * Makefile.am (ordinary_java_source_files): Added java/text/FormatCharacterIterator.java and java/util/Currency.java. * Makefile.in: Regenerated. From-SVN: r73046 --- libjava/java/text/FormatCharacterIterator.java | 405 +++++++++++++++++++++++++ 1 file changed, 405 insertions(+) create mode 100644 libjava/java/text/FormatCharacterIterator.java (limited to 'libjava/java/text/FormatCharacterIterator.java') 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 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 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