OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

CollationElementIterator.java, [...]: Merged copyright and documentation from classpath and rearranged some code.

Browse Source 
2003-04-30  Michael Koch  <konqueror@gmx.de>

	* java/text/CollationElementIterator.java,
	java/text/CollationKey.java,
	java/text/RuleBasedCollator.java:
	Merged copyright and documentation from classpath and
	rearranged some code. No code changes done.

From-SVN: r66288
This commit is contained in:
Michael Koch 2003-04-30 13:09:40 +00:00 committed by Michael Koch
parent 10256cf5f6
commit 70ff9d9023
4 changed files with 339 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libjava/ChangeLog
View File

@ -1,3 +1,11 @@
2003-04-30 Michael Koch <konqueror@gmx.de>
* java/text/CollationElementIterator.java,
java/text/CollationKey.java,
java/text/RuleBasedCollator.java:
Merged copyright and documentation from classpath and
rearranged some code. No code changes done.
2003-04-30 Michael Koch <konqueror@gmx.de>
* java/util/regex/Matcher.java

125
libjava/java/text/CollationElementIterator.java
View File

@ -1,28 +1,93 @@
// CollationElementIterator.java - Iterate over decomposed characters.
/* CollationElementIterator.java -- Walks through collation elements
/* Copyright (C) 1999, 2001 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.text;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 25, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct to JDK 1.1.
*/
/**
* This class walks through the character collation elements of a
* <code>String</code> as defined by the collation rules in an instance of
* <code>RuleBasedCollator</code>. There is no public constructor for
* this class. An instance is created by calling the
* <code>getCollationElementIterator</code> method on
* <code>RuleBasedCollator</code>.
*
* @author Aaron M. Renn <arenn@urbanophile.com>
* @author Tom Tromey <tromey@cygnus.com>
*/
public final class CollationElementIterator
{
/**
* This is a constant value that is returned to indicate that the end of
* the string was encountered.
*/
public static final int NULLORDER = 0xffffffff;
/**
* This is the RuleBasedCollator this object was created from.
*/
RuleBasedCollator collator;
/**
* This is the String that is being iterated over.
*/
String text;
/**
* This is the index into the String where we are currently scanning.
*/
int index;
// A piece of lookahead.
boolean lookahead_set;
int lookahead;
/**
* This method returns the collation ordering value of the next character
* in the string. This method will return <code>NULLORDER</code> if the
* end of the string was reached.
*
* @return The collation ordering value.
*/
public int next ()
{
if (index == text.length())
@ -30,24 +95,51 @@ public final class CollationElementIterator
return collator.ceiNext(this);
}
// This one returns int while the others return short.
/**
* This method returns the primary order value for the given collation
* value.
*
* @param value The collation value returned from <code>next()</code> or <code>previous()</code>.
*
* @return The primary order value of the specified collation value. This is the high 16 bits.
*/
public static final int primaryOrder (int order)
{
// From the JDK 1.2 spec.
return order >>> 16;
}
/**
* This method resets the internal position pointer to read from the
* beginning of the <code>String again.
*/
public void reset ()
{
index = 0;
}
/**
* This method returns the secondary order value for the given collation
* value.
*
* @param value The collation value returned from <code>next()</code> or <code>previous()</code>.
*
* @return The secondary order value of the specified collation value. This is the bits 8-15.
*/
public static final short secondaryOrder (int order)
{
// From the JDK 1.2 spec.
return (short) ((order >>> 8) & 255);
}
/**
* This method returns the tertiary order value for the given collation
* value.
*
* @param value The collation value returned from <code>next()</code> or <code>previous()</code>.
*
* @return The tertiary order value of the specified collation value. This is the low eight bits.
*/
public static final short tertiaryOrder (int order)
{
// From the JDK 1.2 spec.
@ -64,16 +156,5 @@ public final class CollationElementIterator
this.collator = collator;
}
// Text over which we iterate.
String text;
} // class CollationElementIterator
// Index of next character to examine in TEXT.
int index;
// A piece of lookahead.
boolean lookahead_set;
int lookahead;
// The RuleBasedCollator which created this object.
RuleBasedCollator collator;
}

249
libjava/java/text/CollationKey.java
View File

@ -1,88 +1,78 @@
// CollationKey.java - Sort key for locale-sensitive String.
/* CollationKey.java -- Precomputed collation value
/* Copyright (C) 1999, 2000 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.text;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 25, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
/**
* This class represents a pre-computed series of bits representing a
* <code>String</code> for under a particular <code>Collator</code>. This
* value may be compared bitwise against another <code>CollationKey</code>
* representing a different <code>String</code> under the same
* <code>Collator</code> in a manner than is usually more efficient than
* using the raw <code>Collator</code> compare methods. There is overhead
* associated with calculating this value, so it is generally not
* advisable to compute <code>CollationKey</code>'s unless multiple
* comparisons against a <code>String</code> will be done. (For example,
* in a sort routine).
* <p>
* This class cannot be instantiated directly. Instead, a
* <code>CollationKey</code> is created by calling the
* <code>getCollationKey</code> method on an instance of <code>Collator</code>.
*
* @author Aaron M. Renn <arenn@urbanophile.com>
* @author Tom Tromey <tromey@cygnus.com>
*/
public final class CollationKey implements Comparable
{
public int compareTo (CollationKey target)
{
int max = Math.min(key.length, target.key.length);
/**
* This is the <code>String</code> this object represents.
*/
private String originalText;
for (int i = 0; i < max; ++i)
{
if (key[i] != target.key[i])
return key[i] - target.key[i];
}
return key.length - target.key.length;
}
public int compareTo (Object o)
{
return compareTo ((CollationKey) o);
}
public boolean equals (Object obj)
{
if (! (obj instanceof CollationKey))
return false;
CollationKey ck = (CollationKey) obj;
if (key.length != ck.key.length)
return false;
for (int i = 0; i < key.length; ++i)
if (key[i] != ck.key[i])
return false;
return true;
}
public String getSourceString ()
{
return originalText;
}
public int hashCode ()
{
// We just follow BitSet instead of thinking up something new.
long h = originalText.hashCode();
for (int i = key.length - 1; i >= 0; --i)
h ^= key[i] * (i + 1);
return (int) ((h >> 32) ^ h);
}
public byte[] toByteArray ()
{
byte[] r = new byte[4 * key.length];
int off = 0;
for (int i = 0; i < key.length; ++i)
{
r[off++] = (byte) ((key[i] >>> 24) & 255);
r[off++] = (byte) ((key[i] >>> 16) & 255);
r[off++] = (byte) ((key[i] >>> 8) & 255);
r[off++] = (byte) ((key[i] ) & 255);
}
return r;
}
/**
* This is the bit value for this key.
*/
private int[] key;
CollationKey (CollationElementIterator iter, String originalText,
int strength)
@ -101,9 +91,120 @@ public final class CollationKey implements Comparable
key[i] = RuleBasedCollator.next(iter, strength);
}
// Original string.
private String originalText;
/**
* This method compares the specified object to this one. An integer is
* returned which indicates whether the specified object is less than,
* greater than, or equal to this object.
*
* @param ck The <code>CollationKey</code> to compare against this one.
*
* @return A negative integer if this object is less than the specified object, 0 if it is equal or a positive integer if it is greater than the specified object.
*/
public int compareTo (CollationKey ck)
{
int max = Math.min (key.length, ck.key.length);
// Collation key.
private int[] key;
for (int i = 0; i < max; ++i)
{
if (key[i] != ck.key[i])
return key[i] - ck.key[i];
}
return key.length - ck.key.length;
}
/**
* This method compares the specified object to this one. The specified
* object must be an instance of <code>CollationKey</code> or an exception
* will be thrown. An integer is returned which indicates whether the
* specified object is less than, greater than, or equal to this object.
*
* @param obj The <code>Object</code> to compare against this one.
*
* @return A negative integer if this object is less than the specified object, 0 if it is equal or a positive integer if it is greater than the specified object.
*/
public int compareTo (Object obj)
{
return compareTo ((CollationKey) obj);
}
/**
* This method tests the specified <code>Object</code> for equality with
* this object. This will be true if and only if:
* <p>
* <ul>
* <li>The specified object must not be <code>null</code>
* <li>The specified object is an instance of <code>CollationKey</code>.
* <li>The specified object was created from the same <code>Collator</code>
* as this object.
* <li>The specified object has the same source string and bit key as
* this object.
* </ul>
*
* @param obj The <code>Object</code> to test for equality.
*
* @return <code>true</code> if the specified object is equal to this one, <code>false</code> otherwise.
*/
public boolean equals (Object obj)
{
if (! (obj instanceof CollationKey))
return false;
CollationKey ck = (CollationKey) obj;
if (key.length != ck.key.length)
return false;
for (int i = 0; i < key.length; ++i)
if (key[i] != ck.key[i])
return false;
return true;
}
/**
* This method returns the <code>String</code> that this object was created
* from.
*
* @return The source <code>String</code> for this object.
*/
public String getSourceString ()
{
return originalText;
}
/**
* This method returns a hash value for this object. The hash value
* returned will be the hash code of the bit key so that identical bit
* keys will return the same value.
*
* @return A hash value for this object.
*/
public int hashCode ()
{
// We just follow BitSet instead of thinking up something new.
long h = originalText.hashCode();
for (int i = key.length - 1; i >= 0; --i)
h ^= key[i] * (i + 1);
return (int) ((h >> 32) ^ h);
}
/**
* This method returns the collation bit sequence as a byte array.
*
* @param A byte array containing the collation bit sequence.
*/
public byte[] toByteArray ()
{
byte[] r = new byte[4 * key.length];
int off = 0;
for (int i = 0; i < key.length; ++i)
{
r[off++] = (byte) ((key[i] >>> 24) & 255);
r[off++] = (byte) ((key[i] >>> 16) & 255);
r[off++] = (byte) ((key[i] >>> 8) & 255);
r[off++] = (byte) ((key[i] ) & 255);
}
return r;
}
}

74
libjava/java/text/RuleBasedCollator.java
View File

@ -1,12 +1,40 @@
// RuleBasedCollator.java - Concrete class for locale-based string compare.
/* RuleBasedCollator.java -- Concrete Collator Class
/* Copyright (C) 1999, 2000, 2001 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.text;
@ -14,15 +42,16 @@ import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 25, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct
*/
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date March 25, 1999
*/
final class RBCElement
{
String key;
@ -37,6 +66,21 @@ final class RBCElement
public class RuleBasedCollator extends Collator
{
// True if we are using French-style accent ordering.
private boolean frenchAccents;
/**
* This the the original rule string.
*/
private String rules;
// This maps strings onto collation values.
private Hashtable map;
// An entry in this hash means that more lookahead is required for
// the prefix string.
private Hashtable prefixes;
public Object clone ()
{
RuleBasedCollator c = (RuleBasedCollator) super.clone ();
@ -354,16 +398,4 @@ public class RuleBasedCollator extends Collator
prefixes.put(r.key.substring(0, i), Boolean.TRUE);
}
}
// True if we are using French-style accent ordering.
private boolean frenchAccents;
// It's easier to just save the rules than to try to recreate them.
private String rules;
// This maps strings onto collation values.
private Hashtable map;
// An entry in this hash means that more lookahead is required for
// the prefix string.
private Hashtable prefixes;
}