git-svn-id: https://svn.code.sf.net/p/jode/code/trunk@1087 379699f6-c40d-0410-875b-85095c16579ebranch_1_1
jochen
26 years ago
parent
48d5c63aec
commit
6786a3fa35
@ -1,785 +0,0 @@ |
||||
/* ClassInfo Copyright (C) 1998-1999 Jochen Hoenicke. |
||||
* |
||||
* This program 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. |
||||
* |
||||
* This program 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 this program; see the file COPYING. If not, write to |
||||
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
||||
* |
||||
* $Id$ |
||||
*/ |
||||
|
||||
package jode.bytecode; |
||||
import jode.GlobalOptions; |
||||
import java.io.DataInputStream; |
||||
import java.io.DataOutputStream; |
||||
import java.io.IOException; |
||||
import java.util.Enumeration; |
||||
///#ifdef JDK12
|
||||
///import java.util.Map;
|
||||
///import java.util.HashMap;
|
||||
///import java.lang.ref.WeakReference;
|
||||
///import java.lang.ref.ReferenceQueue;
|
||||
///#else
|
||||
import java.util.Hashtable; |
||||
///#endif
|
||||
import java.lang.reflect.Field; |
||||
import java.lang.reflect.Method; |
||||
import java.lang.reflect.Modifier; |
||||
|
||||
/** |
||||
* This class does represent a class similar to java.lang.Class. You |
||||
* can get the super class and the interfaces. |
||||
* |
||||
* The main difference to java.lang.Class is, that the objects are builded |
||||
* from a stream containing the .class file, and that it uses the |
||||
* <code>Type</code> to represent types instead of Class itself. |
||||
* |
||||
* @author Jochen Hoenicke |
||||
*/ |
||||
public class ClassInfo extends BinaryInfo { |
||||
|
||||
private static SearchPath classpath; |
||||
///#ifdef JDK12
|
||||
/// private static final Map classes = new HashMap();
|
||||
/// private static final ReferenceQueue queue = new ReferenceQueue();
|
||||
///#else
|
||||
private static final Hashtable classes = new Hashtable(); |
||||
///#endif
|
||||
|
||||
private int status = 0; |
||||
|
||||
private boolean modified = false; |
||||
|
||||
private int modifiers = -1; |
||||
private String name; |
||||
private ClassInfo superclass; |
||||
private ClassInfo[] interfaces; |
||||
private FieldInfo[] fields; |
||||
private MethodInfo[] methods; |
||||
private InnerClassInfo[] outerClasses; |
||||
private InnerClassInfo[] innerClasses; |
||||
private InnerClassInfo[] extraClasses; |
||||
private String sourceFile; |
||||
|
||||
public final static ClassInfo javaLangObject = forName("java.lang.Object"); |
||||
|
||||
public static void setClassPath(String path) { |
||||
classpath = new SearchPath(path); |
||||
///#ifdef JDK12
|
||||
/// java.lang.ref.Reference died;
|
||||
/// while ((died = queue.poll()) != null) {
|
||||
/// classes.values().remove(died);
|
||||
/// }
|
||||
/// Iterator i = classes.values().iterator();
|
||||
/// while (i.hasNext()) {
|
||||
/// ClassInfo ci = (ClassInfo) ((WeakReference)i.next()).get();
|
||||
/// if (ci == null) {
|
||||
/// i.remove();
|
||||
/// continue;
|
||||
/// }
|
||||
///#else
|
||||
Enumeration enum = classes.elements(); |
||||
while (enum.hasMoreElements()) { |
||||
ClassInfo ci = (ClassInfo) enum.nextElement(); |
||||
///#endif
|
||||
ci.status = 0; |
||||
ci.superclass = null; |
||||
ci.fields = null; |
||||
ci.interfaces = null; |
||||
ci.methods = null; |
||||
ci.removeAllAttributes(); |
||||
} |
||||
} |
||||
|
||||
public static boolean exists(String name) { |
||||
return classpath.exists(name.replace('.', '/') + ".class"); |
||||
} |
||||
|
||||
public static boolean isPackage(String name) { |
||||
return classpath.isDirectory(name.replace('.', '/')); |
||||
} |
||||
|
||||
public static Enumeration getClassesAndPackages(final String packageName) { |
||||
final Enumeration enum = |
||||
classpath.listFiles(packageName.replace('.','/')); |
||||
return new Enumeration() { |
||||
public boolean hasMoreElements() { |
||||
return enum.hasMoreElements(); |
||||
} |
||||
public Object nextElement() { |
||||
String name = (String) enum.nextElement(); |
||||
if (!name.endsWith(".class")) |
||||
// This is a package
|
||||
return name; |
||||
return name.substring(0, name.length()-6); |
||||
|
||||
} |
||||
}; |
||||
} |
||||
|
||||
public static ClassInfo forName(String name) { |
||||
if (name == null |
||||
|| name.indexOf(';') != -1 |
||||
|| name.indexOf('[') != -1 |
||||
|| name.indexOf('/') != -1) |
||||
throw new IllegalArgumentException("Illegal class name: "+name); |
||||
|
||||
///#ifdef JDK12
|
||||
/// java.lang.ref.Reference died;
|
||||
/// while ((died = queue.poll()) != null) {
|
||||
/// classes.values().remove(died);
|
||||
/// }
|
||||
/// WeakReference ref = (WeakReference) classes.get(name);
|
||||
/// ClassInfo clazz = (ref == null) ? null : (ClassInfo) ref.get();
|
||||
///#else
|
||||
ClassInfo clazz = (ClassInfo) classes.get(name); |
||||
///#endif
|
||||
if (clazz == null) { |
||||
clazz = new ClassInfo(name); |
||||
///#ifdef JDK12
|
||||
/// classes.put(name, new WeakReference(clazz, queue));
|
||||
///#else
|
||||
classes.put(name, clazz); |
||||
///#endif
|
||||
} |
||||
return clazz; |
||||
} |
||||
|
||||
private ClassInfo(String name) { |
||||
this.name = name; |
||||
} |
||||
|
||||
protected void readAttribute(String name, int length, |
||||
ConstantPool cp, |
||||
DataInputStream input, |
||||
int howMuch) throws IOException { |
||||
if ((howMuch & ALL_ATTRIBUTES) != 0 && name.equals("SourceFile")) { |
||||
if (length != 2) |
||||
throw new ClassFormatException("SourceFile attribute" |
||||
+ " has wrong length"); |
||||
sourceFile = cp.getUTF8(input.readUnsignedShort()); |
||||
} else if ((howMuch & (OUTERCLASSES | INNERCLASSES)) != 0 |
||||
&& name.equals("InnerClasses")) { |
||||
int count = input.readUnsignedShort(); |
||||
int innerCount = 0, outerCount = 0, extraCount = 0; |
||||
InnerClassInfo[] innerClassInfo = new InnerClassInfo[count]; |
||||
for (int i=0; i< count; i++) { |
||||
int innerIndex = input.readUnsignedShort(); |
||||
int outerIndex = input.readUnsignedShort(); |
||||
int nameIndex = input.readUnsignedShort(); |
||||
String inner = cp.getClassName(innerIndex); |
||||
String outer = |
||||
outerIndex != 0 ? cp.getClassName(outerIndex) : null; |
||||
String innername = |
||||
nameIndex != 0 ? cp.getUTF8(nameIndex) : null; |
||||
int access = input.readUnsignedShort(); |
||||
if (innername != null && innername.length() == 0) |
||||
innername = null; |
||||
InnerClassInfo ici = new InnerClassInfo |
||||
(inner, outer, innername, access); |
||||
|
||||
if (outer != null && outer.equals(getName()) |
||||
&& innername != null) |
||||
innerClassInfo[innerCount++] = ici; |
||||
else |
||||
innerClassInfo[count - (++extraCount)] = ici; |
||||
} |
||||
{ |
||||
String lastOuterName = getName(); |
||||
for (int i = count - extraCount; i < count; i++) { |
||||
InnerClassInfo ici = innerClassInfo[i]; |
||||
if (ici.inner.equals(lastOuterName)) { |
||||
for (int j = i; j > count - extraCount; j--) |
||||
innerClassInfo[j] = innerClassInfo[j-1]; |
||||
innerClassInfo[count-extraCount] = ici; |
||||
extraCount--; |
||||
outerCount++; |
||||
lastOuterName = ici.outer; |
||||
} |
||||
} |
||||
} |
||||
if (innerCount > 0) { |
||||
innerClasses = new InnerClassInfo[innerCount]; |
||||
System.arraycopy(innerClassInfo, 0, |
||||
innerClasses, 0, innerCount); |
||||
} else |
||||
innerClasses = null; |
||||
|
||||
if (outerCount > 0) { |
||||
outerClasses = new InnerClassInfo[outerCount]; |
||||
System.arraycopy(innerClassInfo, innerCount, |
||||
outerClasses, 0, outerCount); |
||||
} else |
||||
outerClasses = null; |
||||
|
||||
if (extraCount > 0) { |
||||
extraClasses = new InnerClassInfo[extraCount]; |
||||
System.arraycopy(innerClassInfo, innerCount + outerCount, |
||||
extraClasses, 0, extraCount); |
||||
} else |
||||
extraClasses = null; |
||||
|
||||
if (length != 2 + 8 * count) |
||||
throw new ClassFormatException |
||||
("InnerClasses attribute has wrong length"); |
||||
} else |
||||
super.readAttribute(name, length, cp, input, howMuch); |
||||
} |
||||
|
||||
public void read(DataInputStream input, int howMuch) throws IOException { |
||||
/* Since we have to read the whole class anyway, we load all |
||||
* info, that we may need later and that does not take much memory. |
||||
*/ |
||||
howMuch |= FIELDS | METHODS | HIERARCHY | INNERCLASSES | OUTERCLASSES; |
||||
howMuch &= ~status; |
||||
/* header */ |
||||
if (input.readInt() != 0xcafebabe) |
||||
throw new ClassFormatException("Wrong magic"); |
||||
if (input.readUnsignedShort() > 3) |
||||
throw new ClassFormatException("Wrong minor"); |
||||
if (input.readUnsignedShort() != 45) |
||||
throw new ClassFormatException("Wrong major"); |
||||
|
||||
/* constant pool */ |
||||
ConstantPool cpool = new ConstantPool(); |
||||
cpool.read(input); |
||||
|
||||
/* always read modifiers, name, super, ifaces */ |
||||
{ |
||||
modifiers = input.readUnsignedShort(); |
||||
String className = cpool.getClassName(input.readUnsignedShort()); |
||||
if (!name.equals(className)) |
||||
throw new ClassFormatException("wrong name " + className); |
||||
String superName = cpool.getClassName(input.readUnsignedShort()); |
||||
superclass = superName != null ? ClassInfo.forName(superName) : null; |
||||
int count = input.readUnsignedShort(); |
||||
interfaces = new ClassInfo[count]; |
||||
for (int i=0; i< count; i++) { |
||||
interfaces[i] = ClassInfo.forName |
||||
(cpool.getClassName(input.readUnsignedShort())); |
||||
} |
||||
status |= HIERARCHY; |
||||
} |
||||
|
||||
/* fields */ |
||||
if ((howMuch & (FIELDS | ALL_ATTRIBUTES)) != 0) { |
||||
int count = input.readUnsignedShort(); |
||||
if ((howMuch & FIELDS) != 0) |
||||
fields = new FieldInfo[count]; |
||||
for (int i=0; i< count; i++) { |
||||
if ((howMuch & FIELDS) != 0) |
||||
fields[i] = new FieldInfo(this); |
||||
fields[i].read(cpool, input, howMuch); |
||||
} |
||||
} else { |
||||
byte[] skipBuf = new byte[6]; |
||||
int count = input.readUnsignedShort(); |
||||
for (int i=0; i< count; i++) { |
||||
input.readFully(skipBuf); // modifier, name, type
|
||||
skipAttributes(input); |
||||
} |
||||
} |
||||
|
||||
/* methods */ |
||||
if ((howMuch & (METHODS | ALL_ATTRIBUTES)) != 0) { |
||||
int count = input.readUnsignedShort(); |
||||
if ((howMuch & METHODS) != 0) |
||||
methods = new MethodInfo[count]; |
||||
for (int i=0; i< count; i++) { |
||||
if ((howMuch & METHODS) != 0) |
||||
methods[i] = new MethodInfo(this); |
||||
methods[i].read(cpool, input, howMuch); |
||||
} |
||||
} else { |
||||
byte[] skipBuf = new byte[6]; |
||||
int count = input.readUnsignedShort(); |
||||
for (int i=0; i< count; i++) { |
||||
input.readFully(skipBuf); // modifier, name, type
|
||||
skipAttributes(input); |
||||
} |
||||
} |
||||
|
||||
/* attributes */ |
||||
readAttributes(cpool, input, howMuch); |
||||
status |= howMuch; |
||||
} |
||||
|
||||
public void reserveSmallConstants(GrowableConstantPool gcp) { |
||||
for (int i=0; i < fields.length; i++) |
||||
fields[i].reserveSmallConstants(gcp); |
||||
|
||||
for (int i=0; i < methods.length; i++) |
||||
methods[i].reserveSmallConstants(gcp); |
||||
} |
||||
|
||||
public void prepareWriting(GrowableConstantPool gcp) { |
||||
gcp.putClassName(name); |
||||
gcp.putClassName(superclass.getName()); |
||||
for (int i=0; i < interfaces.length; i++) |
||||
gcp.putClassName(interfaces[i].getName()); |
||||
|
||||
for (int i=0; i < fields.length; i++) |
||||
fields[i].prepareWriting(gcp); |
||||
|
||||
for (int i=0; i < methods.length; i++) |
||||
methods[i].prepareWriting(gcp); |
||||
|
||||
if (sourceFile != null) { |
||||
gcp.putUTF8("SourceFile"); |
||||
gcp.putUTF8(sourceFile); |
||||
} |
||||
if (outerClasses != null || innerClasses != null |
||||
|| extraClasses != null) { |
||||
gcp.putUTF8("InnerClasses"); |
||||
int outerCount = outerClasses != null ? outerClasses.length : 0; |
||||
for (int i=outerCount; i-- > 0;) { |
||||
gcp.putClassName(outerClasses[i].inner); |
||||
if (outerClasses[i].outer != null) |
||||
gcp.putClassName(outerClasses[i].outer); |
||||
if (outerClasses[i].name != null) |
||||
gcp.putUTF8(outerClasses[i].name); |
||||
} |
||||
int innerCount = innerClasses != null ? innerClasses.length : 0; |
||||
for (int i=0; i< innerCount; i++) { |
||||
gcp.putClassName(innerClasses[i].inner); |
||||
if (innerClasses[i].outer != null) |
||||
gcp.putClassName(innerClasses[i].outer); |
||||
if (innerClasses[i].name != null) |
||||
gcp.putUTF8(innerClasses[i].name); |
||||
} |
||||
int extraCount = extraClasses != null ? extraClasses.length : 0; |
||||
for (int i=0; i< extraCount; i++) { |
||||
gcp.putClassName(extraClasses[i].inner); |
||||
if (extraClasses[i].outer != null) |
||||
gcp.putClassName(extraClasses[i].outer); |
||||
if (extraClasses[i].name != null) |
||||
gcp.putUTF8(extraClasses[i].name); |
||||
} |
||||
} |
||||
prepareAttributes(gcp); |
||||
} |
||||
|
||||
protected int getKnownAttributeCount() { |
||||
int count = 0; |
||||
if (sourceFile != null) |
||||
count++; |
||||
if (innerClasses != null || outerClasses != null |
||||
|| extraClasses != null) |
||||
count++; |
||||
return count; |
||||
} |
||||
|
||||
public void writeKnownAttributes(GrowableConstantPool gcp, |
||||
DataOutputStream output) |
||||
throws IOException { |
||||
if (sourceFile != null) { |
||||
output.writeShort(gcp.putUTF8("SourceFile")); |
||||
output.writeInt(2); |
||||
output.writeShort(gcp.putUTF8(sourceFile)); |
||||
} |
||||
if (outerClasses != null || innerClasses != null |
||||
|| extraClasses != null) { |
||||
output.writeShort(gcp.putUTF8("InnerClasses")); |
||||
int outerCount = (outerClasses != null) ? outerClasses.length : 0; |
||||
int innerCount = (innerClasses != null) ? innerClasses.length : 0; |
||||
int extraCount = (extraClasses != null) ? extraClasses.length : 0; |
||||
int count = outerCount + innerCount + extraCount; |
||||
output.writeInt(2 + count * 8); |
||||
output.writeShort(count); |
||||
for (int i=outerCount; i-- > 0; ) { |
||||
output.writeShort(gcp.putClassName(outerClasses[i].inner)); |
||||
output.writeShort(outerClasses[i].outer != null ? |
||||
gcp.putClassName(outerClasses[i].outer) : 0); |
||||
output.writeShort(outerClasses[i].name != null ? |
||||
gcp.putUTF8(outerClasses[i].name) : 0); |
||||
output.writeShort(outerClasses[i].modifiers); |
||||
} |
||||
for (int i=0; i< innerCount; i++) { |
||||
output.writeShort(gcp.putClassName(innerClasses[i].inner)); |
||||
output.writeShort(innerClasses[i].outer != null ? |
||||
gcp.putClassName(innerClasses[i].outer) : 0); |
||||
output.writeShort(innerClasses[i].name != null ? |
||||
gcp.putUTF8(innerClasses[i].name) : 0); |
||||
output.writeShort(innerClasses[i].modifiers); |
||||
} |
||||
for (int i=0; i< extraCount; i++) { |
||||
output.writeShort(gcp.putClassName(extraClasses[i].inner)); |
||||
output.writeShort(extraClasses[i].outer != null ? |
||||
gcp.putClassName(extraClasses[i].outer) : 0); |
||||
output.writeShort(extraClasses[i].name != null ? |
||||
gcp.putUTF8(extraClasses[i].name) : 0); |
||||
output.writeShort(extraClasses[i].modifiers); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public void write(DataOutputStream out) throws IOException { |
||||
GrowableConstantPool gcp = new GrowableConstantPool(); |
||||
reserveSmallConstants(gcp); |
||||
prepareWriting(gcp); |
||||
|
||||
out.writeInt(0xcafebabe); |
||||
out.writeShort(3); |
||||
out.writeShort(45); |
||||
gcp.write(out); |
||||
|
||||
out.writeShort(modifiers); |
||||
out.writeShort(gcp.putClassName(name)); |
||||
out.writeShort(gcp.putClassName(superclass.getName())); |
||||
out.writeShort(interfaces.length); |
||||
for (int i=0; i < interfaces.length; i++) |
||||
out.writeShort(gcp.putClassName(interfaces[i].getName())); |
||||
|
||||
out.writeShort(fields.length); |
||||
for (int i=0; i < fields.length; i++) |
||||
fields[i].write(gcp, out); |
||||
|
||||
out.writeShort(methods.length); |
||||
for (int i=0; i < methods.length; i++) |
||||
methods[i].write(gcp, out); |
||||
|
||||
writeAttributes(gcp, out); |
||||
} |
||||
|
||||
public void loadInfoReflection(Class clazz, int howMuch) |
||||
throws SecurityException { |
||||
if ((howMuch & HIERARCHY) != 0) { |
||||
modifiers = clazz.getModifiers(); |
||||
if (clazz.getSuperclass() == null) |
||||
superclass = null; |
||||
else |
||||
superclass = ClassInfo.forName |
||||
(clazz.getSuperclass().getName()); |
||||
Class[] ifaces = clazz.getInterfaces(); |
||||
interfaces = new ClassInfo[ifaces.length]; |
||||
for (int i=0; i<ifaces.length; i++) |
||||
interfaces[i] = ClassInfo.forName(ifaces[i].getName()); |
||||
status |= HIERARCHY; |
||||
} |
||||
if ((howMuch & FIELDS) != 0 && fields == null) { |
||||
Field[] fs; |
||||
try { |
||||
fs = clazz.getDeclaredFields(); |
||||
} catch (SecurityException ex) { |
||||
fs = clazz.getFields(); |
||||
GlobalOptions.err.println |
||||
("Could only get public fields of class " |
||||
+ name + "."); |
||||
} |
||||
fields = new FieldInfo[fs.length]; |
||||
for (int i = fs.length; --i >= 0; ) { |
||||
String type = TypeSignature.getSignature(fs[i].getType()); |
||||
fields[i] = new FieldInfo |
||||
(this, fs[i].getName(), type, fs[i].getModifiers()); |
||||
} |
||||
} |
||||
if ((howMuch & METHODS) != 0 && methods == null) { |
||||
Method[] ms; |
||||
try { |
||||
ms = clazz.getDeclaredMethods(); |
||||
} catch (SecurityException ex) { |
||||
ms = clazz.getMethods(); |
||||
GlobalOptions.err.println |
||||
("Could only get public methods of class " |
||||
+ name + "."); |
||||
} |
||||
methods = new MethodInfo[ms.length]; |
||||
for (int i = ms.length; --i >= 0; ) { |
||||
String type = TypeSignature.getSignature |
||||
(ms[i].getParameterTypes(), ms[i].getReturnType()); |
||||
methods[i] = new MethodInfo |
||||
(this, ms[i].getName(), type, ms[i].getModifiers()); |
||||
} |
||||
} |
||||
if ((howMuch & INNERCLASSES) != 0 && innerClasses == null) { |
||||
Class[] is; |
||||
try { |
||||
is = clazz.getDeclaredClasses(); |
||||
} catch (SecurityException ex) { |
||||
is = clazz.getClasses(); |
||||
GlobalOptions.err.println |
||||
("Could only get public methods of class " |
||||
+ name + "."); |
||||
} |
||||
if (is.length > 0) { |
||||
innerClasses = new InnerClassInfo[is.length]; |
||||
for (int i = is.length; --i >= 0; ) { |
||||
String inner = is[i].getName(); |
||||
int dollar = inner.lastIndexOf('$'); |
||||
String name = inner.substring(dollar+1); |
||||
innerClasses[i] = new InnerClassInfo |
||||
(inner, getName(), name, is[i].getModifiers()); |
||||
} |
||||
} |
||||
} |
||||
if ((howMuch & OUTERCLASSES) != 0 && outerClasses == null) { |
||||
int count = 0; |
||||
Class declarer = clazz.getDeclaringClass(); |
||||
while (declarer != null) { |
||||
count++; |
||||
declarer = declarer.getDeclaringClass(); |
||||
} |
||||
if (count > 0) { |
||||
outerClasses = new InnerClassInfo[count]; |
||||
Class current = clazz; |
||||
for (int i = 0; i < count; i++) { |
||||
declarer = current.getDeclaringClass(); |
||||
String name = current.getName(); |
||||
int dollar = name.lastIndexOf('$'); |
||||
outerClasses[i] = new InnerClassInfo |
||||
(name, declarer.getName(), |
||||
name.substring(dollar+1), current.getModifiers()); |
||||
current = declarer; |
||||
} |
||||
} |
||||
} |
||||
status |= howMuch; |
||||
} |
||||
|
||||
public void loadInfo(int howMuch) { |
||||
if ((status & howMuch) == howMuch) |
||||
return; |
||||
if (modified) { |
||||
System.err.println("Allocating info 0x" |
||||
+ Integer.toHexString(howMuch) |
||||
+ " (status 0x" + Integer.toHexString(status) |
||||
+ ") in class " + this); |
||||
Thread.dumpStack(); |
||||
return; |
||||
} |
||||
try { |
||||
DataInputStream input = |
||||
new DataInputStream(classpath.getFile(name.replace('.', '/') |
||||
+ ".class")); |
||||
read(input, howMuch); |
||||
|
||||
} catch (IOException ex) { |
||||
String message = ex.getMessage(); |
||||
if ((howMuch & ~(FIELDS|METHODS|HIERARCHY |
||||
|INNERCLASSES|OUTERCLASSES)) != 0) { |
||||
GlobalOptions.err.println |
||||
("Can't read class " + name + "."); |
||||
ex.printStackTrace(GlobalOptions.err); |
||||
throw new NoClassDefFoundError(name); |
||||
} |
||||
// Try getting the info through the reflection interface
|
||||
// instead.
|
||||
Class clazz = null; |
||||
try { |
||||
clazz = Class.forName(name); |
||||
} catch (ClassNotFoundException ex2) { |
||||
} catch (NoClassDefFoundError ex2) { |
||||
} |
||||
try { |
||||
if (clazz != null) { |
||||
loadInfoReflection(clazz, howMuch); |
||||
return; |
||||
} |
||||
} catch (SecurityException ex2) { |
||||
GlobalOptions.err.println |
||||
(ex2+" while collecting info about class " + name + "."); |
||||
} |
||||
|
||||
// Give a warning and ``guess'' the hierarchie, methods etc.
|
||||
GlobalOptions.err.println |
||||
("Can't read class " + name + ", types may be incorrect. (" |
||||
+ ex.getClass().getName() |
||||
+ (message != null ? ": " + message : "") + ")"); |
||||
|
||||
if ((howMuch & HIERARCHY) != 0) { |
||||
modifiers = Modifier.PUBLIC; |
||||
if (name.equals("java.lang.Object")) |
||||
superclass = null; |
||||
else |
||||
superclass = javaLangObject; |
||||
interfaces = new ClassInfo[0]; |
||||
} |
||||
if ((howMuch & METHODS) != 0) |
||||
methods = new MethodInfo[0]; |
||||
if ((howMuch & FIELDS) != 0) |
||||
fields = new FieldInfo[0]; |
||||
status |= howMuch; |
||||
} |
||||
} |
||||
|
||||
public String getName() { |
||||
return name; |
||||
} |
||||
|
||||
public String getJavaName() { |
||||
/* Don't load attributes for class names not containing a |
||||
* dollar sign. |
||||
*/ |
||||
if (name.indexOf('$') == -1) |
||||
return getName(); |
||||
if (getOuterClasses() != null) { |
||||
int last = outerClasses.length-1; |
||||
StringBuffer sb = |
||||
new StringBuffer(outerClasses[last].outer != null |
||||
? outerClasses[last].outer : "METHOD"); |
||||
for (int i=last; i >= 0; i--) |
||||
sb.append(".").append(outerClasses[i].name != null |
||||
? outerClasses[i].name : "ANONYMOUS"); |
||||
return sb.toString(); |
||||
} |
||||
return getName(); |
||||
} |
||||
|
||||
public ClassInfo getSuperclass() { |
||||
if ((status & HIERARCHY) == 0) |
||||
loadInfo(HIERARCHY); |
||||
return superclass; |
||||
} |
||||
|
||||
public ClassInfo[] getInterfaces() { |
||||
if ((status & HIERARCHY) == 0) |
||||
loadInfo(HIERARCHY); |
||||
return interfaces; |
||||
} |
||||
|
||||
public int getModifiers() { |
||||
if ((status & HIERARCHY) == 0) |
||||
loadInfo(HIERARCHY); |
||||
return modifiers; |
||||
} |
||||
|
||||
public boolean isInterface() { |
||||
return Modifier.isInterface(getModifiers()); |
||||
} |
||||
|
||||
public FieldInfo findField(String name, String typeSig) { |
||||
if ((status & FIELDS) == 0) |
||||
loadInfo(FIELDS); |
||||
for (int i=0; i< fields.length; i++) |
||||
if (fields[i].getName().equals(name) |
||||
&& fields[i].getType().equals(typeSig)) |
||||
return fields[i]; |
||||
return null; |
||||
} |
||||
|
||||
public MethodInfo findMethod(String name, String typeSig) { |
||||
if ((status & METHODS) == 0) |
||||
loadInfo(METHODS); |
||||
for (int i=0; i< methods.length; i++) |
||||
if (methods[i].getName().equals(name) |
||||
&& methods[i].getType().equals(typeSig)) |
||||
return methods[i]; |
||||
return null; |
||||
} |
||||
|
||||
public MethodInfo[] getMethods() { |
||||
if ((status & METHODS) == 0) |
||||
loadInfo(METHODS); |
||||
return methods; |
||||
} |
||||
|
||||
public FieldInfo[] getFields() { |
||||
if ((status & FIELDS) == 0) |
||||
loadInfo(FIELDS); |
||||
return fields; |
||||
} |
||||
|
||||
public InnerClassInfo[] getOuterClasses() { |
||||
if ((status & OUTERCLASSES) == 0) |
||||
loadInfo(OUTERCLASSES); |
||||
return outerClasses; |
||||
} |
||||
|
||||
public InnerClassInfo[] getInnerClasses() { |
||||
if ((status & INNERCLASSES) == 0) |
||||
loadInfo(INNERCLASSES); |
||||
return innerClasses; |
||||
} |
||||
|
||||
public InnerClassInfo[] getExtraClasses() { |
||||
if ((status & INNERCLASSES) == 0) |
||||
loadInfo(INNERCLASSES); |
||||
return extraClasses; |
||||
} |
||||
|
||||
public String getSourceFile() { |
||||
return sourceFile; |
||||
} |
||||
|
||||
public void setName(String newName) { |
||||
name = newName; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setSuperclass(ClassInfo newSuper) { |
||||
superclass = newSuper; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setInterfaces(ClassInfo[] newIfaces) { |
||||
interfaces = newIfaces; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setModifiers(int newModifiers) { |
||||
modifiers = newModifiers; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setMethods(MethodInfo[] mi) { |
||||
methods = mi; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setFields(FieldInfo[] fi) { |
||||
fields = fi; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setOuterClasses(InnerClassInfo[] oc) { |
||||
outerClasses = oc; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setInnerClasses(InnerClassInfo[] ic) { |
||||
innerClasses = ic; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setExtraClasses(InnerClassInfo[] ec) { |
||||
extraClasses = ec; |
||||
modified = true; |
||||
} |
||||
|
||||
public void setSourceFile(String newSource) { |
||||
sourceFile = newSource; |
||||
modified = true; |
||||
} |
||||
|
||||
public boolean superClassOf(ClassInfo son) { |
||||
while (son != this && son != null) { |
||||
son = son.getSuperclass(); |
||||
} |
||||
return son == this; |
||||
} |
||||
|
||||
public boolean implementedBy(ClassInfo clazz) { |
||||
while (clazz != this && clazz != null) { |
||||
ClassInfo[] ifaces = clazz.getInterfaces(); |
||||
for (int i=0; i< ifaces.length; i++) { |
||||
if (implementedBy(ifaces[i])) |
||||
return true; |
||||
} |
||||
clazz = clazz.getSuperclass(); |
||||
} |
||||
return clazz == this; |
||||
} |
||||
|
||||
public String toString() { |
||||
return name; |
||||
} |
||||
} |
||||
@ -1,337 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// AbstractCollection.java -- Abstract implementation of most of Collection
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
import java.lang.reflect.Array; |
||||
|
||||
/** |
||||
* A basic implementation of most of the methods in the Collection interface to |
||||
* make it easier to create a collection. To create an unmodifiable Collection, |
||||
* just subclass AbstractCollection and provide implementations of the |
||||
* iterator() and size() methods. The Iterator returned by iterator() need only |
||||
* provide implementations of hasNext() and next() (that is, it may throw an |
||||
* UnsupportedOperationException if remove() is called). To create a modifiable |
||||
* Collection, you must in addition provide an implementation of the |
||||
* add(Object) method and the Iterator returned by iterator() must provide an |
||||
* implementation of remove(). Other methods should be overridden if the |
||||
* backing data structure allows for a more efficient implementation. The |
||||
* precise implementation used by AbstractCollection is documented, so that |
||||
* subclasses can tell which methods could be implemented more efficiently. |
||||
*/ |
||||
public abstract class AbstractCollection implements Collection { |
||||
|
||||
/** |
||||
* Return an Iterator over this collection. The iterator must provide the |
||||
* hasNext and next methods and should in addition provide remove if the |
||||
* collection is modifiable. |
||||
*/ |
||||
public abstract Iterator iterator(); |
||||
|
||||
/** |
||||
* Return the number of elements in this collection. |
||||
*/ |
||||
public abstract int size(); |
||||
|
||||
/** |
||||
* Add an object to the collection. This implementation always throws an |
||||
* UnsupportedOperationException - it should be overridden if the collection |
||||
* is to be modifiable. |
||||
* |
||||
* @param o the object to add |
||||
* @return true if the add operation caused the Collection to change |
||||
* @exception UnsupportedOperationException if the add operation is not |
||||
* supported on this collection |
||||
*/ |
||||
public boolean add(Object o) { |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** |
||||
* Add all the elements of a given collection to this collection. This |
||||
* implementation obtains an Iterator over the given collection and iterates |
||||
* over it, adding each element with the add(Object) method (thus this method |
||||
* will fail with an UnsupportedOperationException if the add method does). |
||||
* |
||||
* @param c the collection to add the elements of to this collection |
||||
* @return true if the add operation caused the Collection to change |
||||
* @exception UnsupportedOperationException if the add operation is not |
||||
* supported on this collection |
||||
*/ |
||||
public boolean addAll(Collection c) { |
||||
Iterator i = c.iterator(); |
||||
boolean modified = false; |
||||
while (i.hasNext()) { |
||||
modified |= add(i.next()); |
||||
} |
||||
return modified; |
||||
} |
||||
|
||||
/** |
||||
* Remove all elements from the collection. This implementation obtains an |
||||
* iterator over the collection and calls next and remove on it repeatedly |
||||
* (thus this method will fail with an UnsupportedOperationException if the |
||||
* Iterator's remove method does) until there are no more elements to remove. |
||||
* Many implementations will have a faster way of doing this. |
||||
* |
||||
* @exception UnsupportedOperationException if the Iterator returned by |
||||
* iterator does not provide an implementation of remove |
||||
*/ |
||||
public void clear() { |
||||
Iterator i = iterator(); |
||||
while (i.hasNext()) { |
||||
i.next(); |
||||
i.remove(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Test whether this collection contains a given object. That is, if the |
||||
* collection has an element e such that (o == null ? e == null : |
||||
* o.equals(e)). This implementation obtains an iterator over the collection |
||||
* and iterates over it, testing each element for equality with the given |
||||
* object. If it is equal, true is returned. Otherwise false is returned when |
||||
* the end of the collection is reached. |
||||
* |
||||
* @param o the object to remove from this collection |
||||
* @return true if this collection contains an object equal to o |
||||
*/ |
||||
public boolean contains(Object o) { |
||||
Iterator i = iterator(); |
||||
|
||||
// This looks crazily inefficient, but it takes the test o==null outside
|
||||
// the loop, saving time, and also saves needing to store the result of
|
||||
// i.next() each time.
|
||||
if (o == null) { |
||||
while (i.hasNext()) { |
||||
if (i.next() == null) { |
||||
return true; |
||||
} |
||||
} |
||||
} else { |
||||
while (i.hasNext()) { |
||||
if (o.equals(i.next())) { |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* Tests whether this collection contains all the elements in a given |
||||
* collection. This implementation iterates over the given collection, |
||||
* testing whether each element is contained in this collection. If any one |
||||
* is not, false is returned. Otherwise true is returned. |
||||
* |
||||
* @param c the collection to test against |
||||
* @return true if this collection contains all the elements in the given |
||||
* collection |
||||
*/ |
||||
public boolean containsAll(Collection c) { |
||||
Iterator i = c.iterator(); |
||||
while (i.hasNext()) { |
||||
if (!contains(i.next())) { |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
/** |
||||
* Test whether this collection is empty. This implementation returns |
||||
* size() == 0. |
||||
* |
||||
* @return true if this collection is empty. |
||||
*/ |
||||
public boolean isEmpty() { |
||||
return size() == 0; |
||||
} |
||||
|
||||
/** |
||||
* Remove a single instance of an object from this collection. That is, |
||||
* remove one element e such that (o == null ? e == null : o.equals(e)), if |
||||
* such an element exists. This implementation obtains an iterator over the |
||||
* collection and iterates over it, testing each element for equality with |
||||
* the given object. If it is equal, it is removed by the iterator's remove |
||||
* method (thus this method will fail with an UnsupportedOperationException |
||||
* if the Iterator's remove method does). After the first element has been |
||||
* removed, true is returned; if the end of the collection is reached, false |
||||
* is returned. |
||||
* |
||||
* @param o the object to remove from this collection |
||||
* @return true if the remove operation caused the Collection to change, or |
||||
* equivalently if the collection did contain o. |
||||
* @exception UnsupportedOperationException if this collection's Iterator |
||||
* does not support the remove method |
||||
*/ |
||||
public boolean remove(Object o) { |
||||
Iterator i = iterator(); |
||||
|
||||
// This looks crazily inefficient, but it takes the test o==null outside
|
||||
// the loop, saving time, and also saves needing to store the result of
|
||||
// i.next() each time.
|
||||
if (o == null) { |
||||
while (i.hasNext()) { |
||||
if (i.next() == null) { |
||||
i.remove(); |
||||
return true; |
||||
} |
||||
} |
||||
} else { |
||||
while (i.hasNext()) { |
||||
if (o.equals(i.next())) { |
||||
i.remove(); |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* Remove from this collection all its elements that are contained in a given |
||||
* collection. This implementation iterates over this collection, and for |
||||
* each element tests if it is contained in the given collection. If so, it |
||||
* is removed by the Iterator's remove method (thus this method will fail |
||||
* with an UnsupportedOperationException if the Iterator's remove method |
||||
* does). |
||||
* |
||||
* @param c the collection to remove the elements of |
||||
* @return true if the remove operation caused the Collection to change |
||||
* @exception UnsupportedOperationException if this collection's Iterator |
||||
* does not support the remove method |
||||
*/ |
||||
public boolean removeAll(Collection c) { |
||||
Iterator i = iterator(); |
||||
boolean changed = false; |
||||
while (i.hasNext()) { |
||||
if (c.contains(i.next())) { |
||||
i.remove(); |
||||
changed = true; |
||||
} |
||||
} |
||||
return changed; |
||||
} |
||||
|
||||
/** |
||||
* Remove from this collection all its elements that are not contained in a |
||||
* given collection. This implementation iterates over this collection, and |
||||
* for each element tests if it is contained in the given collection. If not, |
||||
* it is removed by the Iterator's remove method (thus this method will fail |
||||
* with an UnsupportedOperationException if the Iterator's remove method |
||||
* does). |
||||
* |
||||
* @param c the collection to retain the elements of |
||||
* @return true if the remove operation caused the Collection to change |
||||
* @exception UnsupportedOperationException if this collection's Iterator |
||||
* does not support the remove method |
||||
*/ |
||||
public boolean retainAll(Collection c) { |
||||
Iterator i = iterator(); |
||||
boolean changed = false; |
||||
while (i.hasNext()) { |
||||
if (!c.contains(i.next())) { |
||||
i.remove(); |
||||
changed = true; |
||||
} |
||||
} |
||||
return changed; |
||||
} |
||||
|
||||
/** |
||||
* Return an array containing the elements of this collection. This |
||||
* implementation creates an Object array of size size() and then iterates |
||||
* over the collection, setting each element of the array from the value |
||||
* returned by the iterator. |
||||
* |
||||
* @return an array containing the elements of this collection |
||||
*/ |
||||
public Object[] toArray() { |
||||
Object[] a = new Object[size()]; |
||||
Iterator i = iterator(); |
||||
for (int pos = 0; pos < a.length; pos++) { |
||||
a[pos] = i.next(); |
||||
} |
||||
return a; |
||||
} |
||||
|
||||
/** |
||||
* Copy the collection into a given array if it will fit, or into a |
||||
* dynamically created array of the same run-time type as the given array if |
||||
* not. If there is space remaining in the array, the first element after the |
||||
* end of the collection is set to null (this is only useful if the |
||||
* collection is known to contain no null elements, however). This |
||||
* implementation first tests whether the given array is large enough to hold |
||||
* all the elements of the collection. If not, the reflection API is used to |
||||
* allocate a new array of the same run-time type. Next an iterator is |
||||
* obtained over the collection and the elements are placed in the array as |
||||
* they are returned by the iterator. Finally the first spare element, if |
||||
* any, of the array is set to null, and the created array is returned. |
||||
* |
||||
* @param a the array to copy into, or of the correct run-time type |
||||
* @return the array that was produced |
||||
* @exception ClassCastException if the type of the array precludes holding |
||||
* one of the elements of the Collection |
||||
*/ |
||||
public Object[] toArray(Object[] a) { |
||||
final int n = size(); |
||||
if (a.length < n) { |
||||
a = (Object[])Array.newInstance(a.getClass().getComponentType(), n); |
||||
} |
||||
Iterator i = iterator(); |
||||
for (int pos = 0; pos < n; pos++) { |
||||
a[pos] = i.next(); |
||||
} |
||||
if (a.length > n) { |
||||
a[n] = null; |
||||
} |
||||
return a; |
||||
} |
||||
|
||||
/** |
||||
* Creates a String representation of the Collection. The string returned is |
||||
* of the form "[a, b, ...]" where a and b etc are the results of calling |
||||
* toString on the elements of the collection. This implementation obtains an |
||||
* Iterator over the Collection and adds each element to a StringBuffer as it |
||||
* is returned by the iterator. |
||||
* |
||||
* @return a String representation of the Collection |
||||
*/ |
||||
public String toString() { |
||||
StringBuffer s = new StringBuffer(); |
||||
s.append('['); |
||||
Iterator i = iterator(); |
||||
boolean more = i.hasNext(); |
||||
while(more) { |
||||
s.append(i.next()); |
||||
if (more = i.hasNext()) { |
||||
s.append(", "); |
||||
} |
||||
} |
||||
s.append(']'); |
||||
return s.toString(); |
||||
} |
||||
} |
||||
@ -1,560 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// AbstractList.java -- Abstract implementation of most of List
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comments for almost everything.
|
||||
// ~ Better general commenting
|
||||
|
||||
package jode.util; |
||||
import java.util.NoSuchElementException; |
||||
|
||||
/** |
||||
* A basic implementation of most of the methods in the List interface to make |
||||
* it easier to create a List based on a random-access data structure. To |
||||
* create an unmodifiable list, it is only necessary to override the size() and |
||||
* get(int) methods (this contrasts with all other abstract collection classes |
||||
* which require an iterator to be provided). To make the list modifiable, the |
||||
* set(int, Object) method should also be overridden, and to make the list |
||||
* resizable, the add(int, Object) and remove(int) methods should be overridden |
||||
* too. Other methods should be overridden if the backing data structure allows |
||||
* for a more efficient implementation. The precise implementation used by |
||||
* AbstractList is documented, so that subclasses can tell which methods could |
||||
* be implemented more efficiently. |
||||
*/ |
||||
public abstract class AbstractList extends AbstractCollection implements List { |
||||
|
||||
/** |
||||
* A count of the number of structural modifications that have been made to |
||||
* the list (that is, insertions and removals). |
||||
*/ |
||||
protected transient int modCount = 0; |
||||
|
||||
public abstract Object get(int index); |
||||
|
||||
public void add(int index, Object o) { |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
public boolean add(Object o) { |
||||
add(size(), o); |
||||
return true; |
||||
} |
||||
|
||||
public boolean addAll(int index, Collection c) { |
||||
Iterator i = c.iterator(); |
||||
if (i.hasNext()) { |
||||
do { |
||||
add(index++, i.next()); |
||||
} while (i.hasNext()); |
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
public void clear() { |
||||
removeRange(0, size()); |
||||
} |
||||
|
||||
public boolean equals(Object o) { |
||||
if (o == this) { |
||||
return true; |
||||
} else if (!(o instanceof List)) { |
||||
return false; |
||||
} else { |
||||
Iterator i1 = iterator(); |
||||
Iterator i2 = ((List)o).iterator(); |
||||
while (i1.hasNext()) { |
||||
if (!i2.hasNext()) { |
||||
return false; |
||||
} else { |
||||
Object e = i1.next(); |
||||
if (e == null ? i2.next() != null : !e.equals(i2.next())) { |
||||
return false; |
||||
} |
||||
} |
||||
} |
||||
if (i2.hasNext()) { |
||||
return false; |
||||
} else { |
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
|
||||
public int hashCode() { |
||||
int hashCode = 1; |
||||
Iterator i = iterator(); |
||||
while (i.hasNext()) { |
||||
Object obj = i.next(); |
||||
hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); |
||||
} |
||||
return hashCode; |
||||
} |
||||
|
||||
public int indexOf(Object o) { |
||||
int index = 0; |
||||
ListIterator i = listIterator(); |
||||
if (o == null) { |
||||
while (i.hasNext()) { |
||||
if (i.next() == null) { |
||||
return index; |
||||
} |
||||
index++; |
||||
} |
||||
} else { |
||||
while (i.hasNext()) { |
||||
if (o.equals(i.next())) { |
||||
return index; |
||||
} |
||||
index++; |
||||
} |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
public Iterator iterator() { |
||||
return new Iterator() { |
||||
private int knownMod = modCount; |
||||
private int position = 0; |
||||
boolean removed = true; |
||||
|
||||
private void checkMod() { |
||||
if (knownMod != modCount) { |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
} |
||||
|
||||
public boolean hasNext() { |
||||
checkMod(); |
||||
return position < size(); |
||||
} |
||||
|
||||
public Object next() { |
||||
checkMod(); |
||||
removed = false; |
||||
try { |
||||
return get(position++); |
||||
} catch (IndexOutOfBoundsException e) { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
} |
||||
|
||||
public void remove() { |
||||
checkMod(); |
||||
if (removed) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
AbstractList.this.remove(--position); |
||||
knownMod = modCount; |
||||
removed = true; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
public int lastIndexOf(Object o) { |
||||
int index = size(); |
||||
ListIterator i = listIterator(index); |
||||
if (o == null) { |
||||
while (i.hasPrevious()) { |
||||
if (i.previous() == null) { |
||||
return index; |
||||
} |
||||
index--; |
||||
} |
||||
} else { |
||||
while (i.hasPrevious()) { |
||||
if (o.equals(i.previous())) { |
||||
return index; |
||||
} |
||||
index--; |
||||
} |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
public ListIterator listIterator() { |
||||
return listIterator(0); |
||||
} |
||||
|
||||
public ListIterator listIterator(final int index) { |
||||
|
||||
if (index < 0 || index > size()) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
|
||||
return new ListIterator() { |
||||
private int knownMod = modCount; |
||||
private int position = index; |
||||
private int lastReturned = -1; |
||||
|
||||
private void checkMod() { |
||||
if (knownMod != modCount) { |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
} |
||||
|
||||
public boolean hasNext() { |
||||
checkMod(); |
||||
return position < size(); |
||||
} |
||||
|
||||
public boolean hasPrevious() { |
||||
checkMod(); |
||||
return position > 0; |
||||
} |
||||
|
||||
public Object next() { |
||||
checkMod(); |
||||
if (hasNext()) { |
||||
lastReturned = position++; |
||||
return get(lastReturned); |
||||
} else { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
} |
||||
|
||||
public Object previous() { |
||||
checkMod(); |
||||
if (hasPrevious()) { |
||||
lastReturned = --position; |
||||
return get(lastReturned); |
||||
} else { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
} |
||||
|
||||
public int nextIndex() { |
||||
checkMod(); |
||||
return position; |
||||
} |
||||
|
||||
public int previousIndex() { |
||||
checkMod(); |
||||
return position - 1; |
||||
} |
||||
|
||||
public void remove() { |
||||
checkMod(); |
||||
if (lastReturned < 0) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
AbstractList.this.remove(lastReturned); |
||||
knownMod = modCount; |
||||
position = lastReturned; |
||||
lastReturned = -1; |
||||
} |
||||
|
||||
public void set(Object o) { |
||||
checkMod(); |
||||
if (lastReturned < 0) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
AbstractList.this.set(lastReturned, o); |
||||
} |
||||
|
||||
public void add(Object o) { |
||||
checkMod(); |
||||
AbstractList.this.add(position++, o); |
||||
lastReturned = -1; |
||||
knownMod = modCount; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
public Object remove(int index) { |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** |
||||
* Remove a subsection of the list. This is called by the clear and |
||||
* removeRange methods of the class which implements subList, which are |
||||
* difficult for subclasses to override directly. Therefore, this method |
||||
* should be overridden instead by the more efficient implementation, if one |
||||
* exists. |
||||
* <p> |
||||
* This implementation first checks for illegal or out of range arguments. It |
||||
* then obtains a ListIterator over the list using listIterator(fromIndex). |
||||
* It then calls next() and remove() on this iterator repeatedly, toIndex - |
||||
* fromIndex times. |
||||
* |
||||
* @param fromIndex the index, inclusive, to remove from. |
||||
* @param toIndex the index, exclusive, to remove to. |
||||
* @exception UnsupportedOperationException if this list does not support |
||||
* the removeRange operation. |
||||
* @exception IndexOutOfBoundsException if fromIndex > toIndex || fromIndex < |
||||
* 0 || toIndex > size(). |
||||
*/ |
||||
protected void removeRange(int fromIndex, int toIndex) { |
||||
if (fromIndex > toIndex) { |
||||
throw new IllegalArgumentException(); |
||||
} else if (fromIndex < 0 || toIndex > size()) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} else { |
||||
ListIterator i = listIterator(fromIndex); |
||||
for (int index = fromIndex; index < toIndex; index++) { |
||||
i.next(); |
||||
i.remove(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public Object set(int index, Object o) { |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
private static class SubList extends AbstractList { |
||||
|
||||
// Note that within this class two fields called modCount are inherited -
|
||||
// one from the superclass, and one from the backing class. These are
|
||||
// explicitly disambiguated in the code by referring to "this.modCount"
|
||||
// and "backing.modCount".
|
||||
// The code uses both these two fields and *no other* to provide fail-fast
|
||||
// behaviour. For correct operation, the two fields should contain equal
|
||||
// values. Therefore, if this.modCount != backing.modCount, there
|
||||
// has been a concurrent modification. This is all achieved purely by using
|
||||
// the modCount field, precisely according to the docs of AbstractList.
|
||||
// See the methods upMod and checkMod.
|
||||
|
||||
// Jikes doesn't want to access outer instance with AbstractList.this,
|
||||
// since this is an AbstractList, too. I therefor changed class to static
|
||||
// and do it by hand. This makes it a lot clearer by the way.
|
||||
private AbstractList backing; |
||||
private final int offset; |
||||
private int size; |
||||
|
||||
SubList(AbstractList backing, int fromIndex, int toIndex) { |
||||
this.backing = backing; |
||||
this.offset = fromIndex; |
||||
this.size = toIndex - fromIndex; |
||||
|
||||
upMod(); |
||||
} |
||||
|
||||
/** |
||||
* This method checks the two modCount fields to ensure that there has |
||||
* not been a concurrent modification. It throws an exception if there |
||||
* has been, and otherwise returns normally. |
||||
* Note that since this method is private, it will be inlined. |
||||
* |
||||
* @exception ConcurrentModificationException if there has been a |
||||
* concurrent modification. |
||||
*/ |
||||
private void checkMod() { |
||||
if (modCount != backing.modCount) { |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method is called after every method that causes a structural |
||||
* modification to the backing list. It updates the local modCount field |
||||
* to match that of the backing list. |
||||
* Note that since this method is private, it will be inlined. |
||||
*/ |
||||
private void upMod() { |
||||
modCount = backing.modCount; |
||||
} |
||||
|
||||
/** |
||||
* This method checks that a value is between 0 and size (inclusive). If |
||||
* it is not, an exception is thrown. |
||||
* Note that since this method is private, it will be inlined. |
||||
* |
||||
* @exception IndexOutOfBoundsException if the value is out of range. |
||||
*/ |
||||
private void checkBoundsInclusive(int index) { |
||||
if (index < 0 || index > size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method checks that a value is between 0 (inclusive) and size |
||||
* (exclusive). If it is not, an exception is thrown. |
||||
* Note that since this method is private, it will be inlined. |
||||
* |
||||
* @exception IndexOutOfBoundsException if the value is out of range. |
||||
*/ |
||||
private void checkBoundsExclusive(int index) { |
||||
if (index < 0 || index >= size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
} |
||||
|
||||
public int size() { |
||||
checkMod(); |
||||
return size; |
||||
} |
||||
|
||||
public Iterator iterator() { |
||||
return listIterator(); |
||||
} |
||||
|
||||
public ListIterator listIterator(final int index) { |
||||
|
||||
checkMod(); |
||||
checkBoundsInclusive(index); |
||||
|
||||
return new ListIterator() { |
||||
ListIterator i = backing.listIterator(index + offset); |
||||
int position = index; |
||||
|
||||
public boolean hasNext() { |
||||
checkMod(); |
||||
return position < size; |
||||
} |
||||
|
||||
public boolean hasPrevious() { |
||||
checkMod(); |
||||
return position > 0; |
||||
} |
||||
|
||||
public Object next() { |
||||
if (position < size) { |
||||
Object o = i.next(); |
||||
position++; |
||||
return o; |
||||
} else { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
} |
||||
|
||||
public Object previous() { |
||||
if (position > 0) { |
||||
Object o = i.previous(); |
||||
position--; |
||||
return o; |
||||
} else { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
} |
||||
|
||||
public int nextIndex() { |
||||
return offset + i.nextIndex(); |
||||
} |
||||
|
||||
public int previousIndex() { |
||||
return offset + i.previousIndex(); |
||||
} |
||||
|
||||
public void remove() { |
||||
i.remove(); |
||||
upMod(); |
||||
size--; |
||||
position = nextIndex(); |
||||
} |
||||
|
||||
public void set(Object o) { |
||||
i.set(o); |
||||
} |
||||
|
||||
public void add(Object o) { |
||||
i.add(o); |
||||
upMod(); |
||||
size++; |
||||
position++; |
||||
} |
||||
|
||||
// Here is the reason why the various modCount fields are mostly
|
||||
// ignored in this wrapper listIterator.
|
||||
// IF the backing listIterator is failfast, then the following holds:
|
||||
// Using any other method on this list will call a corresponding
|
||||
// method on the backing list *after* the backing listIterator
|
||||
// is created, which will in turn cause a ConcurrentModException
|
||||
// when this listIterator comes to use the backing one. So it is
|
||||
// implicitly failfast.
|
||||
// If the backing listIterator is NOT failfast, then the whole of
|
||||
// this list isn't failfast, because the modCount field of the
|
||||
// backing list is not valid. It would still be *possible* to
|
||||
// make the iterator failfast wrt modifications of the sublist
|
||||
// only, but somewhat pointless when the list can be changed under
|
||||
// us.
|
||||
// Either way, no explicit handling of modCount is needed.
|
||||
// However upMod() must be called in add and remove, and size
|
||||
// must also be updated in these two methods, since they do not go
|
||||
// through the corresponding methods of the subList.
|
||||
|
||||
}; |
||||
} |
||||
|
||||
public Object set(int index, Object o) { |
||||
checkMod(); |
||||
checkBoundsExclusive(index); |
||||
o = backing.set(index + offset, o); |
||||
upMod(); |
||||
return o; |
||||
} |
||||
|
||||
public Object get(int index) { |
||||
checkMod(); |
||||
checkBoundsExclusive(index); |
||||
return backing.get(index + offset); |
||||
} |
||||
|
||||
public void add(int index, Object o) { |
||||
checkMod(); |
||||
checkBoundsInclusive(index); |
||||
backing.add(index + offset, o); |
||||
upMod(); |
||||
size++; |
||||
} |
||||
|
||||
public Object remove(int index) { |
||||
checkMod(); |
||||
checkBoundsExclusive(index); |
||||
Object o = backing.remove(index + offset); |
||||
upMod(); |
||||
size--; |
||||
return o; |
||||
} |
||||
|
||||
public void removeRange(int fromIndex2, int toIndex2) { |
||||
checkMod(); |
||||
checkBoundsExclusive(fromIndex2); |
||||
checkBoundsInclusive(toIndex2); |
||||
|
||||
// this call will catch the toIndex2 < fromIndex2 condition
|
||||
backing.removeRange(offset + fromIndex2, offset + toIndex2); |
||||
upMod(); |
||||
size -= toIndex2 - fromIndex2; |
||||
} |
||||
|
||||
public boolean addAll(int index, Collection c) { |
||||
checkMod(); |
||||
checkBoundsInclusive(index); |
||||
int s = backing.size(); |
||||
boolean result = backing.addAll(offset + index, c); |
||||
upMod(); |
||||
size += backing.size() - s; |
||||
return result; |
||||
} |
||||
} |
||||
|
||||
public List subList(final int fromIndex, final int toIndex) { |
||||
return new SubList(this, fromIndex, toIndex); |
||||
} |
||||
|
||||
} |
||||
@ -1,280 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// AbstractMap.java -- Abstract implementation of most of Map
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com),
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// comments
|
||||
// test suite
|
||||
|
||||
package jode.util; |
||||
|
||||
public abstract class AbstractMap implements Map { |
||||
|
||||
public void clear() |
||||
{ |
||||
entrySet().clear(); |
||||
} |
||||
|
||||
public boolean containsKey( Object key ) |
||||
{ |
||||
Object k; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
{ |
||||
k = ((Map.Entry)entries.next()).getKey(); |
||||
if( key == null ? k == null : key.equals( k ) ) |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
public boolean containsValue( Object value ) |
||||
{ |
||||
Object v; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
{ |
||||
v = ((Map.Entry)entries.next()).getValue(); |
||||
if( value == null ? v == null : value.equals( v ) ) |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
public abstract Set entrySet(); |
||||
|
||||
public boolean equals( Object o ) |
||||
{ |
||||
if( this == o ) |
||||
return true; |
||||
|
||||
if( o == null || !( o instanceof Map ) ) |
||||
return false; |
||||
|
||||
Map m = (Map)o; |
||||
if( m.size() != size() ) |
||||
return false; |
||||
|
||||
Object key, value1, value2; |
||||
Map.Entry entry; |
||||
Iterator entries = entrySet().iterator(); |
||||
while( entries.hasNext() ) |
||||
{ |
||||
entry = (Map.Entry)entries.next(); |
||||
key = entry.getKey(); |
||||
value1 = entry.getValue(); |
||||
value2 = m.get( key ); |
||||
|
||||
if( !( ( value1 == null && value2 == null ) |
||||
|| value1.equals( value2 ) ) ) |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
public Object get( Object key ) |
||||
{ |
||||
Object k; |
||||
Map.Entry entry; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
{ |
||||
entry = (Map.Entry)entries.next(); |
||||
k = entry.getKey(); |
||||
if( key == null ? k == null : key.equals( k ) ) |
||||
return entry.getValue(); |
||||
} |
||||
|
||||
return null; |
||||
} |
||||
|
||||
public int hashCode() |
||||
{ |
||||
int hashcode = 0; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
hashcode += entries.next().hashCode(); |
||||
|
||||
return hashcode; |
||||
} |
||||
|
||||
public boolean isEmpty() |
||||
{ |
||||
return size() == 0; |
||||
} |
||||
|
||||
public Set keySet() |
||||
{ |
||||
if( this.keySet == null ) |
||||
{ |
||||
this.keySet = |
||||
new AbstractSet() |
||||
{ |
||||
public int size() |
||||
{ |
||||
return AbstractMap.this.size(); |
||||
} |
||||
|
||||
public boolean contains(Object key) |
||||
{ |
||||
return AbstractMap.this.containsKey(key); |
||||
} |
||||
|
||||
public Iterator iterator() |
||||
{ |
||||
return new Iterator() |
||||
{ |
||||
Iterator map_iterator = AbstractMap.this.entrySet().iterator(); |
||||
|
||||
public boolean hasNext() |
||||
{ |
||||
return map_iterator.hasNext(); |
||||
} |
||||
|
||||
public Object next() |
||||
{ |
||||
return ((Map.Entry)map_iterator.next()).getKey(); |
||||
} |
||||
|
||||
public void remove() |
||||
{ |
||||
map_iterator.remove(); |
||||
} |
||||
}; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
return this.keySet; |
||||
} |
||||
|
||||
public Object put( Object key, Object value ) |
||||
{ |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
public void putAll( Map m ) |
||||
{ |
||||
Map.Entry entry; |
||||
Iterator entries = m.entrySet().iterator(); |
||||
while( entries.hasNext() ) |
||||
{ |
||||
entry = (Map.Entry)entries.next(); |
||||
put( entry.getKey(), entry.getValue() ); |
||||
} |
||||
} |
||||
|
||||
public Object remove( Object key ) |
||||
{ |
||||
Object k, value; |
||||
Map.Entry entry; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
{ |
||||
entry = (Map.Entry)entries.next(); |
||||
k = entry.getKey(); |
||||
if( key == null ? k == null : key.equals( k ) ) |
||||
{ |
||||
value = entry.getValue(); |
||||
entries.remove(); |
||||
return value; |
||||
} |
||||
} |
||||
|
||||
return null; |
||||
} |
||||
|
||||
public int size() |
||||
{ |
||||
return entrySet().size(); |
||||
} |
||||
|
||||
public String toString() |
||||
{ |
||||
Map.Entry entry; |
||||
String rep = "AbstractMap< "; |
||||
Iterator entries = entrySet().iterator(); |
||||
|
||||
while( entries.hasNext() ) |
||||
{ |
||||
entry = (Map.Entry)entries.next(); |
||||
rep += entry.getKey() + " -> " + entry.getValue() + ", "; |
||||
} |
||||
|
||||
return rep.substring( 0, rep.length() - 2 ) + " >"; |
||||
} |
||||
|
||||
public Collection values() |
||||
{ |
||||
if( this.valueCollection == null ) |
||||
{ |
||||
this.valueCollection = |
||||
new AbstractCollection() |
||||
{ |
||||
public int size() |
||||
{ |
||||
return AbstractMap.this.size(); |
||||
} |
||||
|
||||
public Iterator iterator() |
||||
{ |
||||
return new Iterator() |
||||
{ |
||||
Iterator map_iterator = AbstractMap.this.entrySet().iterator(); |
||||
|
||||
public boolean hasNext() |
||||
{ |
||||
return map_iterator.hasNext(); |
||||
} |
||||
|
||||
public Object next() |
||||
{ |
||||
return ((Map.Entry)map_iterator.next()).getValue(); |
||||
} |
||||
|
||||
public void remove() |
||||
{ |
||||
map_iterator.remove(); |
||||
} |
||||
}; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
return this.valueCollection; |
||||
} |
||||
|
||||
|
||||
private Collection valueCollection = null; |
||||
private Set keySet = null; |
||||
} |
||||
@ -1,111 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// AbstractSequentialList.java -- List implementation for sequential access
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Lots of doc comments still missing.
|
||||
// ~ The class comment should include a description of what should be overridden
|
||||
// to provide what features, as should the listIterator comment.
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* Abstract superclass to make it easier to implement the List interface when |
||||
* backed by a sequential-access store, such as a linked list. |
||||
*/ |
||||
public abstract class AbstractSequentialList extends AbstractList { |
||||
|
||||
/** |
||||
* Returns a ListIterator over the list, starting from position index. |
||||
* Subclasses must provide an implementation of this method. |
||||
* |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
*/ |
||||
public abstract ListIterator listIterator(int index); |
||||
|
||||
/** |
||||
* Add an element to the list at a given index. This implementation obtains a |
||||
* ListIterator positioned at the specified index, and then adds the element |
||||
* using the ListIterator's add method. |
||||
* |
||||
* @param index the position to add the element |
||||
* @param o the element to insert |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
* @exception UnsupportedOperationException if the iterator returned by |
||||
* listIterator(index) does not support the add method. |
||||
*/ |
||||
public void add(int index, Object o) { |
||||
ListIterator i = listIterator(index); |
||||
i.add(o); |
||||
} |
||||
|
||||
public boolean addAll(int index, Collection c) { |
||||
boolean changed = false; |
||||
Iterator ci = c.iterator(); |
||||
ListIterator i = listIterator(index); |
||||
while (ci.hasNext()) { |
||||
i.add(ci.next()); |
||||
changed = true; |
||||
} |
||||
return changed; |
||||
} |
||||
|
||||
public Object get(int index) { |
||||
ListIterator i = listIterator(index); |
||||
if (!i.hasNext()) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
return i.next(); |
||||
} |
||||
|
||||
/** |
||||
* Return an Iterator over this List. This implementation returns |
||||
* listIterator(). |
||||
* |
||||
* @return an Iterator over this List |
||||
*/ |
||||
public Iterator iterator() { |
||||
return listIterator(); |
||||
} |
||||
|
||||
public Object remove(int index) { |
||||
ListIterator i = listIterator(index); |
||||
if (!i.hasNext()) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
Object removed = i.next(); |
||||
i.remove(); |
||||
return removed; |
||||
} |
||||
|
||||
public Object set(int index, Object o) { |
||||
ListIterator i = listIterator(index); |
||||
if (!i.hasNext()) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
Object old = i.next(); |
||||
i.set(o); |
||||
return old; |
||||
} |
||||
} |
||||
@ -1,78 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// AbstractSet.java -- Abstract implementation of most of Set
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* An abstract implementation of Set to make it easier to create your own |
||||
* implementations. In order to create a Set, subclass AbstractSet and |
||||
* implement the same methods that are required for AbstractCollection |
||||
* (although these methods must of course meet the requirements that Set puts |
||||
* on them - specifically, no element may be in the set more than once). This |
||||
* class simply provides implementations of equals() and hashCode() to fulfil |
||||
* the requirements placed on them by the Set interface. |
||||
*/ |
||||
public abstract class AbstractSet extends AbstractCollection implements Set { |
||||
|
||||
/** |
||||
* Tests whether the given object is equal to this Set. This implementation |
||||
* first checks whether this set <em>is</em> the given object, and returns |
||||
* true if so. Otherwise, if o is a Set and is the same size as this one, it |
||||
* returns the result of calling containsAll on the given Set. Otherwise, it |
||||
* returns false. |
||||
* |
||||
* @param o the Object to be tested for equality with this Set |
||||
* @return true if the given object is equal to this Set |
||||
*/ |
||||
public boolean equals(Object o) { |
||||
if (o == this) { |
||||
return true; |
||||
} else if (o instanceof Set && ((Set)o).size() == size()) { |
||||
return containsAll((Collection)o); |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Returns a hash code for this Set. The hash code of a Set is the sum of the |
||||
* hash codes of all its elements, except that the hash code of null is |
||||
* defined to be zero. This implementation obtains an Iterator over the Set, |
||||
* and sums the results. |
||||
* |
||||
* @return a hash code for this Set |
||||
*/ |
||||
public int hashCode() { |
||||
int hash = 0; |
||||
Iterator i = iterator(); |
||||
while (i.hasNext()) { |
||||
try { |
||||
hash += i.next().hashCode(); |
||||
} catch (NullPointerException e) { |
||||
} |
||||
} |
||||
return hash; |
||||
} |
||||
} |
||||
@ -1,489 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// ArrayList.java -- JDK1.2's answer to Vector; this is an array-backed
|
||||
// implementation of the List interface
|
||||
//
|
||||
// This is a JDK 1.2 compliant version of ArrayList.java
|
||||
//
|
||||
// Copyright (c) 1998 by Jon A. Zeppieri (jon@eease.com),
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
package jode.util; |
||||
|
||||
import java.lang.reflect.Array; |
||||
import java.io.Serializable; |
||||
import java.io.IOException; |
||||
import java.io.ObjectInputStream; |
||||
import java.io.ObjectOutputStream; |
||||
|
||||
/** |
||||
* An array-backed implementation of the List interface. ArrayList |
||||
* performs well on simple tasks: random access into a list, appending |
||||
* to or removing from the end of a list, checking the size, &c. |
||||
* |
||||
* @author Jon A. Zeppieri |
||||
* @version $Id$ |
||||
* @see java.util.AbstractList |
||||
* @see java.util.List |
||||
*/ |
||||
public class ArrayList extends AbstractList |
||||
implements List, Cloneable, Serializable |
||||
{ |
||||
/** the default capacity for new ArrayLists */ |
||||
private static final int DEFAULT_CAPACITY = 16; |
||||
|
||||
/** the number of elements in this list */ |
||||
int size; |
||||
|
||||
/** where the data is stored */ |
||||
transient Object[] _arData; |
||||
|
||||
/** |
||||
* Construct a new ArrayList with the supplied initial capacity. |
||||
* |
||||
* @param iCapacity |
||||
*/ |
||||
public ArrayList(int iCapacity) |
||||
{ |
||||
_arData = new Object[iCapacity]; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Construct a new ArrayList with the default capcity |
||||
*/ |
||||
public ArrayList() |
||||
{ |
||||
this(DEFAULT_CAPACITY); |
||||
} |
||||
|
||||
/** |
||||
* Construct a new ArrayList, and initialize it with the elements |
||||
* in the supplied Collection; Sun specs say that the initial |
||||
* capacity is 110% of the Collection's size. |
||||
* |
||||
* @param oCollection the collection whose elements will |
||||
* initialize this list |
||||
*/ |
||||
public ArrayList(Collection oCollection) |
||||
{ |
||||
this((int) (oCollection.size() * 1.1)); |
||||
addAll(oCollection); |
||||
} |
||||
|
||||
/** |
||||
* Guarantees that this list will have at least enough capacity to |
||||
* hold iMinCapacity elements. |
||||
* |
||||
* @param iMinCapacity the minimum guaranteed capacity |
||||
*/ |
||||
public void ensureCapacity(int iMinCapacity) |
||||
{ |
||||
Object[] arNewData; |
||||
int iCapacity = _arData.length; |
||||
|
||||
if (iMinCapacity > iCapacity) |
||||
{ |
||||
arNewData = new Object[Math.max((iCapacity * 2), iMinCapacity)]; |
||||
System.arraycopy(_arData, 0, arNewData, 0, iCapacity); |
||||
_arData = arNewData; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Appends the supplied element to the end of this list. |
||||
* |
||||
* @param oElement the element to be appended to this list |
||||
*/ |
||||
public boolean add(Object oElement) |
||||
{ |
||||
ensureCapacity(size + 1); |
||||
_arData[size++] = oElement; |
||||
modCount++; |
||||
return true; |
||||
} |
||||
|
||||
/** |
||||
* Retrieves the element at the user-supplied index. |
||||
* |
||||
* @param iIndex the index of the element we are fetching |
||||
* @throws IndexOutOfBoundsException (iIndex < 0) || (iIndex >= size()) |
||||
*/ |
||||
public Object get(int iIndex) |
||||
{ |
||||
if (iIndex >= size) |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"index=" + String.valueOf(iIndex)); |
||||
return _arData[iIndex]; |
||||
} |
||||
|
||||
/** |
||||
* Returns the number of elements in this list |
||||
*/ |
||||
public int size() |
||||
{ |
||||
return size; |
||||
} |
||||
|
||||
/** |
||||
* Removes the element at the user-supplied index |
||||
* |
||||
* @param iIndex the index of the element to be removed |
||||
* @return the removed Object |
||||
* @throws IndexOutOfBoundsException (iIndex < 0) || (iIndex >= size()) |
||||
*/ |
||||
public Object remove(int iIndex) |
||||
{ |
||||
Object oResult; |
||||
|
||||
if (iIndex >= size) |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"index=" + String.valueOf(iIndex)); |
||||
|
||||
oResult = _arData[iIndex]; |
||||
|
||||
if (iIndex != --size) |
||||
System.arraycopy(_arData, (iIndex + 1), _arData, iIndex, |
||||
(size - iIndex)); |
||||
|
||||
modCount++; |
||||
_arData[size] = null; |
||||
|
||||
return oResult; |
||||
} |
||||
|
||||
/** |
||||
* Removes all elements in the half-open interval [iFromIndex, iToIndex). |
||||
* |
||||
* @param iFromIndex the first index which will be removed |
||||
* @param iToIndex one greater than the last index which will be |
||||
* removed |
||||
*/ |
||||
public void removeRange(int iFromIndex, int iToIndex) |
||||
{ |
||||
int iReduction; |
||||
int i; |
||||
|
||||
if ((iFromIndex >= size) || (iToIndex >= size)) |
||||
{ |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"indices=" + |
||||
String.valueOf(iFromIndex) + "," + |
||||
String.valueOf(iToIndex)); |
||||
} |
||||
else if (iFromIndex > iToIndex) |
||||
{ |
||||
throw new IllegalArgumentException("fromIndex(" + |
||||
String.valueOf(iFromIndex) + |
||||
") > toIndex(" + |
||||
String.valueOf(iToIndex) + ")"); |
||||
} |
||||
else if (iFromIndex != iToIndex) |
||||
{ |
||||
iReduction = iToIndex - iFromIndex; |
||||
System.arraycopy(_arData, (iFromIndex + iReduction), _arData, |
||||
iFromIndex, (size - iFromIndex - iReduction)); |
||||
modCount++; |
||||
|
||||
for (i = (iFromIndex + iReduction); i < size; i++) |
||||
_arData[i] = null; |
||||
|
||||
size -= iReduction; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Adds the supplied element at the specified index, shifting all |
||||
* elements currently at that index or higher one to the right. |
||||
* |
||||
* @param iIndex the index at which the element is being added |
||||
* @param oElement the element being added |
||||
*/ |
||||
public void add(int iIndex, Object oElement) |
||||
{ |
||||
if (iIndex > size) |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"index=" + String.valueOf(iIndex)); |
||||
|
||||
ensureCapacity(size + 1); |
||||
System.arraycopy(_arData, iIndex, _arData, |
||||
(iIndex + 1), (size - iIndex)); |
||||
_arData[iIndex] = oElement; |
||||
size++; |
||||
modCount++; |
||||
} |
||||
|
||||
/** |
||||
* Add each element in the supplied Collection to this List. |
||||
* |
||||
* @param oCollection a Collection containing elements to be |
||||
* added to this List |
||||
*/ |
||||
public boolean addAll(Collection oCollection) |
||||
{ |
||||
Iterator itElements; |
||||
int iLen = oCollection.size(); |
||||
|
||||
if (iLen > 0) |
||||
{ |
||||
ensureCapacity(size + iLen); |
||||
modCount++; |
||||
|
||||
itElements = oCollection.iterator(); |
||||
|
||||
while (itElements.hasNext()) |
||||
_arData[size++] = itElements.next(); |
||||
|
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* Add all elements in the supplied collection, inserting them beginning |
||||
* at the specified index. |
||||
* |
||||
* @param iIndex the index at which the elements will be inserted |
||||
* @param oCollection the Collection containing the elements to be |
||||
* inserted |
||||
*/ |
||||
public boolean addAll(int iIndex, Collection oCollection) |
||||
{ |
||||
Iterator itElements; |
||||
int iLen; |
||||
|
||||
if (iIndex > size) |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"index=" + String.valueOf(iIndex)); |
||||
|
||||
iLen = oCollection.size(); |
||||
|
||||
if (iLen > 0) |
||||
{ |
||||
ensureCapacity(size + iLen); |
||||
|
||||
System.arraycopy(_arData, iIndex, _arData, |
||||
(iIndex + iLen), (size - iIndex)); |
||||
modCount++; |
||||
size += iLen; |
||||
|
||||
itElements = oCollection.iterator(); |
||||
while (itElements.hasNext()) |
||||
_arData[iIndex++] = itElements.next(); |
||||
|
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* Creates a shallow copy of this ArrayList |
||||
*/ |
||||
public Object clone() |
||||
{ |
||||
ArrayList oClone; |
||||
|
||||
try |
||||
{ |
||||
oClone = (ArrayList) super.clone(); |
||||
oClone._arData = _arData; |
||||
oClone.size = size; |
||||
} |
||||
catch(CloneNotSupportedException e) |
||||
{ |
||||
oClone = null; |
||||
} |
||||
return oClone; |
||||
} |
||||
|
||||
/** |
||||
* Returns true iff oElement is in this ArrayList. |
||||
* |
||||
* @param oElement the element whose inclusion in the List is being |
||||
* tested |
||||
*/ |
||||
public boolean contains(Object oElement) |
||||
{ |
||||
return (indexOf(oElement) != -1); |
||||
} |
||||
|
||||
/** |
||||
* Returns the lowest index at which oElement appears in this List, or |
||||
* -1 if it does not appear. |
||||
* |
||||
* @param oElement the element whose inclusion in the List is being |
||||
* tested |
||||
*/ |
||||
public int indexOf(Object oElement) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < size; i++) |
||||
{ |
||||
if (doesEqual(oElement, _arData[i])) |
||||
return i; |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
/** |
||||
* Returns the highest index at which oElement appears in this List, or |
||||
* -1 if it does not appear. |
||||
* |
||||
* @param oElement the element whose inclusion in the List is being |
||||
* tested |
||||
*/ |
||||
public int lastIndexOf(Object oElement) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = size - 1; i >= 0; i--) |
||||
{ |
||||
if (doesEqual(oElement, _arData[i])) |
||||
return i; |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
/** |
||||
* Removes all elements from this List |
||||
*/ |
||||
public void clear() |
||||
{ |
||||
int i; |
||||
|
||||
if (size > 0) |
||||
{ |
||||
modCount++; |
||||
size = 0; |
||||
|
||||
for (i = 0; i < size; i++) |
||||
_arData[i] = null; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Sets the element at the specified index. |
||||
* |
||||
* @param iIndex the index at which the element is being set |
||||
* @param oElement the element to be set |
||||
* @return the element previously at the specified index, or null if |
||||
* none was there |
||||
*/ |
||||
public Object set(int iIndex, Object oElement) |
||||
{ |
||||
Object oResult; |
||||
|
||||
if (iIndex >= size) |
||||
throw new IndexOutOfBoundsException("ArrayList size=" + |
||||
String.valueOf(size) + "; " + |
||||
"index=" + String.valueOf(iIndex)); |
||||
oResult = _arData[iIndex]; |
||||
modCount++; |
||||
_arData[iIndex] = oElement; |
||||
|
||||
return oResult; |
||||
} |
||||
|
||||
/** |
||||
* Returns an Object Array containing all of the elements in this ArrayList |
||||
*/ |
||||
public Object[] toArray() |
||||
{ |
||||
Object[] arObjects = new Object[size]; |
||||
System.arraycopy(_arData, 0, arObjects, 0, size); |
||||
return arObjects; |
||||
} |
||||
|
||||
/** |
||||
* Returns an Array whse component type is the runtime component type of |
||||
* the passes-in Array. The returned Array is populated with all of the |
||||
* elements in this ArrayList. If the passed-in Array is not large enough |
||||
* to store all of the elements in this List, a new Array will be created |
||||
* and returned; if the passed-in Array is <i>larger</i> than the size |
||||
* of this List, then size() + 1 index will be set to null. |
||||
* |
||||
* @param arObjects the passed-in Array |
||||
*/ |
||||
public Object[] toArray(Object[] arObjects) |
||||
{ |
||||
Object[] arReturn = (arObjects.length >= size) |
||||
? arObjects |
||||
: (Object[]) |
||||
Array.newInstance(arObjects.getClass().getComponentType(), size); |
||||
|
||||
System.arraycopy(_arData, 0, arReturn, 0, size); |
||||
|
||||
if (arReturn.length > size) |
||||
arReturn[size] = null; |
||||
|
||||
return arReturn; |
||||
} |
||||
|
||||
/** |
||||
* Trims the capacity of tjis List to be equal to its size; |
||||
* a memory saver. |
||||
*/ |
||||
public void trimToSize() |
||||
{ |
||||
Object[] arNewData = new Object[size]; |
||||
System.arraycopy(_arData, 0, arNewData, 0, size); |
||||
modCount++; |
||||
_arData = arNewData; |
||||
} |
||||
|
||||
private void writeObject(ObjectOutputStream oOut) |
||||
throws IOException |
||||
{ |
||||
int i; |
||||
|
||||
oOut.defaultWriteObject(); |
||||
|
||||
oOut.writeInt(_arData.length); |
||||
for (i = 0; i < _arData.length; i++) |
||||
oOut.writeObject(_arData[i]); |
||||
} |
||||
|
||||
private void readObject(ObjectInputStream oIn) |
||||
throws IOException, ClassNotFoundException |
||||
{ |
||||
int i; |
||||
int iCapacity; |
||||
oIn.defaultReadObject(); |
||||
|
||||
iCapacity = oIn.readInt(); |
||||
_arData = new Object[iCapacity]; |
||||
|
||||
for (i = 0; i < iCapacity; i++) |
||||
_arData[i] = oIn.readObject(); |
||||
} |
||||
|
||||
private static final boolean doesEqual(Object oOne, Object oTwo) |
||||
{ |
||||
return ((oOne == null) ? (oTwo == null) : oOne.equals(oTwo)); |
||||
} |
||||
} |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,138 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// BasicMapEntry.java -- a class providing a plain-vanilla implementation of
|
||||
// the Map.Entry interface; could be used anywhere in
|
||||
// java.util
|
||||
//
|
||||
// Copyright (c) 1998 by Jon A. Zeppieri (jon@eease.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
///#ifdef JDK12
|
||||
///import java.lang.UnsupportedOperationException;
|
||||
///import java.util.Map;
|
||||
///#endif
|
||||
|
||||
/** |
||||
* a class which implements Map.Entry |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
class BasicMapEntry implements Map.Entry |
||||
{ |
||||
/** the key */ |
||||
Object key; |
||||
/** the value */ |
||||
Object value; |
||||
|
||||
/** |
||||
* construct a new BasicMapEntry with the given key and value |
||||
* |
||||
* @param newKey the key of this Entry |
||||
* @param newValue the value of this Entry |
||||
*/ |
||||
BasicMapEntry(Object newKey, Object newValue) |
||||
{ |
||||
key = newKey; |
||||
value = newValue; |
||||
} |
||||
|
||||
/** |
||||
* returns true if <pre>o</pre> is a Map.Entry and |
||||
* <pre> |
||||
* (((o.getKey == null) ? (key == null) : |
||||
* o.getKey().equals(key)) && |
||||
* ((o.getValue() == null) ? (value == null) : |
||||
* o.getValue().equals(value))) |
||||
* </pre> |
||||
* |
||||
* NOTE: the calls to getKey() and getValue() in this implementation |
||||
* are <i>NOT</i> superfluous and should not be removed. They insure |
||||
* that subclasses such as HashMapEntry work correctly |
||||
* |
||||
* @param o the Object being tested for equality |
||||
*/ |
||||
public boolean equals(Object o) |
||||
{ |
||||
Map.Entry tester; |
||||
Object oTestingKey, oTestingValue; |
||||
Object oKey, oValue; |
||||
if (o instanceof Map.Entry) |
||||
{ |
||||
tester = (Map.Entry) o; |
||||
oKey = getKey(); |
||||
oValue = getValue(); |
||||
oTestingKey = tester.getKey(); |
||||
oTestingValue = tester.getValue(); |
||||
return (((oTestingKey == null) ? (oKey == null) : |
||||
oTestingKey.equals(oKey)) && |
||||
((oTestingValue == null) ? (oValue == null) : |
||||
oTestingValue.equals(oValue))); |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** returns the key */ |
||||
public Object getKey() |
||||
{ |
||||
return key; |
||||
} |
||||
|
||||
/** returns the value */ |
||||
public Object getValue() |
||||
{ |
||||
return value; |
||||
} |
||||
|
||||
/** the hashCode() for a Map.Entry is |
||||
* <pre> |
||||
* ((getKey() == null) ? 0 : getKey().hashCode()) ^ |
||||
* ((getValue() == null) ? 0 : getValue().hashCode()); |
||||
* </pre> |
||||
* |
||||
* NOTE: the calls to getKey() and getValue() in this implementation |
||||
* are <i>NOT</i> superfluous and should not be removed. They insure |
||||
* that subclasses such as HashMapEntry work correctly |
||||
*/ |
||||
public int hashCode() |
||||
{ |
||||
Object oKey = getKey(); |
||||
Object oValue = getValue(); |
||||
return ((oKey == null) ? 0 : oKey.hashCode()) ^ |
||||
((oValue == null) ? 0 : oValue.hashCode()); |
||||
} |
||||
|
||||
/** |
||||
* sets the value of this Map.Entry |
||||
* |
||||
* @param newValue the new value of this Map.Entry |
||||
*/ |
||||
public Object setValue(Object newValue) |
||||
throws UnsupportedOperationException, ClassCastException, |
||||
IllegalArgumentException, NullPointerException |
||||
{ |
||||
Object oVal = value; |
||||
value = newValue; |
||||
return oVal; |
||||
} |
||||
} |
||||
@ -1,198 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Bucket.java -- a class providing a hash-bucket data structure (a lightweight
|
||||
// linked list)
|
||||
//
|
||||
// Copyright (c) 1998 by Jon A. Zeppieri (jon@eease.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* a class representing a simple, lightweight linked-list, using Node |
||||
* objects as its linked nodes; this is used by Hashtable and HashMap |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
class Bucket |
||||
{ |
||||
/** the first node of the lined list, originally null */ |
||||
Node first; |
||||
|
||||
/** trivial constructor for a Bucket */ |
||||
Bucket() |
||||
{ |
||||
} |
||||
|
||||
/** add this key / value pair to the list |
||||
* |
||||
* @param entry a Map.Entry object to be added to this list |
||||
*/ |
||||
Map.Entry add(Node newNode) |
||||
{ |
||||
Object oKey; |
||||
Object oTestKey = newNode.getKey(); |
||||
Node it = first; |
||||
Node prev = null; |
||||
if (it == null) // if the list is empty (the ideal case), we make a new single-node list
|
||||
{ |
||||
first = newNode; |
||||
return null; |
||||
} |
||||
else // otherwise try to find where this key already exists in the list,
|
||||
{// and if it does, replace the value with the new one (and return the old one)
|
||||
while (it != null) |
||||
{ |
||||
oKey = it.getKey(); |
||||
if ((oKey == null) ? (oTestKey == null) : |
||||
oKey.equals(oTestKey)) |
||||
{ |
||||
if (prev != null) |
||||
prev.next = newNode; |
||||
else |
||||
first = newNode; |
||||
newNode.next = it.next; |
||||
return it; |
||||
} |
||||
prev = it; |
||||
it = it.next; |
||||
} |
||||
prev.next = newNode; // otherwise, just stick this at the
|
||||
return null; // end of the list
|
||||
} |
||||
} |
||||
|
||||
/** |
||||
* remove a Map.Entry in this list with the supplied key and return its value, |
||||
* if it exists, else return null |
||||
* |
||||
* @param key the key we are looking for in this list |
||||
*/ |
||||
Object removeByKey(Object key) |
||||
{ |
||||
Object oEntryKey; |
||||
Node prev = null; |
||||
Node it = first; |
||||
while (it != null) |
||||
{ |
||||
oEntryKey = it.getKey(); |
||||
if ((oEntryKey == null) ? (key == null) : oEntryKey.equals(key)) |
||||
{ |
||||
if (prev == null) // we are removing the first element
|
||||
first = it.next; |
||||
else |
||||
prev.next = it.next; |
||||
return it.getValue(); |
||||
} |
||||
else |
||||
{ |
||||
prev = it; |
||||
it = it.next; |
||||
} |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/** |
||||
* return the value which the supplied key maps to, if it maps to anything in this list, |
||||
* otherwise, return null |
||||
* |
||||
* @param key the key mapping to a value that we are looking for |
||||
*/ |
||||
Object getValueByKey(Object key) |
||||
{ |
||||
Node entry = getEntryByKey(key); |
||||
return (entry == null) ? null : entry.getValue(); |
||||
} |
||||
|
||||
/** |
||||
* return the Map.Entry which the supplied key is a part of, if such a Map.Entry exists, |
||||
* null otherwise |
||||
* |
||||
* this method is important for HashMap, which can hold null values and the null key |
||||
* |
||||
* @param key the key for which we are finding the corresponding Map.Entry |
||||
*/ |
||||
Node getEntryByKey(Object key) |
||||
{ |
||||
Object oEntryKey; |
||||
Node it = first; |
||||
while (it != null) |
||||
{ |
||||
oEntryKey = it.getKey(); |
||||
if ((oEntryKey == null) ? (key == null) : oEntryKey.equals(key)) |
||||
return it; |
||||
it = it.next; |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/** |
||||
* return true if this list has a Map.Entry whose value equals() the supplied value |
||||
* |
||||
* @param value the value we are looking to match in this list |
||||
*/ |
||||
boolean containsValue(Object value) |
||||
{ |
||||
Object oEntryValue; |
||||
Node it = first; |
||||
while (it != null) |
||||
{ |
||||
oEntryValue = it.getValue(); |
||||
if ((oEntryValue == null) ? (value == null) : oEntryValue.equals(value)) |
||||
return true; |
||||
it = it.next; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
// INNSER CLASSES ----------------------------------------------------------
|
||||
|
||||
/** |
||||
* a class represnting a node in our lightweight linked-list |
||||
* that we use for hash buckets; a Node object contains a Map.Entry as its |
||||
* <pre>value</pre> property and a reference (possibly, even hopefully, null) |
||||
* to another Node as its <pre>next</pre> property. |
||||
* |
||||
* There <i>is</i> a reason for not using a highly generic "LinkedNode" type |
||||
* class: we want to eliminate runtime typechecks. |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
static class Node extends BasicMapEntry implements Map.Entry |
||||
{ |
||||
/** a reference to the next node in the linked list */ |
||||
Node next; |
||||
|
||||
/** non-trivial contructor -- sets the <pre>value</pre> of the Bucket upon instantiation */ |
||||
Node(Object key, Object value) |
||||
{ |
||||
super(key, value); |
||||
} |
||||
|
||||
|
||||
} |
||||
// EOF ------------------------------------------------------------------------
|
||||
} |
||||
@ -1,234 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Collection.java -- Interface that represents a collection of objects
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Maybe some more @see clauses would be helpful.
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* Interface that represents a collection of objects. This interface is the |
||||
* root of the collection hierarchy, and does not provide any guarantees about |
||||
* the order of its elements or whether or not duplicate elements are |
||||
* permitted. |
||||
* <p> |
||||
* All methods of this interface that are defined to modify the collection are |
||||
* defined as <dfn>optional</dfn>. An optional operation may throw an |
||||
* UnsupportedOperationException if the data backing this collection does not |
||||
* support such a modification. This may mean that the data structure is |
||||
* immutable, or that it is read-only but may change ("unmodifiable"), or |
||||
* that it is modifiable but of fixed size (such as an array), or any number |
||||
* of other combinations. |
||||
* <p> |
||||
* A class that wishes to implement this interface should consider subclassing |
||||
* AbstractCollection, which provides basic implementations of most of the |
||||
* methods of this interface. Classes that are prepared to make guarantees |
||||
* about ordering or about absence of duplicate elements should consider |
||||
* implementing List or Set respectively, both of which are subinterfaces of |
||||
* Collection. |
||||
* <p> |
||||
* A general-purpose implementation of the Collection interface should in most |
||||
* cases provide at least two constructors: One which takes no arguments and |
||||
* creates an empty collection, and one which takes a Collection as an argument |
||||
* and returns a collection containing the same elements (that is, creates a |
||||
* copy of the argument using its own implementation). |
||||
* |
||||
* @see java.util.List |
||||
* @see java.util.Set |
||||
* @see java.util.AbstractCollection |
||||
*/ |
||||
public interface Collection { |
||||
|
||||
/** |
||||
* Add an element to this collection. |
||||
* |
||||
* @param o the object to add. |
||||
* @returns true if the collection was modified as a result of this action. |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the add operation. |
||||
* @exception ClassCastException if o cannot be added to this collection due |
||||
* to its type. |
||||
* @exception IllegalArgumentException if o cannot be added to this |
||||
* collection for some other reason. |
||||
*/ |
||||
boolean add(Object o); |
||||
|
||||
/** |
||||
* Add the contents of a given collection to this collection. |
||||
* |
||||
* @param c the collection to add. |
||||
* @returns true if the collection was modified as a result of this action. |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the addAll operation. |
||||
* @exception ClassCastException if some element of c cannot be added to this |
||||
* collection due to its type. |
||||
* @exception IllegalArgumentException if some element of c cannot be added |
||||
* to this collection for some other reason. |
||||
*/ |
||||
boolean addAll(Collection c); |
||||
|
||||
/** |
||||
* Clear the collection, such that a subsequent call to isEmpty() would |
||||
* return true. |
||||
* |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the clear operation. |
||||
*/ |
||||
void clear(); |
||||
|
||||
/** |
||||
* Test whether this collection contains a given object as one of its |
||||
* elements. |
||||
* |
||||
* @param o the element to look for. |
||||
* @returns true if this collection contains at least one element e such that |
||||
* <code>o == null ? e == null : o.equals(e)</code>. |
||||
*/ |
||||
boolean contains(Object o); |
||||
|
||||
/** |
||||
* Test whether this collection contains every element in a given collection. |
||||
* |
||||
* @param c the collection to test for. |
||||
* @returns true if for every element o in c, contains(o) would return true. |
||||
*/ |
||||
boolean containsAll(Collection c); |
||||
|
||||
/** |
||||
* Test whether this collection is equal to some object. The Collection |
||||
* interface does not explicitly require any behaviour from this method, and |
||||
* it may be left to the default implementation provided by Object. The Set |
||||
* and List interfaces do, however, require specific behaviour from this |
||||
* method. |
||||
* <p> |
||||
* If an implementation of Collection, which is not also an implementation of |
||||
* Set or List, should choose to implement this method, it should take care |
||||
* to obey the contract of the equals method of Object. In particular, care |
||||
* should be taken to return false when o is a Set or a List, in order to |
||||
* preserve the symmetry of the relation. |
||||
* |
||||
* @param o the object to compare to this collection. |
||||
* @returns true if the o is equal to this collection. |
||||
*/ |
||||
boolean equals(Object o); |
||||
|
||||
/** |
||||
* Obtain a hash code for this collection. The Collection interface does not |
||||
* explicitly require any behaviour from this method, and it may be left to |
||||
* the default implementation provided by Object. The Set and List interfaces |
||||
* do, however, require specific behaviour from this method. |
||||
* <p> |
||||
* If an implementation of Collection, which is not also an implementation of |
||||
* Set or List, should choose to implement this method, it should take care |
||||
* to obey the contract of the hashCode method of Object. Note that this |
||||
* method renders it impossible to correctly implement both Set and List, as |
||||
* the required implementations are mutually exclusive. |
||||
* |
||||
* @returns a hash code for this collection. |
||||
*/ |
||||
int hashCode(); |
||||
|
||||
/** |
||||
* Test whether this collection is empty, that is, if size() == 0. |
||||
* |
||||
* @returns true if this collection contains no elements. |
||||
*/ |
||||
boolean isEmpty(); |
||||
|
||||
/** |
||||
* Obtain an Iterator over this collection. |
||||
* |
||||
* @returns an Iterator over the elements of this collection, in any order. |
||||
*/ |
||||
Iterator iterator(); |
||||
|
||||
/** |
||||
* Remove a single occurrence of an object from this collection. That is, |
||||
* remove an element e, if one exists, such that <code>o == null ? e == null |
||||
* : o.equals(e)</code>. |
||||
* |
||||
* @param o the object to remove. |
||||
* @returns true if the collection changed as a result of this call, that is, |
||||
* if the collection contained at least one occurrence of o. |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the remove operation. |
||||
*/ |
||||
boolean remove(Object o); |
||||
|
||||
/** |
||||
* Remove all elements of a given collection from this collection. That is, |
||||
* remove every element e such that c.contains(e). |
||||
* |
||||
* @returns true if this collection was modified as a result of this call. |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the removeAll operation. |
||||
*/ |
||||
boolean removeAll(Collection c); |
||||
|
||||
/** |
||||
* Remove all elements of this collection that are not contained in a given |
||||
* collection. That is, remove every element e such that !c.contains(e). |
||||
* |
||||
* @returns true if this collection was modified as a result of this call. |
||||
* @exception UnsupportedOperationException if this collection does not |
||||
* support the retainAll operation. |
||||
*/ |
||||
boolean retainAll(Collection c); |
||||
|
||||
/** |
||||
* Get the number of elements in this collection. |
||||
* |
||||
* @returns the number of elements in the collection. |
||||
*/ |
||||
int size(); |
||||
|
||||
/** |
||||
* Copy the current contents of this collection into an array. |
||||
* |
||||
* @returns an array of type Object[] and length equal to the size of this |
||||
* collection, containing the elements currently in this collection, in |
||||
* any order. |
||||
*/ |
||||
Object[] toArray(); |
||||
|
||||
/** |
||||
* Copy the current contents of this collection into an array. If the array |
||||
* passed as an argument has length less than the size of this collection, an |
||||
* array of the same run-time type as a, and length equal to the size of this |
||||
* collection, is allocated using Reflection. Otherwise, a itself is used. |
||||
* The elements of this collection are copied into it, and if there is space |
||||
* in the array, the following element is set to null. The resultant array is |
||||
* returned. |
||||
* Note: The fact that the following element is set to null is only useful |
||||
* if it is known that this collection does not contain any null elements. |
||||
* |
||||
* @param a the array to copy this collection into. |
||||
* @returns an array containing the elements currently in this collection, in |
||||
* any order. |
||||
* @exception ArrayStoreException if the type of any element of the |
||||
* collection is not a subtype of the element type of a. |
||||
*/ |
||||
Object[] toArray(Object[] a); |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,51 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/************************************************************************* |
||||
/* Comparable.java -- Interface for comparaing objects to obtain an ordering |
||||
/* |
||||
/* Copyright (c) 1998 by Free Software Foundation, Inc. |
||||
/* |
||||
/* This program is free software; you can redistribute it and/or modify |
||||
/* it under the terms of the GNU Library General Public License as published |
||||
/* by the Free Software Foundation, version 2. (see COPYING.LIB) |
||||
/* |
||||
/* This program 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 this program; if not, write to the Free Software Foundation |
||||
/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA |
||||
/*************************************************************************/ |
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
** Interface for objects that can be ordering among other |
||||
** objects. The ordering can be <EM>total</EM>, such that two objects |
||||
** only compare equal if they are equal by the equals method, or |
||||
** <EM>partial</EM> such that this is not necessarily true. For |
||||
** example, a case-sensitive dictionary order comparison of Strings |
||||
** is total, but if it is case-insensitive it is partial, because |
||||
** "abc" and "ABC" compare as equal even though "abc".equals("ABC") |
||||
** returns false. |
||||
** |
||||
** @author Geoff Berry |
||||
** |
||||
** @since JDK1.2 |
||||
** @see java.util.Comparator |
||||
**/ |
||||
public interface Comparable |
||||
{ |
||||
/** |
||||
** @return a negative integer if this object is less than |
||||
** <code>o<code>, zero if this object is equal to <code>o</code>, or |
||||
** a positive integer if this object is greater than <code>o</code> |
||||
**/ |
||||
public int compareTo( Object o ); |
||||
} |
||||
@ -1,62 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Comparator.java -- Interface for objects that specify an ordering
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* Interface for objects that specify an ordering between objects. The ordering |
||||
* can be <EM>total</EM>, such that two objects only compare equal if they are |
||||
* equal by the equals method, or <EM>partial</EM> such that this is not |
||||
* necessarily true. For example, a case-sensitive dictionary order comparison |
||||
* of Strings is total, but if it is case-insensitive it is partial, because |
||||
* "abc" and "ABC" compare as equal even though "abc".equals("ABC") returns |
||||
* false. |
||||
* <P> |
||||
* In general, Comparators should be Serializable, because when they are passed |
||||
* to Serializable data structures such as SortedMap or SortedSet, the entire |
||||
* data structure will only serialize correctly if the comparator is |
||||
* Serializable. |
||||
*/ |
||||
public interface Comparator { |
||||
|
||||
/** |
||||
* Return an integer that is negative, zero or positive depending on whether |
||||
* the first argument is less than, equal to or greater than the second |
||||
* according to this ordering. This method should obey the following contract: |
||||
* <UL> |
||||
* <LI>if compare(a, b) < 0 then compare(b, a) > 0</LI> |
||||
* <LI>if compare(a, b) throws an exception, so does compare(b, a)</LI> |
||||
* <LI>if compare(a, b) < 0 and compare(b, c) < 0 then compare(a, c) |
||||
* < 0</LI> |
||||
* <LI>if a.equals(b) or both a and b are null, then compare(a, b) == 0. |
||||
* The converse need not be true, but if it is, this Comparator |
||||
* specifies a <EM>total</EM> ordering.</LI> |
||||
* </UL> |
||||
* |
||||
* @throws ClassCastException if the elements are not of types that can be |
||||
* compared by this ordering. |
||||
*/ |
||||
int compare(Object o1, Object o2); |
||||
} |
||||
@ -1,53 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// ConcurrentModificationException.java -- Data structure concurrently modified
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* Exception that is thrown by the collections classes when it is detected that |
||||
* a modification has been made to a data structure when this is not allowed, |
||||
* such as when a collection is structurally modified while an Iterator is |
||||
* operating over it. In cases where this can be detected, a |
||||
* ConcurrentModificationException will be thrown. An Iterator that detects this |
||||
* condition is referred to as fail-fast. |
||||
*/ |
||||
public class ConcurrentModificationException extends RuntimeException { |
||||
|
||||
/** |
||||
* Constructs a ConcurrentModificationException with no detail message. |
||||
*/ |
||||
public ConcurrentModificationException() { |
||||
super(); |
||||
} |
||||
|
||||
/** |
||||
* Constructs a ConcurrentModificationException with a detail message. |
||||
* |
||||
* @param detail the detail message for the exception |
||||
*/ |
||||
public ConcurrentModificationException(String detail) { |
||||
super(detail); |
||||
} |
||||
} |
||||
@ -1,876 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// HashMap.java -- a class providing a basic hashtable data structure,
|
||||
// mapping Object --> Object; part of the JDK1.2 collections
|
||||
// API
|
||||
//
|
||||
// This is a JDK 1.2 compliant version of HashMap.java
|
||||
//
|
||||
// Copyright (c) 1998 by Jon A. Zeppieri (jon@eease.com),
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
package jode.util; |
||||
import java.util.NoSuchElementException; |
||||
|
||||
import java.io.IOException; |
||||
import java.io.Serializable; |
||||
import java.io.ObjectInputStream; |
||||
import java.io.ObjectOutputStream; |
||||
|
||||
/** |
||||
* This class provides a hashtable-backed implementation of the |
||||
* Map interface. |
||||
* |
||||
* It uses a hash-bucket approach; that is, hash |
||||
* collisions are handled by linking the new node off of the |
||||
* pre-existing node (or list of nodes). In this manner, techniques |
||||
* such as linear probing (which can casue primary clustering) and |
||||
* rehashing (which does not fit very well with Java's method of |
||||
* precomputing hash codes) are avoided. |
||||
* |
||||
* Under ideal circumstances (no collisions, HashMap offers O(1) |
||||
* performance on most operations (<pre>containsValue()</pre> is, |
||||
* of course, O(n)). In the worst case (all keys map to the same |
||||
* hash code -- very unlikely), most operations are O(n). |
||||
* |
||||
* HashMap is part of the JDK1.2 Collections API. It differs from |
||||
* Hashtable in that it accepts the null key and null values, and it |
||||
* does not support "Enumeration views." |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
public class HashMap extends AbstractMap |
||||
implements Map, Cloneable, Serializable |
||||
{ |
||||
// STATIC (CLASS) VARIABLES ------------------------------------------
|
||||
|
||||
/** |
||||
* the default capacity for an instance of HashMap -- I think this |
||||
* is low, and perhaps it shoudl be raised; Sun's documentation mildly |
||||
* suggests that this (11) is the correct value, though |
||||
*/ |
||||
private static final int DEFAULT_CAPACITY = 11; |
||||
|
||||
/** the default load factor of a HashMap */ |
||||
private static final float DEFAULT_LOAD_FACTOR = 0.75F; |
||||
|
||||
/** used internally to represent the null key */ |
||||
private static final HashMap.Null NULL_KEY = new HashMap.Null(); |
||||
|
||||
/** used internally to parameterize the creation of set/collection views */ |
||||
private static final int KEYS = 0; |
||||
|
||||
/** used internally to parameterize the creation of set/collection views */ |
||||
private static final int VALUES = 1; |
||||
|
||||
/** used internally to parameterize the creation of set/collection views */ |
||||
private static final int ENTRIES = 2; |
||||
|
||||
private static final long serialVersionUID = 362498820763181265L; |
||||
|
||||
// INSTANCE VARIABLES -------------------------------------------------
|
||||
|
||||
/** the capacity of this HashMap: denotes the size of the bucket array */ |
||||
transient int capacity; |
||||
|
||||
/** the size of this HashMap: denotes the number of key-value pairs */ |
||||
private transient int size; |
||||
|
||||
/** the load factor of this HashMap: used in computing the threshold |
||||
* @serial |
||||
*/ |
||||
float loadFactor; |
||||
|
||||
/* the rounded product of the capacity and the load factor; when the number of |
||||
* elements exceeds the threshold, the HashMap calls <pre>rehash()</pre> |
||||
* @serial |
||||
*/ |
||||
private int threshold; |
||||
|
||||
/** |
||||
* this data structure contains the actual key-value mappings; a |
||||
* <pre>BucketList</pre> is a lightweight linked list of "Buckets", |
||||
* which, in turn, are linked nodes containing a key-value mapping |
||||
* and a reference to the "next" Bucket in the list |
||||
*/ |
||||
private transient Bucket[] buckets; |
||||
|
||||
/** |
||||
* counts the number of modifications this HashMap has undergone; used by Iterators |
||||
* to know when to throw ConcurrentModificationExceptions (idea ripped-off from |
||||
* Stuart Ballard's AbstractList implementation) |
||||
*/ |
||||
private transient int modCount; |
||||
|
||||
|
||||
// CONSTRUCTORS ---------------------------------------------------------
|
||||
|
||||
/** |
||||
* construct a new HashMap with the default capacity and the default |
||||
* load factor |
||||
*/ |
||||
public HashMap() |
||||
{ |
||||
init(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR); |
||||
} |
||||
|
||||
/** |
||||
* construct a new HashMap with a specific inital capacity and load factor |
||||
* |
||||
* @param initialCapacity the initial capacity of this HashMap (>=0) |
||||
* @param initialLoadFactor the load factor of this HashMap |
||||
* (a misnomer, really, since the load factor of |
||||
* a HashMap does not change) |
||||
* |
||||
* @throws IllegalArgumentException if (initialCapacity < 0) || |
||||
* (initialLoadFactor > 1.0) || |
||||
* (initialLoadFactor <= 0.0) |
||||
*/ |
||||
public HashMap(int initialCapacity, float initialLoadFactor) |
||||
throws IllegalArgumentException |
||||
{ |
||||
if (initialCapacity < 0 || initialLoadFactor <= 0 || initialLoadFactor > 1) |
||||
throw new IllegalArgumentException(); |
||||
else |
||||
init(initialCapacity, initialLoadFactor); |
||||
} |
||||
|
||||
/** |
||||
* construct a new HashMap with a specific inital capacity |
||||
* |
||||
* @param initialCapacity the initial capacity of this HashMap (>=0) |
||||
* |
||||
* @throws IllegalArgumentException if (initialCapacity < 0) |
||||
*/ |
||||
public HashMap(int initialCapacity) |
||||
throws IllegalArgumentException |
||||
{ |
||||
if (initialCapacity < 0) |
||||
throw new IllegalArgumentException(); |
||||
else |
||||
init(initialCapacity, DEFAULT_LOAD_FACTOR); |
||||
} |
||||
|
||||
/** |
||||
* construct a new HashMap from the given Map |
||||
* |
||||
* every element in Map t will be put into this new HashMap |
||||
* |
||||
* @param t a Map whose key / value pairs will be put into |
||||
* the new HashMap. <b>NOTE: key / value pairs |
||||
* are not cloned in this constructor</b> |
||||
*/ |
||||
public HashMap(Map t) |
||||
{ |
||||
int mapSize = t.size() * 2; |
||||
init(((mapSize > DEFAULT_CAPACITY) ? mapSize : DEFAULT_CAPACITY), DEFAULT_LOAD_FACTOR); |
||||
putAll(t); |
||||
} |
||||
|
||||
|
||||
// PUBLIC METHODS ---------------------------------------------------------
|
||||
|
||||
/** returns the number of kay-value mappings currently in this Map */ |
||||
public int size() |
||||
{ |
||||
return size; |
||||
} |
||||
|
||||
/** returns true if there are no key-value mappings currently in this Map */ |
||||
public boolean isEmpty() |
||||
{ |
||||
return size == 0; |
||||
} |
||||
|
||||
/** empties this HashMap of all elements */ |
||||
public void clear() |
||||
{ |
||||
size = 0; |
||||
modCount++; |
||||
buckets = new Bucket[capacity]; |
||||
} |
||||
|
||||
/** |
||||
* returns a shallow clone of this HashMap (i.e. the Map itself is cloned, but |
||||
* its contents are not) |
||||
*/ |
||||
public Object clone() |
||||
{ |
||||
Map.Entry entry; |
||||
Iterator it = entrySet().iterator(); |
||||
HashMap clone = new HashMap(capacity, loadFactor); |
||||
while (it.hasNext()) |
||||
{ |
||||
entry = (Map.Entry) it.next(); |
||||
clone.internalPut(entry.getKey(), entry.getValue()); |
||||
} |
||||
return clone; |
||||
} |
||||
|
||||
/** returns a "set view" of this HashMap's keys */ |
||||
public Set keySet() |
||||
{ |
||||
return new HashMapSet(KEYS); |
||||
} |
||||
|
||||
/** returns a "set view" of this HashMap's entries */ |
||||
public Set entrySet() |
||||
{ |
||||
return new HashMapSet(ENTRIES); |
||||
} |
||||
|
||||
/** returns a "collection view" (or "bag view") of this HashMap's values */ |
||||
public Collection values() |
||||
{ |
||||
return new HashMapCollection(); |
||||
} |
||||
|
||||
/** |
||||
* returns true if the supplied object equals (<pre>equals()</pre>) a key |
||||
* in this HashMap |
||||
* |
||||
* @param key the key to search for in this HashMap |
||||
*/ |
||||
public boolean containsKey(Object key) |
||||
{ |
||||
return (internalGet(key) != null); |
||||
} |
||||
|
||||
/** |
||||
* returns true if this HashMap contains a value <pre>o</pre>, such that |
||||
* <pre>o.equals(value)</pre>. |
||||
* |
||||
* @param value the value to search for in this Hashtable |
||||
*/ |
||||
public boolean containsValue(Object value) |
||||
{ |
||||
int i; |
||||
Bucket list; |
||||
|
||||
for (i = 0; i < capacity; i++) |
||||
{ |
||||
list = buckets[i]; |
||||
if (list != null && list.containsValue(value)) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/* |
||||
* return the value in this Hashtable associated with the supplied key, or <pre>null</pre> |
||||
* if the key maps to nothing |
||||
* |
||||
* @param key the key for which to fetch an associated value |
||||
*/ |
||||
public Object get(Object key) |
||||
{ |
||||
Map.Entry oResult = internalGet(key); |
||||
return (oResult == null) ? null : oResult.getValue(); |
||||
} |
||||
|
||||
/** |
||||
* puts the supplied value into the Map, mapped by the supplied key |
||||
* |
||||
* @param key the HashMap key used to locate the value |
||||
* @param value the value to be stored in the HashMap |
||||
*/ |
||||
public Object put(Object key, Object value) |
||||
{ |
||||
return internalPut(key, value); |
||||
} |
||||
|
||||
/** |
||||
* part of the Map interface; for each Map.Entry in t, the key / value pair is |
||||
* added to this Map, <b>using the <pre>put()</pre> method -- this may not be |
||||
* you want, so be warned (if you override the put() method, this could lead to |
||||
* off behavior)</b> |
||||
* |
||||
* @param t a Map whose key / value pairs will be added to this Hashtable |
||||
*/ |
||||
public void putAll(Map t) |
||||
{ |
||||
Map.Entry entry; |
||||
Iterator it = t.entrySet().iterator(); |
||||
while (it.hasNext()) |
||||
{ |
||||
entry = (Map.Entry) it.next(); |
||||
put(entry.getKey(), entry.getValue()); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* removes from the HashMap and returns the value which is mapped by the |
||||
* supplied key; if the key maps to nothing, then the HashMap remains unchanged, |
||||
* and <pre>null</pre> is returned |
||||
* |
||||
* @param key the key used to locate the value to remove from the HashMap |
||||
*/ |
||||
public Object remove(Object key) |
||||
{ |
||||
Bucket list; |
||||
int index; |
||||
Object result = null; |
||||
if (size > 0) |
||||
{ |
||||
index = hash(((key == null) ? NULL_KEY : key)); |
||||
list = buckets[index]; |
||||
if (list != null) |
||||
{ |
||||
result = list.removeByKey(key); |
||||
if (result != null) |
||||
{ |
||||
size--; |
||||
modCount++; |
||||
if (list.first == null) |
||||
buckets[index] = null; |
||||
} |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
|
||||
// PRIVATE METHODS -----------------------------------------------------------
|
||||
|
||||
/** |
||||
* puts the given key-value pair into this HashMap; a private method is used |
||||
* because it is called by the rehash() method as well as the put() method, |
||||
* and if a subclass overrides put(), then rehash would do funky things |
||||
* if it called put() |
||||
* |
||||
* @param key the HashMap key used to locate the value |
||||
* @param value the value to be stored in the HashMap |
||||
*/ |
||||
private Object internalPut(Object key, Object value) |
||||
{ |
||||
HashMapEntry entry; |
||||
Bucket list; |
||||
int hashIndex; |
||||
Object oResult; |
||||
Object oRealKey = ((key == null) ? NULL_KEY : key); |
||||
|
||||
modCount++; |
||||
if (size == threshold) |
||||
rehash(); |
||||
entry = new HashMapEntry(oRealKey, value); |
||||
hashIndex = hash(oRealKey); |
||||
list = buckets[hashIndex]; |
||||
if (list == null) |
||||
{ |
||||
list = new Bucket(); |
||||
buckets[hashIndex] = list; |
||||
} |
||||
oResult = list.add(entry); |
||||
if (oResult == null) |
||||
{ |
||||
size++; |
||||
return null; |
||||
} |
||||
else |
||||
{ |
||||
return ((Map.Entry) oResult).getValue(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a private method, called by all of the constructors to initialize a new HashMap |
||||
* |
||||
* @param initialCapacity the initial capacity of this HashMap (>=0) |
||||
* @param initialLoadFactor the load factor of this HashMap |
||||
* (a misnomer, really, since the load factor of |
||||
* a HashMap does not change) |
||||
*/ |
||||
private void init(int initialCapacity, float initialLoadFactor) |
||||
{ |
||||
size = 0; |
||||
modCount = 0; |
||||
capacity = initialCapacity; |
||||
loadFactor = initialLoadFactor; |
||||
threshold = (int) ((float) capacity * loadFactor); |
||||
buckets = new Bucket[capacity]; |
||||
} |
||||
|
||||
/** private -- simply hashes a non-null Object to its array index */ |
||||
private int hash(Object key) |
||||
{ |
||||
return Math.abs(key.hashCode() % capacity); |
||||
} |
||||
|
||||
/** |
||||
* increases the size of the HashMap and rehashes all keys to new array indices; |
||||
* this is called when the addition of a new value would cause size() > threshold |
||||
*/ |
||||
private void rehash() |
||||
{ |
||||
int i; |
||||
Bucket[] data = buckets; |
||||
Bucket.Node node; |
||||
|
||||
modCount++; |
||||
capacity = (capacity * 2) + 1; |
||||
size = 0; |
||||
threshold = (int) ((float) capacity * loadFactor); |
||||
buckets = new Bucket[capacity]; |
||||
for (i = 0; i < data.length; i++) |
||||
{ |
||||
if (data[i] != null) |
||||
{ |
||||
node = data[i].first; |
||||
while (node != null) |
||||
{ |
||||
internalPut(node.getKey(), node.getValue()); |
||||
node = node.next; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a private method which does the "dirty work" (or some of it anyway) of fetching a value |
||||
* with a key |
||||
* |
||||
* @param key the key for which to fetch an associated value |
||||
*/ |
||||
private Map.Entry internalGet(Object key) |
||||
{ |
||||
Bucket list; |
||||
if (size == 0) |
||||
{ |
||||
return null; |
||||
} |
||||
else |
||||
{ |
||||
list = buckets[hash(((key == null) ? NULL_KEY : key))]; |
||||
return (list == null) ? null : list.getEntryByKey(key); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a private method used by inner class HashMapSet to implement its own |
||||
* <pre>contains(Map.Entry)</pre> method; returns true if the supplied |
||||
* key / value pair is found in this HashMap (again, using <pre>equals()</pre>, |
||||
* rather than <pre>==</pre>) |
||||
* |
||||
* @param entry a Map.Entry to match against key / value pairs in |
||||
* this HashMap |
||||
*/ |
||||
private boolean containsEntry(Map.Entry entry) |
||||
{ |
||||
Map.Entry oInternalEntry; |
||||
if (entry == null) |
||||
{ |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
oInternalEntry = internalGet(entry.getKey()); |
||||
return (oInternalEntry != null && oInternalEntry.equals(entry)); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Serializes this object to the given stream. |
||||
* @serialdata the <i>capacity</i>(int) that is the length of the |
||||
* bucket array, the <i>size</i>(int) of the hash map are emitted |
||||
* first. They are followed by size entries, each consisting of |
||||
* a key (Object) and a value (Object). |
||||
*/ |
||||
private void writeObject(ObjectOutputStream s) |
||||
throws IOException |
||||
{ |
||||
// the fields
|
||||
s.defaultWriteObject(); |
||||
|
||||
s.writeInt(capacity); |
||||
s.writeInt(size); |
||||
Iterator it = entrySet().iterator(); |
||||
while (it.hasNext()) |
||||
{ |
||||
Map.Entry oEntry = (Map.Entry) it.next(); |
||||
s.writeObject(oEntry.getKey()); |
||||
s.writeObject(oEntry.getValue()); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Deserializes this object from the given stream. |
||||
* @serialdata the <i>capacity</i>(int) that is the length of the |
||||
* bucket array, the <i>size</i>(int) of the hash map are emitted |
||||
* first. They are followed by size entries, each consisting of |
||||
* a key (Object) and a value (Object). |
||||
*/ |
||||
private void readObject(ObjectInputStream s) |
||||
throws IOException, ClassNotFoundException |
||||
{ |
||||
// the fields
|
||||
s.defaultReadObject(); |
||||
|
||||
capacity = s.readInt(); |
||||
int iLen = s.readInt(); |
||||
size = 0; |
||||
modCount = 0; |
||||
buckets = new Bucket[capacity]; |
||||
|
||||
for (int i = 0; i < iLen; i++) |
||||
{ |
||||
Object oKey = s.readObject(); |
||||
Object oValue = s.readObject(); |
||||
internalPut(oKey, oValue); |
||||
} |
||||
} |
||||
|
||||
// INNER CLASSES -------------------------------------------------------------
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** |
||||
* an inner class providing a Set view of a HashMap; this implementation is |
||||
* parameterized to view either a Set of keys or a Set of Map.Entry objects |
||||
* |
||||
* Note: a lot of these methods are implemented by AbstractSet, and would work |
||||
* just fine without any meddling, but far greater efficiency can be gained by |
||||
* overriding a number of them. And so I did. |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
private class HashMapSet extends AbstractSet |
||||
implements Set |
||||
{ |
||||
/** the type of this Set view: KEYS or ENTRIES */ |
||||
private int setType; |
||||
|
||||
/** construct a new HashtableSet with the supplied view type */ |
||||
HashMapSet(int type) |
||||
{ |
||||
setType = type; |
||||
} |
||||
|
||||
/** |
||||
* adding an element is unsupported; this method simply throws an exception |
||||
* |
||||
* @throws UnsupportedOperationException |
||||
*/ |
||||
public boolean add(Object o) throws UnsupportedOperationException |
||||
{ |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** |
||||
* adding an element is unsupported; this method simply throws an exception |
||||
* |
||||
* @throws UnsupportedOperationException |
||||
*/ |
||||
public boolean addAll(Collection c) throws UnsupportedOperationException |
||||
{ |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** |
||||
* clears the backing HashMap; this is a prime example of an overridden implementation |
||||
* which is far more efficient than its superclass implementation (which uses an iterator |
||||
* and is O(n) -- this is an O(1) call) |
||||
*/ |
||||
public void clear() |
||||
{ |
||||
HashMap.this.clear(); |
||||
} |
||||
|
||||
/** |
||||
* returns true if the supplied object is contained by this Set |
||||
* |
||||
* @param o an Object being testing to see if it is in this Set |
||||
*/ |
||||
public boolean contains(Object o) |
||||
{ |
||||
if (setType == KEYS) |
||||
return HashMap.this.containsKey(o); |
||||
else |
||||
return (o instanceof Map.Entry) ? HashMap.this.containsEntry((Map.Entry) o) : false; |
||||
} |
||||
|
||||
/** |
||||
* returns true if the backing HashMap is empty (which is the only case either a KEYS |
||||
* Set or an ENTRIES Set would be empty) |
||||
*/ |
||||
public boolean isEmpty() |
||||
{ |
||||
return HashMap.this.isEmpty(); |
||||
} |
||||
|
||||
/** |
||||
* removes the supplied Object from the Set |
||||
* |
||||
* @param o the Object to be removed |
||||
*/ |
||||
public boolean remove(Object o) |
||||
{ |
||||
if (setType == KEYS) |
||||
return (HashMap.this.remove(o) != null); |
||||
else |
||||
return (o instanceof Map.Entry) ? |
||||
(HashMap.this.remove(((Map.Entry) o).getKey()) != null) : false; |
||||
} |
||||
|
||||
/** returns the size of this Set (always equal to the size of the backing Hashtable) */ |
||||
public int size() |
||||
{ |
||||
return HashMap.this.size(); |
||||
} |
||||
|
||||
/** returns an Iterator over the elements of this Set */ |
||||
public Iterator iterator() |
||||
{ |
||||
return new HashMapIterator(setType); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Like the above Set view, except this one if for values, which are not |
||||
* guaranteed to be unique in a Map; this prvides a Bag of values |
||||
* in the HashMap |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
private class HashMapCollection extends AbstractCollection |
||||
implements Collection |
||||
{ |
||||
/** a trivial contructor for HashMapCollection */ |
||||
HashMapCollection() |
||||
{ |
||||
} |
||||
|
||||
/** |
||||
* adding elements is not supported by this Collection; |
||||
* this method merely throws an exception |
||||
* |
||||
* @throws UnsupportedOperationException |
||||
*/ |
||||
public boolean add(Object o) throws UnsupportedOperationException |
||||
{ |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** |
||||
* adding elements is not supported by this Collection; |
||||
* this method merely throws an exception |
||||
* |
||||
* @throws UnsupportedOperationException |
||||
*/ |
||||
public boolean addAll(Collection c) throws UnsupportedOperationException |
||||
{ |
||||
throw new UnsupportedOperationException(); |
||||
} |
||||
|
||||
/** removes all elements from this Collection (and from the backing HashMap) */ |
||||
public void clear() |
||||
{ |
||||
HashMap.this.clear(); |
||||
} |
||||
|
||||
/** |
||||
* returns true if this Collection contains at least one Object which equals() the |
||||
* supplied Object |
||||
* |
||||
* @param o the Object to compare against those in the Set |
||||
*/ |
||||
public boolean contains(Object o) |
||||
{ |
||||
return HashMap.this.containsValue(o); |
||||
} |
||||
|
||||
/** returns true IFF the Collection has no elements */ |
||||
public boolean isEmpty() |
||||
{ |
||||
return HashMap.this.isEmpty(); |
||||
} |
||||
|
||||
/** returns the size of this Collection */ |
||||
public int size() |
||||
{ |
||||
return HashMap.this.size(); |
||||
} |
||||
|
||||
/** returns an Iterator over the elements in this Collection */ |
||||
public Iterator iterator() |
||||
{ |
||||
return new HashMapIterator(VALUES); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a class which implements the Iterator interface and is used for |
||||
* iterating over HashMaps; |
||||
* this implementation is parameterized to give a sequential view of |
||||
* keys, values, or entries; it also allows the removal of elements, |
||||
* as per the Javasoft spec. |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
class HashMapIterator implements Iterator |
||||
{ |
||||
/** the type of this Iterator: KEYS, VALUES, or ENTRIES */ |
||||
private int myType; |
||||
/** |
||||
* the number of modifications to the backing Hashtable for which |
||||
* this Iterator can account (idea ripped off from Stuart Ballard) |
||||
*/ |
||||
private int knownMods; |
||||
/** the location of our sequential "cursor" */ |
||||
private int position; |
||||
/** the current index of the BucketList array */ |
||||
private int bucketIndex; |
||||
/** a reference, originally null, to the specific Bucket our "cursor" is pointing to */ |
||||
private Bucket.Node currentNode; |
||||
/** a reference to the current key -- used fro removing elements via the Iterator */ |
||||
private Object currentKey; |
||||
|
||||
/** construct a new HashtableIterator with the supllied type: KEYS, VALUES, or ENTRIES */ |
||||
HashMapIterator(int type) |
||||
{ |
||||
myType = type; |
||||
knownMods = HashMap.this.modCount; |
||||
position = 0; |
||||
bucketIndex = -1; |
||||
currentNode = null; |
||||
currentKey = null; |
||||
} |
||||
|
||||
/** |
||||
* Stuart Ballard's code: if the backing HashMap has been altered through anything |
||||
* but <i>this</i> Iterator's <pre>remove()</pre> method, we will give up right here, |
||||
* rather than risking undefined behavior |
||||
* |
||||
* @throws ConcurrentModificationException |
||||
*/ |
||||
private void checkMod() |
||||
{ |
||||
if (knownMods != HashMap.this.modCount) |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
|
||||
/** returns true if the Iterator has more elements */ |
||||
public boolean hasNext() |
||||
{ |
||||
checkMod(); |
||||
return position < HashMap.this.size(); |
||||
} |
||||
|
||||
/** returns the next element in the Iterator's sequential view */ |
||||
public Object next() |
||||
{ |
||||
Bucket list = null; |
||||
Object result; |
||||
checkMod(); |
||||
try |
||||
{ |
||||
while (currentNode == null) |
||||
{ |
||||
while (list == null) |
||||
list = HashMap.this.buckets[++bucketIndex]; |
||||
currentNode = list.first; |
||||
} |
||||
currentKey = currentNode.getKey(); |
||||
result = (myType == KEYS) ? currentKey : |
||||
((myType == VALUES) ? currentNode.getValue() : currentNode); |
||||
currentNode = currentNode.next; |
||||
} |
||||
catch(Exception e) |
||||
{ |
||||
throw new NoSuchElementException(); |
||||
} |
||||
position++; |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* removes from the backing HashMap the last element which was fetched with the |
||||
* <pre>next()</pre> method |
||||
*/ |
||||
public void remove() |
||||
{ |
||||
checkMod(); |
||||
if (currentKey == null) |
||||
{ |
||||
throw new IllegalStateException(); |
||||
} |
||||
else |
||||
{ |
||||
HashMap.this.remove(currentKey); |
||||
knownMods++; |
||||
currentKey = null; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a singleton instance of this class (HashMap.NULL_KEY) |
||||
* is used to represent the null key in HashMap objects |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
private static class Null |
||||
{ |
||||
/** trivial constructor */ |
||||
Null() |
||||
{ |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* a HashMap version of Map.Entry -- one thing in this implementation is |
||||
* HashMap-specific: if the key is HashMap.NULL_KEY, getKey() will return |
||||
* null |
||||
* |
||||
* Simply, a key / value pair |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
private static class HashMapEntry extends Bucket.Node implements Map.Entry |
||||
{ |
||||
/** construct a new HashMapEntry with the given key and value */ |
||||
public HashMapEntry(Object key, Object value) |
||||
{ |
||||
super(key, value); |
||||
} |
||||
|
||||
/** |
||||
* if the key == HashMap.NULL_KEY, null is returned, otherwise the actual |
||||
* key is returned |
||||
*/ |
||||
public Object getKey() |
||||
{ |
||||
Object oResult = super.getKey(); |
||||
return (oResult == HashMap.NULL_KEY) ? null : oResult; |
||||
} |
||||
} |
||||
// EOF -----------------------------------------------------------------------
|
||||
} |
||||
@ -1,238 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// HashSet.java -- a class providing a HashMap-backet Set
|
||||
//
|
||||
// Copyright (c) 1998 by Jon A. Zeppieri (jon@eease.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
package jode.util; |
||||
|
||||
import java.io.IOException; |
||||
import java.io.Serializable; |
||||
import java.io.ObjectInputStream; |
||||
import java.io.ObjectOutputStream; |
||||
|
||||
/** |
||||
* This class provides a HashMap-backed implementation of the |
||||
* Set interface. |
||||
* |
||||
* Each element in the Set is a key in the backing HashMap; each key |
||||
* maps to a static token, denoting that the key does, in fact, exist. |
||||
* |
||||
* Most operations are O(1), assuming no hash collisions. In the worst |
||||
* case (where all hases collide), operations are O(n). |
||||
* |
||||
* HashSet is a part of the JDK1.2 Collections API. |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
public class HashSet extends AbstractSet |
||||
implements Set, Cloneable, Serializable |
||||
{ |
||||
// INSTANCE VARIABLES -------------------------------------------------
|
||||
/** the HashMap which backs this Set */ |
||||
private transient HashMap map; |
||||
static final long serialVersionUID = -5024744406713321676L; |
||||
|
||||
// CONSTRUCTORS ---------------------------------------------------------
|
||||
|
||||
/** |
||||
* construct a new, empty HashSet whose backing HashMap has the default |
||||
* capacity and loadFacor |
||||
*/ |
||||
public HashSet() |
||||
{ |
||||
map = new HashMap(); |
||||
} |
||||
|
||||
/** |
||||
* construct a new, empty HashSet whose backing HashMap has the supplied |
||||
* capacity and the default load factor |
||||
* |
||||
* @param initialCapacity the initial capacity of the backing |
||||
* HashMap |
||||
*/ |
||||
public HashSet(int initialCapacity) |
||||
{ |
||||
map = new HashMap(initialCapacity); |
||||
} |
||||
|
||||
/** |
||||
* construct a new, empty HashSet whose backing HashMap has the supplied |
||||
* capacity and load factor |
||||
* |
||||
* @param initialCapacity the initial capacity of the backing |
||||
* HashMap |
||||
* @param loadFactor the load factor of the backing HashMap |
||||
*/ |
||||
public HashSet(int initialCapacity, float loadFactor) |
||||
{ |
||||
map = new HashMap(initialCapacity, loadFactor); |
||||
} |
||||
|
||||
/** |
||||
* construct a new HashSet with the same elements as are in the supplied |
||||
* collection (eliminating any duplicates, of course; the backing HashMap |
||||
* will have the default capacity and load factor |
||||
* |
||||
* @param c a collection containing the elements with |
||||
* which this set will be initialized |
||||
*/ |
||||
public HashSet(Collection c) |
||||
{ |
||||
map = new HashMap(); |
||||
addAll(c); |
||||
} |
||||
|
||||
|
||||
// PUBLIC METHODS ---------------------------------------------------------
|
||||
|
||||
/** |
||||
* adds the given Object to the set if it is not already in the Set, |
||||
* returns true if teh element was added, false otherwise |
||||
* |
||||
* @param o the Object to add to this Set |
||||
*/ |
||||
public boolean add(Object o) |
||||
{ |
||||
if (map.containsKey(o)) |
||||
{ |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
internalAdd(o); |
||||
return true; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* empties this Set of all elements; this is a fast operation [O(1)] |
||||
*/ |
||||
public void clear() |
||||
{ |
||||
map.clear(); |
||||
} |
||||
|
||||
/** |
||||
* returns a shallow copy of this Set (the Set itself is cloned; its |
||||
* elements are not) |
||||
*/ |
||||
public Object clone() |
||||
{ |
||||
Iterator it = iterator(); |
||||
HashSet clone = new HashSet(map.capacity, map.loadFactor); |
||||
while (it.hasNext()) |
||||
clone.internalAdd(it.next()); |
||||
return clone; |
||||
} |
||||
|
||||
/** |
||||
* returns true if the supplied element is in this Set, false otherwise |
||||
* |
||||
* @param o the Object whose presence in this Set we are testing for |
||||
*/ |
||||
public boolean contains(Object o) |
||||
{ |
||||
return map.containsKey(o); |
||||
} |
||||
|
||||
/** |
||||
* returns true if this set has no elements in it (size() == 0) |
||||
*/ |
||||
public boolean isEmpty() |
||||
{ |
||||
return map.isEmpty(); |
||||
} |
||||
|
||||
/** |
||||
* returns an Iterator over the elements of this Set; the Iterator allows |
||||
* removal of elements |
||||
*/ |
||||
public Iterator iterator() |
||||
{ |
||||
return map.keySet().iterator(); |
||||
} |
||||
|
||||
/** |
||||
* removes the supplied Object from this Set if it is in the Set; returns |
||||
* true if an element was removed, false otherwise |
||||
*/ |
||||
public boolean remove(Object o) |
||||
{ |
||||
return (map.remove(o) != null); |
||||
} |
||||
|
||||
/** |
||||
* returns the number of elements in this Set |
||||
*/ |
||||
public int size() |
||||
{ |
||||
return map.size(); |
||||
} |
||||
|
||||
|
||||
// PRIVATE METHODS -----------------------------------------------------------
|
||||
|
||||
/** |
||||
* adds the supplied element to this Set; this private method is used |
||||
* internally [clone()] instead of add(), because add() can be overridden |
||||
* to do unexpected things |
||||
* |
||||
* @param o the Object to add to this Set |
||||
*/ |
||||
private void internalAdd(Object o) |
||||
{ |
||||
map.put(o, Boolean.TRUE); |
||||
} |
||||
|
||||
/** Serialize this Object in a manner which is binary-compatible with the JDK */ |
||||
private void writeObject(ObjectOutputStream s) throws IOException |
||||
{ |
||||
Iterator it = iterator(); |
||||
s.writeInt(map.capacity); |
||||
s.writeFloat(map.loadFactor); |
||||
s.writeInt(size()); |
||||
while (it.hasNext()) |
||||
s.writeObject(it.next()); |
||||
} |
||||
|
||||
/** Deserialize this Object in a manner which is binary-compatible with the JDK */ |
||||
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException |
||||
{ |
||||
int i, iSize, iCapacity; |
||||
float fLoadFactor; |
||||
Object oElement; |
||||
|
||||
iCapacity = s.readInt(); |
||||
fLoadFactor = s.readFloat(); |
||||
iSize = s.readInt(); |
||||
|
||||
map = new HashMap(iCapacity, fLoadFactor); |
||||
|
||||
for (i = 0; i < iSize; i++) |
||||
{ |
||||
oElement = s.readObject(); |
||||
internalAdd(oElement); |
||||
} |
||||
} |
||||
} |
||||
@ -1,66 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Iterator.java -- Interface for iterating over collections
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* An object which iterates over a collection. An Iterator is used to return the |
||||
* items once only, in sequence, by successive calls to the next method. It is |
||||
* also possible to remove elements from the underlying collection by using the |
||||
* optional remove method. Iterator is intended as a replacement for the |
||||
* Enumeration interface of previous versions of Java, which did not have the |
||||
* remove method and had less conveniently named methods. |
||||
*/ |
||||
public interface Iterator { |
||||
|
||||
/** |
||||
* Tests whether there are elements remaining in the collection. |
||||
* |
||||
* @return true if there is at least one more element in the collection, |
||||
* that is, if the next call to next will not throw NoSuchElementException. |
||||
*/ |
||||
boolean hasNext(); |
||||
|
||||
/** |
||||
* Obtain the next element in the collection. |
||||
* |
||||
* @return the next element in the collection |
||||
* @exception NoSuchElementException if there are no more elements |
||||
*/ |
||||
Object next(); |
||||
|
||||
/** |
||||
* Remove from the underlying collection the last element returned by next. |
||||
* This method can be called only once after each call to next. It does not |
||||
* affect what will be returned by subsequent calls to next. This operation is |
||||
* optional, it may throw an UnsupportedOperationException. |
||||
* |
||||
* @exception IllegalStateException if next has not yet been called or remove |
||||
* has already been called since the last call to next. |
||||
* @exception UnsupportedOperationException if this Iterator does not support |
||||
* the remove operation. |
||||
*/ |
||||
void remove(); |
||||
} |
||||
@ -1,581 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// LinkedList.java -- Linked list implementation of the List interface
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
import java.util.NoSuchElementException; |
||||
import java.io.Serializable; |
||||
import java.io.ObjectOutputStream; |
||||
import java.io.ObjectInputStream; |
||||
import java.io.IOException; |
||||
|
||||
// TO DO:
|
||||
// ~ Doc comment for the class.
|
||||
// ~ Doc comments for the non-list methods.
|
||||
// ~ Some commenting on the Backing API and other general implementation notes.
|
||||
|
||||
/** |
||||
* Linked list implementation of the List interface. |
||||
*/ |
||||
public class LinkedList extends AbstractSequentialList |
||||
implements Serializable, Cloneable |
||||
{ |
||||
static final long serialVersionUID = 876323262645176354L; |
||||
|
||||
/** |
||||
* An Entry containing the head (in the next field) and the tail (in the |
||||
* previous field) of the list. The data field is null. If the list is empty, |
||||
* both the head and the tail point to ends itself. |
||||
*/ |
||||
transient Entry ends = new Entry(); |
||||
|
||||
/** |
||||
* The current length of the list. |
||||
*/ |
||||
transient int size = 0; |
||||
|
||||
/** |
||||
* Class to represent an entry in the list. Holds a single element. |
||||
*/ |
||||
private static class Entry { |
||||
|
||||
/** |
||||
* The list element. |
||||
*/ |
||||
Object data = null; |
||||
|
||||
/** |
||||
* The next entry in the list. If this is the last entry in the list, the |
||||
* ends field of the list is held here. |
||||
*/ |
||||
Entry next; |
||||
|
||||
/** |
||||
* The previous entry in the list. If this is the first entry in the list, |
||||
* the ends field of the list is held here. |
||||
*/ |
||||
Entry previous; |
||||
|
||||
/** |
||||
* Create an entry with given data and linkage. |
||||
*/ |
||||
Entry(Object d, Entry n, Entry p) { |
||||
data = d; |
||||
next = n; |
||||
previous = p; |
||||
} |
||||
|
||||
/** |
||||
* Create an entry with no data and linking to itself, for use as the ends |
||||
* field of the list. |
||||
*/ |
||||
Entry() { |
||||
next = previous = this; |
||||
} |
||||
|
||||
/** |
||||
* Remove this entry. |
||||
*/ |
||||
Object remove() { |
||||
previous.next = next; |
||||
next.previous = previous; |
||||
return data; |
||||
} |
||||
} |
||||
|
||||
private static interface Backing { |
||||
void checkMod(int known); |
||||
void upMod(); |
||||
void incSize(int by); |
||||
void decSize(int by); |
||||
} |
||||
|
||||
private final Backing back = new Backing() { |
||||
public void checkMod(int known) { |
||||
if (known != modCount) { |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
} |
||||
public void upMod() { |
||||
modCount++; |
||||
} |
||||
public void incSize(int by) { |
||||
size += by; |
||||
} |
||||
public void decSize(int by) { |
||||
size -= by; |
||||
} |
||||
}; |
||||
|
||||
/** A ListIterator over the list. This class keeps track of its |
||||
* position in the list, the size of the list, and the two list |
||||
* entries it is between. This enables it to be used identically |
||||
* for both the list itself and a sublist of the list. |
||||
*/ |
||||
private static class Iter implements ListIterator { |
||||
|
||||
/** |
||||
* The index of the element that will be returned by next(). |
||||
*/ |
||||
int pos; |
||||
|
||||
/** |
||||
* The size of the backing list. |
||||
*/ |
||||
int size; |
||||
|
||||
/** |
||||
* The entry containing the element that will be returned by next(). |
||||
*/ |
||||
Entry next; |
||||
|
||||
/** |
||||
* The entry containing the element that will be returned by previous(). |
||||
*/ |
||||
Entry previous; |
||||
|
||||
/** |
||||
* The entry that will be affected by remove() or set(). |
||||
*/ |
||||
Entry recent; |
||||
|
||||
/** |
||||
* The known value of the modCount of the backing list. |
||||
*/ |
||||
int knownMod; |
||||
|
||||
private final Backing b; |
||||
|
||||
/** |
||||
* Create a new Iter starting at a given Entry within the list, at a given |
||||
* position, in a list of given size. |
||||
* |
||||
* @param index the index to begin iteration. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size. |
||||
*/ |
||||
Iter(Backing backing, Entry n, int index, int s, int mc) { |
||||
b = backing; |
||||
pos = index; |
||||
size = s; |
||||
next = n; |
||||
previous = n.previous; |
||||
knownMod = mc; |
||||
} |
||||
|
||||
public int nextIndex() { |
||||
b.checkMod(knownMod); |
||||
return pos; |
||||
} |
||||
|
||||
public int previousIndex() { |
||||
b.checkMod(knownMod); |
||||
return pos - 1; |
||||
} |
||||
|
||||
public boolean hasNext() { |
||||
b.checkMod(knownMod); |
||||
return pos < size; |
||||
} |
||||
|
||||
public boolean hasPrevious() { |
||||
b.checkMod(knownMod); |
||||
return pos > 0; |
||||
} |
||||
|
||||
public Object next() { |
||||
b.checkMod(knownMod); |
||||
if (pos >= size) { |
||||
throw new NoSuchElementException(); |
||||
} else { |
||||
pos++; |
||||
recent = previous = next; |
||||
next = recent.next; |
||||
return recent.data; |
||||
} |
||||
} |
||||
|
||||
public Object previous() { |
||||
b.checkMod(knownMod); |
||||
if (pos <= 0) { |
||||
throw new NoSuchElementException(); |
||||
} else { |
||||
pos--; |
||||
recent = next = previous; |
||||
previous = recent.previous; |
||||
return recent.data; |
||||
} |
||||
} |
||||
|
||||
public void remove() { |
||||
b.checkMod(knownMod); |
||||
if (recent == null) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
|
||||
// Adjust the position to before the removed element
|
||||
if (recent == previous) pos--; |
||||
|
||||
// Could use recent.remove() but this way is quicker, and also correctly
|
||||
// fixes next and previous.
|
||||
next = recent.previous.next = recent.next; |
||||
previous = recent.next.previous = recent.previous; |
||||
size--; |
||||
b.decSize(1); |
||||
knownMod++; |
||||
b.upMod(); |
||||
recent = null; |
||||
} |
||||
|
||||
public void add(Object o) { |
||||
b.checkMod(knownMod); |
||||
previous.next = next.previous = new Entry(o, next, previous); |
||||
|
||||
// New for 1.2RC1 - the semantics changed so that the iterator is
|
||||
// positioned *after* the new element.
|
||||
previous = next; |
||||
next = previous.next; |
||||
pos++; |
||||
|
||||
size++; |
||||
b.incSize(1); |
||||
knownMod++; |
||||
b.upMod(); |
||||
recent = null; |
||||
} |
||||
|
||||
public void set(Object o) { |
||||
b.checkMod(knownMod); |
||||
if (recent == null) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
recent.data = o; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Obtain the Entry at a given position in a list. This method of course |
||||
* takes linear time, but it is intelligent enough to take the shorter of the |
||||
* paths to get to the Entry required. This implies that the first or last |
||||
* entry in the list is obtained in constant time, which is a very desirable |
||||
* property. |
||||
* For speed and flexibility in which ranges are valid, range checking is not |
||||
* done in this method, and if n is outside the range -1 <= n <= size, the |
||||
* result will be wrong (but no exception will be thrown). |
||||
* Note that you *can* obtain entries at position -1 and size, which are |
||||
* equal to prehead and posttail respectively. |
||||
* This method is static so that it can also be used in subList. |
||||
* |
||||
* @param n the number of the entry to get. |
||||
* @param size the size of the list to get the entry in. |
||||
* @param head the entry before the first element of the list (usually ends). |
||||
* @param tail the entry after the last element of the list (usually ends). |
||||
*/ |
||||
static Entry getEntry(int n, int size, Entry head, Entry tail) { |
||||
|
||||
// n less than size/2, iterate from start
|
||||
if (n < size >> 1) { |
||||
while (n-- >= 0) { |
||||
head = head.next; |
||||
} |
||||
return head; |
||||
|
||||
// n greater than size/2, iterate from end
|
||||
} else { |
||||
while (++n <= size) { |
||||
tail = tail.previous; |
||||
} |
||||
return tail; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Create an empty linked list. |
||||
*/ |
||||
public LinkedList() { |
||||
super(); |
||||
} |
||||
|
||||
/** |
||||
* Create a linked list containing the elements, in order, of a given |
||||
* collection. |
||||
* |
||||
* @param c the collection to populate this list from. |
||||
*/ |
||||
public LinkedList(Collection c) { |
||||
super(); |
||||
// Note: addAll could be made slightly faster, but not enough so to justify
|
||||
// re-implementing it from scratch. It is just a matter of a relatively
|
||||
// small constant factor.
|
||||
addAll(c); |
||||
} |
||||
|
||||
public Object getFirst() { |
||||
if (size == 0) { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
return ends.next.data; |
||||
} |
||||
|
||||
public Object getLast() { |
||||
if (size == 0) { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
return ends.previous.data; |
||||
} |
||||
|
||||
public Object removeFirst() { |
||||
if (size == 0) { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
size--; |
||||
modCount++; |
||||
return ends.next.remove(); |
||||
} |
||||
|
||||
public Object removeLast() { |
||||
if (size == 0) { |
||||
throw new NoSuchElementException(); |
||||
} |
||||
size--; |
||||
modCount++; |
||||
return ends.previous.remove(); |
||||
} |
||||
|
||||
public void addFirst(Object o) { |
||||
ends.next.previous = ends.next = new Entry(o, ends.next, ends); |
||||
size++; |
||||
modCount++; |
||||
} |
||||
|
||||
public void addLast(Object o) { |
||||
ends.previous.next = ends.previous = new Entry(o, ends, ends.previous); |
||||
size++; |
||||
modCount++; |
||||
} |
||||
|
||||
/** |
||||
* Obtain the number of elements currently in this list. |
||||
* |
||||
* @returns the number of elements currently in this list. |
||||
*/ |
||||
public int size() { |
||||
return size; |
||||
} |
||||
|
||||
/** |
||||
* Remove a range of elements from this list. |
||||
* |
||||
* @param fromIndex the index, inclusive, to remove from. |
||||
* @param toIndex the index, exclusive, to remove to. |
||||
* @exception IndexOutOfBoundsException if fromIndex > toIndex || fromIndex < |
||||
* 0 || toIndex > size(). |
||||
*/ |
||||
// Note: normally removeRange is provided to allow efficient ways to
|
||||
// implement clear() on subLists. However, in this case clear on subLists
|
||||
// works anyway, so this implementation is included just for completeness
|
||||
// and because subclasses might try to use it.
|
||||
protected void removeRange(int fromIndex, int toIndex) { |
||||
subList(fromIndex, toIndex).clear(); |
||||
} |
||||
|
||||
/** |
||||
* Clear the list. |
||||
*/ |
||||
public void clear() { |
||||
ends.next = ends.previous = ends; |
||||
modCount++; |
||||
size = 0; |
||||
} |
||||
|
||||
/** |
||||
* Obtain a ListIterator over this list, starting at a given index. The |
||||
* ListIterator returned by this method supports the add, remove and set |
||||
* methods. |
||||
* |
||||
* @param index the index of the element to be returned by the first call to |
||||
* next(), or size() to be initially positioned at the end of the list. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size(). |
||||
*/ |
||||
public ListIterator listIterator(int index) { |
||||
|
||||
// Check bounds
|
||||
if (index < 0 || index > size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
|
||||
return new Iter(back, getEntry(index, size, ends, ends), |
||||
index, size, modCount); |
||||
} |
||||
|
||||
/** |
||||
* Obtain a List view of a subsection of this list, from fromIndex |
||||
* (inclusive) to toIndex (exclusive). The returned list is modifiable in |
||||
* every respect. Changes to the returned list are reflected in this list. If |
||||
* this list is structurally modified is any way other than through the |
||||
* returned list, any subsequent operations on the returned list will result |
||||
* in a ConcurrentModificationException (that is, the returned list is |
||||
* fail-fast). |
||||
* |
||||
* @param fromIndex the index that the returned list should start from |
||||
* (inclusive). |
||||
* @param toIndex the index that the returned list should go to (exclusive). |
||||
* @returns a List backed by a subsection of this list. |
||||
* @exception IndexOutOfBoundsException if fromIndex < 0 || toIndex > size() |
||||
* || fromIndex > toIndex. |
||||
*/ |
||||
public List subList(int fromIndex, int toIndex) { |
||||
|
||||
// Check bounds
|
||||
if (fromIndex > toIndex || fromIndex < 0 || toIndex > size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
|
||||
return new SubLinkedList(back, getEntry(fromIndex - 1, size, ends, ends), |
||||
getEntry(toIndex, size, ends, ends), |
||||
toIndex - fromIndex); |
||||
} |
||||
|
||||
private static class SubLinkedList extends AbstractSequentialList { |
||||
|
||||
Entry head; // entry before the beginning
|
||||
Entry tail; // entry after the end
|
||||
int size; |
||||
private final Backing b; |
||||
|
||||
private final Backing back = new Backing() { |
||||
public void checkMod(int known) { |
||||
if (known != modCount) { |
||||
throw new ConcurrentModificationException(); |
||||
} |
||||
} |
||||
public void upMod() { |
||||
modCount++; |
||||
} |
||||
public void incSize(int by) { |
||||
size += by; |
||||
} |
||||
public void decSize(int by) { |
||||
size -= by; |
||||
} |
||||
}; |
||||
|
||||
SubLinkedList(Backing backing, Entry h, Entry t, int s) { |
||||
b = backing; |
||||
head = h; |
||||
tail = t; |
||||
size = s; |
||||
} |
||||
|
||||
public int size() { |
||||
b.checkMod(this.modCount); |
||||
return size; |
||||
} |
||||
|
||||
public ListIterator listIterator(int index) { |
||||
b.checkMod(this.modCount); |
||||
|
||||
// Check bounds
|
||||
if (index < 0 || index > size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
|
||||
return new Iter(back, getEntry(index, size, head, tail), |
||||
index, size, modCount); |
||||
} |
||||
|
||||
public void clear() { |
||||
b.checkMod(this.modCount); |
||||
head.next = tail; |
||||
tail.previous = head; |
||||
size = 0; |
||||
b.decSize(size); |
||||
modCount++; |
||||
b.upMod(); |
||||
} |
||||
|
||||
// No removeRange because this class cannot be publically subclassed.
|
||||
|
||||
public List subList(int fromIndex, int toIndex) { |
||||
b.checkMod(this.modCount); |
||||
|
||||
// Check bounds
|
||||
if (fromIndex > toIndex || fromIndex < 0 || toIndex > size) { |
||||
throw new IndexOutOfBoundsException(); |
||||
} |
||||
|
||||
return new SubLinkedList(back, getEntry(fromIndex - 1, size, head, tail), |
||||
getEntry(toIndex, size, head, tail), |
||||
toIndex - fromIndex); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Create a shallow copy of this LinkedList. |
||||
* @return an object of the same class as this object, containing the |
||||
* same elements in the same order. |
||||
*/ |
||||
public Object clone() |
||||
{ |
||||
LinkedList copy; |
||||
try |
||||
{ |
||||
copy = (LinkedList) super.clone(); |
||||
} |
||||
catch (CloneNotSupportedException ex) |
||||
{ |
||||
throw new InternalError(ex.getMessage()); |
||||
} |
||||
copy.size = 0; |
||||
copy.ends = new Entry(); |
||||
copy.addAll(this); |
||||
return copy; |
||||
} |
||||
|
||||
/** |
||||
* Serialize an object to a stream. |
||||
* @serialdata the size of the list (int), followed by all the elements |
||||
* (Object) in proper order. |
||||
*/ |
||||
private void writeObject(ObjectOutputStream s) |
||||
throws IOException |
||||
{ |
||||
s.writeInt(size); |
||||
for (Iterator i = iterator(); i.hasNext(); ) |
||||
s.writeObject(i.next()); |
||||
} |
||||
|
||||
/** |
||||
* Deserialize an object from a stream. |
||||
* @serialdata the size of the list (int), followed by all the elements |
||||
* (Object) in proper order. |
||||
*/ |
||||
private void readObject(ObjectInputStream s) |
||||
throws IOException, ClassNotFoundException |
||||
{ |
||||
int serialSize = s.readInt(); |
||||
ends = new Entry(); |
||||
for (int i=0; i< serialSize; i++) |
||||
addLast(s.readObject()); |
||||
} |
||||
} |
||||
@ -1,331 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// List.java -- An ordered collection which allows indexed access
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comment for the interface itself needs to be put into english.
|
||||
// ~ Some more @see clauses might be nice.
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* [This is what this doc comment will mention: |
||||
* ~ Additional restrictions on some methods. Others included for completeness. |
||||
* ~ ListIterator and what it can do |
||||
* ~ Positional and iterated access |
||||
* ~ search (but linear time) |
||||
* ~ be careful when containing self as an element, because equals and hashCode |
||||
* loop.] |
||||
*/ |
||||
public interface List extends Collection { |
||||
|
||||
/** |
||||
* Insert an element into the list at a given position. |
||||
* |
||||
* @param index the location to insert the item. |
||||
* @param o the object to insert. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* add operation. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
* @exception ClassCastException if o cannot be added to this list due to its |
||||
* type. |
||||
* @exception IllegalArgumentException if o cannot be added to this list for |
||||
* some other reason. |
||||
*/ |
||||
void add(int index, Object o); |
||||
|
||||
/** |
||||
* Add an element to the end of the list. |
||||
* |
||||
* @param o the object to add. |
||||
* @returns true, as Collection defines this method as returning true if the |
||||
* list was modified as a result of this action, and it always is for a |
||||
* list. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* add operation. |
||||
* @exception ClassCastException if o cannot be added to this list due to its |
||||
* type. |
||||
* @exception IllegalArgumentException if o cannot be added to this list for |
||||
* some other reason. |
||||
*/ |
||||
boolean add(Object o); |
||||
|
||||
/** |
||||
* Insert the contents of a collection into the list at a given position. |
||||
* |
||||
* @param index the location to insert the collection. |
||||
* @param c the collection to insert. |
||||
* @returns true if the list was modified by this action, that is, if c is |
||||
* non-empty. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* addAll operation. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
* @exception ClassCastException if some element of c cannot be added to this |
||||
* list due to its type. |
||||
* @exception IllegalArgumentException if some element of c cannot be added |
||||
* to this list for some other reason. |
||||
*/ |
||||
boolean addAll(int index, Collection c); |
||||
|
||||
/** |
||||
* Add the contents of a collection to the end of the list. |
||||
* |
||||
* @param c the collection to add. |
||||
* @returns true if the list was modified by this action, that is, if c is |
||||
* non-empty. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* addAll operation. |
||||
* @exception ClassCastException if some element of c cannot be added to this |
||||
* list due to its type. |
||||
* @exception IllegalArgumentException if some element of c cannot be added |
||||
* to this list for some other reason. |
||||
*/ |
||||
boolean addAll(Collection c); |
||||
|
||||
/** |
||||
* Clear the list, such that a subsequent call to isEmpty() would return |
||||
* true. |
||||
* |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* clear operation. |
||||
*/ |
||||
void clear(); |
||||
|
||||
/** |
||||
* Test whether this list contains a given object as one of its elements. |
||||
* |
||||
* @param o the element to look for. |
||||
* @returns true if this list contains an element e such that <code>o == |
||||
* null ? e == null : o.equals(e)</code>. |
||||
*/ |
||||
boolean contains(Object o); |
||||
|
||||
/** |
||||
* Test whether this list contains every element in a given collection. |
||||
* |
||||
* @param c the collection to test for. |
||||
* @returns true if for every element o in c, contains(o) would return true. |
||||
*/ |
||||
boolean containsAll(Collection c); |
||||
|
||||
/** |
||||
* Test whether this list is equal to another object. A List is defined to be |
||||
* equal to an object if and only if that object is also a List, and the two |
||||
* lists are equal. Two lists l1 and l2 are defined to be equal if and only |
||||
* if <code>l1.size() == l2.size()</code>, and for every integer n between 0 |
||||
* and <code>l1.size() - 1</code> inclusive, <code>l1.get(n) == null ? |
||||
* l2.get(n) == null : l1.get(n).equals(l2.get(n))</code>. |
||||
* |
||||
* @param o the object to test for equality with this list. |
||||
* @returns true if o is equal to this list. |
||||
*/ |
||||
boolean equals(Object o); |
||||
|
||||
/** |
||||
* Get the element at a given index in this list. |
||||
* |
||||
* @param index the index of the element to be returned. |
||||
* @returns the element at index index in this list. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index >= size() |
||||
*/ |
||||
Object get(int index); |
||||
|
||||
/** |
||||
* Obtain a hash code for this list. In order to obey the general contract of |
||||
* the hashCode method of class Object, this value is calculated as follows: |
||||
* <pre> |
||||
* hashCode = 1; |
||||
* Iterator i = list.iterator(); |
||||
* while (i.hasNext()) { |
||||
* Object obj = i.next(); |
||||
* hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode()); |
||||
* } |
||||
* </pre> |
||||
* This ensures that the general contract of Object.hashCode() is adhered to. |
||||
* |
||||
* @returns the hash code of this list. |
||||
*/ |
||||
int hashCode(); |
||||
|
||||
/** |
||||
* Obtain the first index at which a given object is to be found in this |
||||
* list. |
||||
* |
||||
* @returns the least integer n such that <code>o == null ? get(n) == null : |
||||
* o.equals(get(n))</code>, or -1 if there is no such index. |
||||
*/ |
||||
int indexOf(Object o); |
||||
|
||||
/** |
||||
* Test whether this list is empty, that is, if size() == 0. |
||||
* |
||||
* @returns true if this list contains no elements. |
||||
*/ |
||||
boolean isEmpty(); |
||||
|
||||
/** |
||||
* Obtain an Iterator over this list. |
||||
* |
||||
* @returns an Iterator over the elements of this list, in order. |
||||
*/ |
||||
Iterator iterator(); |
||||
|
||||
/** |
||||
* Obtain the last index at which a given object is to be found in this |
||||
* list. |
||||
* |
||||
* @returns the greatest integer n such that <code>o == null ? get(n) == null |
||||
* : o.equals(get(n))</code>. |
||||
*/ |
||||
int lastIndexOf(Object o); |
||||
|
||||
/** |
||||
* Obtain a ListIterator over this list, starting at the beginning. |
||||
* |
||||
* @returns a ListIterator over the elements of this list, in order, starting |
||||
* at the beginning. |
||||
*/ |
||||
ListIterator listIterator(); |
||||
|
||||
/** |
||||
* Obtain a ListIterator over this list, starting at a given position. |
||||
* |
||||
* @param index the position, between 0 and size() inclusive, to begin the |
||||
* iteration from. |
||||
* @returns a ListIterator over the elements of this list, in order, starting |
||||
* at index. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
*/ |
||||
ListIterator listIterator(int index); |
||||
|
||||
/** |
||||
* Remove the element at a given position in this list. |
||||
* |
||||
* @param index the position within the list of the object to remove. |
||||
* @returns the object that was removed. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* remove operation. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index > size() |
||||
*/ |
||||
Object remove(int index); |
||||
|
||||
/** |
||||
* Remove the first occurence of an object from this list. That is, remove |
||||
* the first element e such that <code>o == null ? e == null : |
||||
* o.equals(e)</code>. |
||||
* |
||||
* @param o the object to remove. |
||||
* @returns true if the list changed as a result of this call, that is, if |
||||
* the list contained at least one occurrence of o. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* remove operation. |
||||
*/ |
||||
boolean remove(Object o); |
||||
|
||||
/** |
||||
* Remove all elements of a given collection from this list. That is, remove |
||||
* every element e such that c.contains(e). |
||||
* |
||||
* @returns true if this list was modified as a result of this call. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* removeAll operation. |
||||
*/ |
||||
boolean removeAll(Collection c); |
||||
|
||||
/** |
||||
* Remove all elements of this list that are not contained in a given |
||||
* collection. That is, remove every element e such that !c.contains(e). |
||||
* |
||||
* @returns true if this list was modified as a result of this call. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* retainAll operation. |
||||
*/ |
||||
boolean retainAll(Collection c); |
||||
|
||||
/** |
||||
* Replace an element of this list with another object. |
||||
* |
||||
* @param index the position within this list of the element to be replaced. |
||||
* @param o the object to replace it with. |
||||
* @returns the object that was replaced. |
||||
* @exception UnsupportedOperationException if this list does not support the |
||||
* set operation. |
||||
* @exception IndexOutOfBoundsException if index < 0 || index >= size() |
||||
* @exception ClassCastException if o cannot be added to this list due to its |
||||
* type. |
||||
* @exception IllegalArgumentException if o cannot be added to this list for |
||||
* some other reason. |
||||
*/ |
||||
Object set(int index, Object o); |
||||
|
||||
/** |
||||
* Get the number of elements in this list. |
||||
* |
||||
* @returns the number of elements in the list. |
||||
*/ |
||||
int size(); |
||||
|
||||
/** |
||||
* Obtain a List view of a subsection of this list, from fromIndex |
||||
* (inclusive) to toIndex (exclusive). The returned list should be modifiable |
||||
* if and only if this list is modifiable. Changes to the returned list |
||||
* should be reflected in this list. If this list is structurally modified in |
||||
* any way other than through the returned list, the result of any subsequent |
||||
* operations on the returned list is undefined. |
||||
* |
||||
* @param fromIndex the index that the returned list should start from |
||||
* (inclusive). |
||||
* @param toIndex the index that the returned list should go to (exclusive). |
||||
* @returns a List backed by a subsection of this list. |
||||
* @exception IndexOutOfBoundsException if fromIndex < 0 || toIndex > size() |
||||
* || fromIndex > toIndex. |
||||
*/ |
||||
List subList(int fromIndex, int toIndex); |
||||
|
||||
/** |
||||
* Copy the current contents of this list into an array. |
||||
* |
||||
* @returns an array of type Object[] and length equal to the length of this |
||||
* list, containing the elements currently in this list, in order. |
||||
*/ |
||||
Object[] toArray(); |
||||
|
||||
/** |
||||
* Copy the current contents of this list into an array. If the array passed |
||||
* as an argument has length less than that of this list, an array of the |
||||
* same run-time type as a, and length equal to the length of this list, is |
||||
* allocated using Reflection. Otherwise, a itself is used. The elements of |
||||
* this list are copied into it, and if there is space in the array, the |
||||
* following element is set to null. The resultant array is returned. |
||||
* Note: The fact that the following element is set to null is only useful |
||||
* if it is known that this list does not contain any null elements. |
||||
* |
||||
* @param a the array to copy this list into. |
||||
* @returns an array containing the elements currently in this list, in |
||||
* order. |
||||
* @exception ArrayStoreException if the type of any element of the |
||||
* collection is not a subtype of the element type of a. |
||||
*/ |
||||
Object[] toArray(Object[] a); |
||||
} |
||||
@ -1,145 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// ListIterator.java -- Extended Iterator for iterating over ordered lists
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* An extended version of Iterator to support the extra features of Lists. The |
||||
* elements may be accessed in forward or reverse order, elements may be |
||||
* replaced as well as removed, and new elements may be inserted, during the |
||||
* traversal of the list. |
||||
*/ |
||||
public interface ListIterator extends Iterator { |
||||
|
||||
/** |
||||
* Tests whether there are elements remaining in the list in the forward |
||||
* direction. |
||||
* |
||||
* @return true if there is at least one more element in the list in the |
||||
* forward direction, that is, if the next call to next will not throw |
||||
* NoSuchElementException. |
||||
*/ |
||||
boolean hasNext(); |
||||
|
||||
/** |
||||
* Tests whether there are elements remaining in the list in the reverse |
||||
* direction. |
||||
* |
||||
* @return true if there is at least one more element in the list in the |
||||
* reverse direction, that is, if the next call to previous will not throw |
||||
* NoSuchElementException. |
||||
*/ |
||||
boolean hasPrevious(); |
||||
|
||||
/** |
||||
* Obtain the next element in the list in the forward direction. Repeated |
||||
* calls to next may be used to iterate over the entire list, or calls to next |
||||
* and previous may be used together to go forwards and backwards. Alternating |
||||
* calls to next and previous will return the same element. |
||||
* |
||||
* @return the next element in the list in the forward direction |
||||
* @exception NoSuchElementException if there are no more elements |
||||
*/ |
||||
Object next(); |
||||
|
||||
/** |
||||
* Obtain the next element in the list in the reverse direction. Repeated |
||||
* calls to previous may be used to iterate backwards over the entire list, or |
||||
* calls to next and previous may be used together to go forwards and |
||||
* backwards. Alternating calls to next and previous will return the same |
||||
* element. |
||||
* |
||||
* @return the next element in the list in the reverse direction |
||||
* @exception NoSuchElementException if there are no more elements |
||||
*/ |
||||
Object previous(); |
||||
|
||||
/** |
||||
* Find the index of the element that would be returned by a call to next. |
||||
* |
||||
* @return the index of the element that would be returned by a call to next, |
||||
* or list.size() if the iterator is at the end of the list. |
||||
*/ |
||||
int nextIndex(); |
||||
|
||||
/** |
||||
* Find the index of the element that would be returned by a call to previous. |
||||
* |
||||
* @return the index of the element that would be returned by a call to |
||||
* previous, or -1 if the iterator is at the beginning of the list. |
||||
*/ |
||||
int previousIndex(); |
||||
|
||||
/** |
||||
* Insert an element into the list at the current position of the iterator. |
||||
* The element is inserted in between the element that would be returned by |
||||
* previous and the element that would be returned by next. After the |
||||
* insertion, a subsequent call to next is unaffected, but a call to |
||||
* previous returns the item that was added. This operation is optional, it |
||||
* may throw an UnsupportedOperationException. |
||||
* |
||||
* @param o the object to insert into the list |
||||
* @exception ClassCastException the object is of a type which cannot be added |
||||
* to this list |
||||
* @exception IllegalArgumentException some other aspect of the object stops |
||||
* it being added to this list |
||||
* @exception UnsupportedOperationException if this ListIterator does not |
||||
* support the add operation |
||||
*/ |
||||
void add(Object o); |
||||
|
||||
/** |
||||
* Remove from the list the element last returned by a call to next or |
||||
* previous. This method may only be called if neither add nor remove have |
||||
* been called since the last call to next or previous. This operation is |
||||
* optional, it may throw an UnsupportedOperationException. |
||||
* |
||||
* @exception IllegalStateException if neither next or previous have been |
||||
* called, or if add or remove has been called since the last call to next |
||||
* or previous. |
||||
* @exception UnsupportedOperationException if this ListIterator does not |
||||
* support the remove operation. |
||||
*/ |
||||
void remove(); |
||||
|
||||
/** |
||||
* Replace the element last returned by a call to next or previous with a |
||||
* given object. This method may only be called if neither add nor remove have |
||||
* been called since the last call to next or previous. This operation is |
||||
* optional, it may throw an UnsupportedOperationException. |
||||
* |
||||
* @param o the object to replace the element with |
||||
* @exception ClassCastException the object is of a type which cannot be added |
||||
* to this list |
||||
* @exception IllegalArgumentException some other aspect of the object stops |
||||
* it being added to this list |
||||
* @exception IllegalStateException if neither next or previous have been |
||||
* called, or if add or remove has been called since the last call to next |
||||
* or previous. |
||||
* @exception UnsupportedOperationException if this ListIterator does not |
||||
* support the set operation. |
||||
*/ |
||||
void set(Object o); |
||||
} |
||||
@ -1,55 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Map.java -- An object that maps keys to values
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comments for everything.
|
||||
|
||||
package jode.util; |
||||
|
||||
public interface Map |
||||
{ |
||||
public void clear(); |
||||
public boolean containsKey(Object key); |
||||
public boolean containsValue(Object value); |
||||
public Set entrySet(); |
||||
public boolean equals(Object o); |
||||
public Object get(Object key); |
||||
public Object put(Object key, Object value); |
||||
public int hashCode(); |
||||
public boolean isEmpty(); |
||||
public Set keySet(); |
||||
public void putAll(Map m); |
||||
public Object remove(Object o); |
||||
public int size(); |
||||
public Collection values(); |
||||
|
||||
public static interface Entry { |
||||
public Object getKey(); |
||||
public Object getValue(); |
||||
public Object setValue(Object value); |
||||
public int hashCode(); |
||||
public boolean equals(Object o); |
||||
} |
||||
} |
||||
@ -1,46 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Set.java -- A collection that prohibits duplicates
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comments for everything.
|
||||
|
||||
package jode.util; |
||||
|
||||
public interface Set extends Collection { |
||||
boolean add(Object o); |
||||
boolean addAll(Collection c); |
||||
void clear(); |
||||
boolean contains(Object o); |
||||
boolean containsAll(Collection c); |
||||
boolean equals(Object o); |
||||
int hashCode(); |
||||
boolean isEmpty(); |
||||
Iterator iterator(); |
||||
boolean remove(Object o); |
||||
boolean removeAll(Collection c); |
||||
boolean retainAll(Collection c); |
||||
int size(); |
||||
Object[] toArray(); |
||||
} |
||||
@ -1,38 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// SortedMap.java -- A map that makes guarantees about the order of its keys
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comments for everything.
|
||||
|
||||
package jode.util; |
||||
|
||||
public interface SortedMap extends Map { |
||||
Comparator comparator(); |
||||
Object firstKey(); |
||||
SortedMap headMap(Object toKey); |
||||
Object lastKey(); |
||||
SortedMap subMap(Object fromKey, Object toKey); |
||||
SortedMap tailMap(Object fromKey); |
||||
} |
||||
@ -1,38 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// SortedSet.java -- A set that makes guarantees about the order of its elements
|
||||
//
|
||||
// Copyright (c) 1998 by Stuart Ballard (stuart.ballard@mcmail.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// TO DO:
|
||||
// ~ Doc comments for everything.
|
||||
|
||||
package jode.util; |
||||
|
||||
public interface SortedSet extends Set { |
||||
Comparator comparator(); |
||||
Object first(); |
||||
SortedSet headSet(Object toElement); |
||||
Object last(); |
||||
SortedSet subSet(Object fromElement, Object toElement); |
||||
SortedSet tailSet(Object fromElement); |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,331 +0,0 @@ |
||||
// This class is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// TreeSet.java -- a class providing a TreeMap-backet SortedSet
|
||||
//
|
||||
// Copyright (c) 1999 by Jon A. Zeppieri (jon@eease.com)
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Library General Public License as published
|
||||
// by the Free Software Foundation, version 2. (see COPYING.LIB)
|
||||
//
|
||||
// This program 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 Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public License
|
||||
// along with this program; if not, write to the Free Software Foundation
|
||||
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
package jode.util; |
||||
|
||||
import java.io.IOException; |
||||
import java.io.Serializable; |
||||
import java.io.ObjectInputStream; |
||||
import java.io.ObjectOutputStream; |
||||
|
||||
/** |
||||
* This class provides a TreeMap-backed implementation of the |
||||
* SortedSet interface. |
||||
* |
||||
* Each element in the Set is a key in the backing TreeMap; each key |
||||
* maps to a static token, denoting that the key does, in fact, exist. |
||||
* |
||||
* Most operations are O(log n). |
||||
* |
||||
* TreeSet is a part of the JDK1.2 Collections API. |
||||
* |
||||
* @author Jon Zeppieri |
||||
* @version $Revision$ |
||||
* @modified $Id$ |
||||
*/ |
||||
|
||||
public class TreeSet extends AbstractSet |
||||
implements SortedSet, Cloneable, Serializable |
||||
{ |
||||
// INSTANCE VARIABLES -------------------------------------------------
|
||||
|
||||
/** The TreeMap which backs this Set */ |
||||
transient SortedMap _oMap; |
||||
static final long serialVersionUID = -2479143000061671589L; |
||||
|
||||
|
||||
// CONSTRUCTORS -------------------------------------------------------
|
||||
|
||||
/** |
||||
* Construct a new TreeSet whose backing TreeMap using the "natural" ordering |
||||
* of keys. |
||||
*/ |
||||
public TreeSet() |
||||
{ |
||||
this((Comparator) null); |
||||
} |
||||
|
||||
/** |
||||
* Construct a new TreeSet whose backing TreeMap uses the supplied |
||||
* Comparator. |
||||
* |
||||
* @param oComparator the Comparator this Set will use |
||||
*/ |
||||
public TreeSet(Comparator oComparator) |
||||
{ |
||||
_oMap = new TreeMap(oComparator); |
||||
} |
||||
|
||||
/** |
||||
* Construct a new TreeSet whose backing TreeMap uses the "natural" |
||||
* orering of the keys and which contains all of the elements in the |
||||
* supplied Collection. |
||||
* |
||||
* @param oCollection the new Set will be initialized with all |
||||
* of the elements in this Collection |
||||
*/ |
||||
public TreeSet(Collection oCollection) |
||||
{ |
||||
this((Comparator) null); |
||||
addAll(oCollection); |
||||
} |
||||
|
||||
/** |
||||
* Construct a new TreeSet, using the same key ordering as the supplied |
||||
* SortedSet and containing all of the elements in the supplied SortedSet. |
||||
* This constructor runs in linear time. |
||||
* |
||||
* @param oSortedSet the new TreeSet will use this SortedSet's |
||||
* comparator and will initialize itself |
||||
* with all of the elements in this SortedSet |
||||
*/ |
||||
public TreeSet(SortedSet oSortedSet) |
||||
{ |
||||
this(oSortedSet.comparator()); |
||||
|
||||
TreeMap oMap = (TreeMap) _oMap; |
||||
int i = 0; |
||||
Map.Entry[] arEntries = new Map.Entry[oSortedSet.size()]; |
||||
Iterator itEntries = oSortedSet.iterator(); |
||||
|
||||
while (itEntries.hasNext()) |
||||
arEntries[i++] = new BasicMapEntry(itEntries.next(), Boolean.TRUE); |
||||
|
||||
oMap._iSize = i; |
||||
oMap.putAllLinear(arEntries); |
||||
} |
||||
|
||||
TreeSet(SortedMap oMap) |
||||
{ |
||||
_oMap = oMap; |
||||
} |
||||
|
||||
// METHODS -----------------------------------------------------------
|
||||
|
||||
/** |
||||
* Adds the spplied Object to the Set if it is not already in the Set; |
||||
* returns true if the element is added, false otherwise |
||||
* |
||||
* @param oObject the Object to be added to this Set |
||||
*/ |
||||
public boolean add(Object oObject) |
||||
{ |
||||
if (_oMap.containsKey(oObject)) |
||||
{ |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
internalAdd(_oMap, oObject); |
||||
return true; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Adds all of the elements in the supplied Collection to this TreeSet. |
||||
* |
||||
* @param oCollection All of the elements in this Collection |
||||
* will be added to the Set. |
||||
* |
||||
* @return true if the Set is altered, false otherwise |
||||
*/ |
||||
public boolean addAll(Collection oCollection) |
||||
{ |
||||
boolean boResult = false; |
||||
Iterator itElements = oCollection.iterator(); |
||||
|
||||
while (itElements.hasNext()) |
||||
boResult = (boResult || add(itElements.next())); |
||||
|
||||
return boResult; |
||||
} |
||||
|
||||
/** |
||||
* Removes all elements in this Set. |
||||
*/ |
||||
public void clear() |
||||
{ |
||||
_oMap.clear(); |
||||
} |
||||
|
||||
/** Returns a shallow copy of this Set. */ |
||||
public Object clone() |
||||
{ |
||||
TreeSet oClone; |
||||
|
||||
try |
||||
{ |
||||
oClone = (TreeSet) super.clone(); |
||||
oClone._oMap = _oMap; |
||||
} |
||||
catch(CloneNotSupportedException e) |
||||
{ |
||||
oClone = null; |
||||
} |
||||
return oClone; |
||||
} |
||||
|
||||
/** Returns this Set's comparator */ |
||||
public Comparator comparator() |
||||
{ |
||||
return _oMap.comparator(); |
||||
} |
||||
|
||||
/** |
||||
* Returns true if this Set contains the supplied Object, |
||||
* false otherwise |
||||
* |
||||
* @param oObject the Object whose existence in the Set is |
||||
* being tested |
||||
*/ |
||||
public boolean contains(Object oObject) |
||||
{ |
||||
return _oMap.containsKey(oObject); |
||||
} |
||||
|
||||
/** Returns true if this Set has size 0, false otherwise */ |
||||
public boolean isEmpty() |
||||
{ |
||||
return _oMap.isEmpty(); |
||||
} |
||||
|
||||
/** Returns the number of elements in this Set */ |
||||
public int size() |
||||
{ |
||||
return _oMap.size(); |
||||
} |
||||
|
||||
/** |
||||
* If the supplied Object is in this Set, it is removed, and true is |
||||
* returned; otherwise, false is returned. |
||||
* |
||||
* @param oObject the Object we are attempting to remove |
||||
* from this Set |
||||
*/ |
||||
public boolean remove(Object oObject) |
||||
{ |
||||
return (_oMap.remove(oObject) != null); |
||||
} |
||||
|
||||
/** Returns the first (by order) element in this Set */ |
||||
public Object first() |
||||
{ |
||||
return _oMap.firstKey(); |
||||
} |
||||
|
||||
/** Returns the last (by order) element in this Set */ |
||||
public Object last() |
||||
{ |
||||
return _oMap.lastKey(); |
||||
} |
||||
|
||||
/** |
||||
* Returns a view of this Set including all elements in the interval |
||||
* [oFromElement, oToElement). |
||||
* |
||||
* @param oFromElement the resultant view will contain all |
||||
* elements greater than or equal to this |
||||
* element |
||||
* @param oToElement the resultant view will contain all |
||||
* elements less than this element |
||||
*/ |
||||
public SortedSet subSet(Object oFromElement, Object oToElement) |
||||
{ |
||||
return new TreeSet(_oMap.subMap(oFromElement, oToElement)); |
||||
} |
||||
|
||||
/** |
||||
* Returns a view of this Set including all elements less than oToElement |
||||
* |
||||
* @param oToElement the resultant view will contain all |
||||
* elements less than this element |
||||
*/ |
||||
public SortedSet headSet(Object oToElement) |
||||
{ |
||||
return new TreeSet(_oMap.headMap(oToElement)); |
||||
} |
||||
|
||||
/** |
||||
* Returns a view of this Set including all elements greater than or |
||||
* equal to oFromElement. |
||||
* |
||||
* @param oFromElement the resultant view will contain all |
||||
* elements greater than or equal to this |
||||
* element |
||||
*/ |
||||
public SortedSet tailSet(Object oFromElement) |
||||
{ |
||||
return new TreeSet(_oMap.tailMap(oFromElement)); |
||||
} |
||||
|
||||
|
||||
/** Returns in Iterator over the elements in this TreeSet */ |
||||
public Iterator iterator() |
||||
{ |
||||
return _oMap.keySet().iterator(); |
||||
} |
||||
|
||||
private void writeObject(ObjectOutputStream oOut) throws IOException |
||||
{ |
||||
Iterator itElements = iterator(); |
||||
|
||||
oOut.writeObject(comparator()); |
||||
oOut.writeInt(size()); |
||||
|
||||
while (itElements.hasNext()) |
||||
oOut.writeObject(itElements.next()); |
||||
} |
||||
|
||||
private void readObject(ObjectInputStream oIn) |
||||
throws IOException, ClassNotFoundException |
||||
{ |
||||
int i; |
||||
Map.Entry[] arEntries; |
||||
TreeMap oMap; |
||||
Comparator oComparator = (Comparator) oIn.readObject(); |
||||
int iSize = oIn.readInt(); |
||||
|
||||
arEntries = new Map.Entry[iSize]; |
||||
|
||||
for (i = 0; i < iSize; i++) |
||||
arEntries[iSize] = new BasicMapEntry(oIn.readObject(), Boolean.TRUE); |
||||
|
||||
oMap = new TreeMap(oComparator); |
||||
oMap._iSize = iSize; |
||||
oMap.putAllLinear(arEntries); |
||||
_oMap = oMap; |
||||
} |
||||
|
||||
/** |
||||
* adds the supplied element to this Set; this private method is used |
||||
* internally instead of add(), because add() can be overridden |
||||
* to do unexpected things |
||||
* |
||||
* @param o the Object to add to this Set |
||||
*/ |
||||
private static final void internalAdd(Map oMap, Object oObject) |
||||
{ |
||||
oMap.put(oObject, Boolean.TRUE); |
||||
} |
||||
} |
||||
@ -1,54 +0,0 @@ |
||||
// This interface is taken from the Classpath project.
|
||||
// Please note the different copyright holder!
|
||||
// The changes I did is this comment, the package line, some
|
||||
// imports from java.util and some minor jdk12 -> jdk11 fixes.
|
||||
// -- Jochen Hoenicke <jochen@gnu.org>
|
||||
|
||||
/************************************************************************* |
||||
/* UnsupportedOperationException.java -- Exception thrown when an |
||||
/* unsupported operation is attempted on an object |
||||
/* |
||||
/* Copyright (c) 1998 by Free Software Foundation, Inc. |
||||
/* |
||||
/* This program is free software; you can redistribute it and/or modify |
||||
/* it under the terms of the GNU Library General Public License as published |
||||
/* by the Free Software Foundation, version 2. (see COPYING.LIB) |
||||
/* |
||||
/* This program 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 this program; if not, write to the Free Software Foundation |
||||
/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA |
||||
/*************************************************************************/ |
||||
|
||||
package jode.util; |
||||
|
||||
/** |
||||
* This exception is thrown by an object when an operation is |
||||
* requested of it that it does not support. |
||||
* |
||||
* @since JDK 1.2 |
||||
*/ |
||||
public class UnsupportedOperationException extends RuntimeException |
||||
{ |
||||
static final long serialVersionUID = -1242599979055084673L; |
||||
|
||||
/** |
||||
* Create an exception without a message. |
||||
*/ |
||||
public UnsupportedOperationException() |
||||
{ |
||||
super(); |
||||
} |
||||
|
||||
/** |
||||
* Create an exception with a message. |
||||
*/ |
||||
public UnsupportedOperationException( String s ) |
||||
{ |
||||
super(s); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue