suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adds -- base of support to include LinkedList and Iterators into profj

Browse Source 
Commits -- Corrections to interface bugs, and package setup-plt errors

svn: r6482
This commit is contained in:
Kathy Gray 2007-06-05 15:26:06 +00:00
parent 544d337578
commit 3ac1230baa
13 changed files with 2895 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
collects/profj/build-info.ss
View File

@ -266,11 +266,15 @@
(send type-recs add-class-record record)
(send type-recs add-require-syntax class-name (build-require-syntax class path dir #f #f))
(map (lambda (ancestor)
(import-class (car ancestor) (cdr ancestor)
(find-directory
(cdr ancestor)
(lambda () (error 'internal-error "Compiled parent's directory is not found")))
loc type-recs level caller-src add-to-env))
(let* ([ancestor-name (car ancestor)]
[ancestor-path (if (null? (cdr ancestor))
(send type-recs lookup-path ancestor-name
(lambda () null))
(cdr ancestor))])
(import-class ancestor-name ancestor-path
(find-directory ancestor-path
(lambda () (error 'internal-error "Compiled parent's directory is not found")))
loc type-recs level caller-src add-to-env)))
(append (class-record-parents record) (class-record-ifaces record)))
))
((and (dynamic?) (dir-path-scheme? in-dir) (check-scheme-file-exists? class dir))
@ -297,7 +301,8 @@
#;(send type-recs set-location! old-type-loc))
))))
(send type-recs add-require-syntax class-name (build-require-syntax class path dir #t #f)))
(else (file-error 'file (cons class path) caller-src level)))
(else
(file-error 'file (cons class path) caller-src level)))
(when add-to-env (send type-recs add-to-env class path loc))
(send type-recs add-class-req class-name (not add-to-env) loc)))
@ -347,13 +352,11 @@
(make-dir-path (build-path 'same) #f))))))
(classes (if dir (get-class-list dir) null)))
;(printf "~n~nadd-my-package package ~a loc ~a ~n" package loc)
;(printf "add-my-package: dir ~a class ~a~n" dir classes)
;(printf "add-my-package: dir ~a class ~a~n" (dir-path-path dir) classes)
(let ([external-classes (filter (lambda (c) (not (contained-in? defs c))) classes)])
(for-each (lambda (c) (send type-recs add-to-env c package loc)) external-classes)
(for-each (lambda (c)
(import-class c package
(make-dir-path (build-path 'same) #f) loc type-recs level #f #t))
external-classes)
(for-each (lambda (c)
(import-class c package dir loc type-recs level #f #t)) external-classes)
(send type-recs add-package-contents package classes))))
;contained-in? (list definition) definition -> bool
@ -828,7 +831,7 @@
(apply append (cons f (map class-record-fields super-records)))
(apply append (cons m (map class-record-methods super-records)))
(apply append (cons i (map class-record-inners super-records)))
(apply append (cons super-names
(apply append (cons (map class-record-name super-records)
(map class-record-parents super-records)))
null)))
(send type-recs add-class-record record)
@ -1228,23 +1231,23 @@
;class-fully-implemented? class-record id (list class-record) (list id) (list method) type-records symbol -> bool
(define (class-fully-implemented? super super-name ifaces ifaces-name methods type-recs level)
(when (memq 'abstract (class-record-modifiers super))
(let ((unimplemented-iface-methods (get-unimplemented-methods (class-record-methods super)
(class-record-ifaces super)
type-recs)))
(andmap (lambda (unimp iface)
(or (null? unimp)
(implements-all? unimp methods iface level)))
(car unimplemented-iface-methods) (cadr unimplemented-iface-methods))
(let ((unimplemented-iface-methods
(get-unimplemented-methods (class-record-methods super) (class-record-ifaces super)
ifaces ifaces-name type-recs)))
(andmap (lambda (unimp iface)
(or (null? unimp)
(implements-all? unimp methods iface level)))
(car unimplemented-iface-methods) (cadr unimplemented-iface-methods))
(when (memq 'abstract (class-record-modifiers super))
(implements-all? (get-methods-need-implementing (class-record-methods super))
methods super-name level)))
(andmap (lambda (iface iface-name)
(or (super-implements? iface (class-record-ifaces super))
(implements-all? (class-record-methods iface) methods iface-name level)))
ifaces
ifaces-name))
methods super-name level))
#;(andmap (lambda (iface iface-name)
(or (super-implements? iface (class-record-ifaces super) (class-record-methods super))
(implements-all? (class-record-methods iface) methods iface-name level)))
ifaces
ifaces-name)))
;super-implements?: class-record (list (list string))
;super-implements?: class-record (list (list string)) -> boolean
(define (super-implements? iface ifaces)
(member (class-record-name iface) ifaces))
@ -1283,7 +1286,7 @@
((name? iface) (cons (id-string (name-id iface))
(map id-string (name-path iface))))))
ifaces-name)
(map class-record-name ifaces))) type-recs))))
(map class-record-name ifaces))) null null type-recs))))
(apply append
(map (lambda (m-lists)
(map (lambda (m)
@ -1301,8 +1304,9 @@
m-lists))
unimplemented-iface-methods))))
;get-unimplemented-methods: (list method-record) (list (list string)) type-recs -> (list (list (list method-record)) (list string(
(define (get-unimplemented-methods methods ifaces type-recs)
;get-unimplemented-methods: (list method-record) (list (list string))
; (list class-record) (list id) type-recs -> (list (list (list method-record)) (list string))
(define (get-unimplemented-methods methods ifaces iface-records iface-names type-recs)
(letrec ((method-req-equal
(lambda (mrec1 mrec2)
(and (equal? (method-record-name mrec1) (method-record-name mrec2))
@ -1315,12 +1319,11 @@
(or (method-req-equal mrec (car mrecs))
(method-rec-mem mrec (cdr mrecs)))))))
(list (map (lambda (iface)
(let ((iface-rec (send type-recs get-class-record iface)))
(filter (lambda (m) (not (method-rec-mem m methods)))
(class-record-methods iface-rec))))
ifaces)
(map (lambda (iface)
(make-name (make-id (car iface) #f) (cdr iface) #f)) ifaces))))
(filter (lambda (m) (not (method-rec-mem m methods))) (class-record-methods iface)))
(append (map (lambda (iface-spec) (send type-recs get-class-record iface-spec)) ifaces)
iface-records))
(append (map (lambda (iface) (make-name (make-id (car iface) #f) (cdr iface) #f)) ifaces)
(map (lambda (iface) (make-name iface null #f)) iface-names)))))
;get-methods-need-implementing: (list method-record) -> (list method-record)
(define (get-methods-need-implementing methods)

7
collects/profj/installer.ss
View File

@ -1,12 +1,13 @@
(module installer mzscheme
(require (prefix lang: (lib "installer.ss" "profj" "libs" "java" "lang"))
(prefix io: (lib "installer.ss" "profj" "libs" "java" "io"))
(prefix test: (lib "installer.ss" "profj" "libs" "java" "tester"))
(prefix util: (lib "installer.ss" "profj" "libs" "java" "util"))
(prefix test: (lib "installer.ss" "profj" "libs" "java" "tester")))
)
(provide installer)
(define (installer plthome)
(io:installer plthome)
(lang:installer plthome)
(util:installer plthome)
(test:installer plthome)))
(test:installer plthome)
(util:installer plthome)))

463
collects/profj/libs/java/util/AbstractCollection.java Normal file
View File

@ -0,0 +1,463 @@
/* AbstractCollection.java -- Abstract implementation of most of Collection
Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.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.
* <p>
*
* The programmer should provide a no-argument constructor, and one that
* accepts another Collection, as recommended by the Collection interface.
* Unfortunately, there is no way to enforce this in Java.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see AbstractSet
* @see AbstractList
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractCollection implements Collection
{
/**
* The main constructor, for use by subclasses.
*/
protected AbstractCollection()
{
}
/**
* 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.
*
* @return an iterator
*/
public abstract Iterator iterator();
/**
* Return the number of elements in this collection. If there are more than
* Integer.MAX_VALUE elements, return Integer.MAX_VALUE.
*
* @return the size
*/
public abstract int size();
/**
* Add an object to the collection (optional operation). This implementation
* always throws an UnsupportedOperationException - it should be
* overridden if the collection is to be modifiable. If the collection
* does not accept duplicates, simply return false. Collections may specify
* limitations on what may be added.
*
* @param o the object to add
* @return true if the add operation caused the Collection to change
* @throws UnsupportedOperationException if the add operation is not
* supported on this collection
* @throws NullPointerException if the collection does not support null
* @throws ClassCastException if the object is of the wrong type
* @throws IllegalArgumentException if some aspect of the object prevents
* it from being added
*/
public boolean add(Object o)
{
throw new UnsupportedOperationException();
}
/**
* Add all the elements of a given collection to this collection (optional
* operation). 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). The behavior is
* unspecified if the specified collection is modified during the iteration,
* including the special case of trying addAll(this) on a non-empty
* collection.
*
* @param c the collection to add the elements of to this collection
* @return true if the add operation caused the Collection to change
* @throws UnsupportedOperationException if the add operation is not
* supported on this collection
* @throws NullPointerException if this collection does not support null,
* or if the specified collection is null
* @throws ClassCastException if an object in c is of the wrong type
* @throws IllegalArgumentException if some aspect of an object in c prevents
* it from being added
* @see #add(Object)
*/
public boolean addAll(Collection c)
{
Iterator itr = c.iterator();
boolean modified = false;
int pos = c.size();
while (--pos >= 0)
modified = modified | add(itr.next());
return modified;
}
/**
* Remove all elements from the collection (optional operation). 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.
*
* @throws UnsupportedOperationException if the Iterator returned by
* iterator does not provide an implementation of remove
* @see Iterator#remove()
*/
public void clear()
{
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
{
itr.next();
itr.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 itr = iterator();
int pos = size();
while (--pos >= 0)
if (equals(o, itr.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
* @throws NullPointerException if the given collection is null
* @see #contains(Object)
*/
public boolean containsAll(Collection c)
{
Iterator itr = c.iterator();
int pos = c.size();
while (--pos >= 0)
if (!contains(itr.next()))
return false;
return true;
}
/**
* Test whether this collection is empty. This implementation returns
* size() == 0.
*
* @return true if this collection is empty.
* @see #size()
*/
public boolean isEmpty()
{
return size() == 0;
}
/**
* Remove a single instance of an object from this collection (optional
* operation). That is, remove one element e such that
* <code>(o == null ? e == null : o.equals(e))</code>, 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.
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
public boolean remove(Object o)
{
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
if (equals(o, itr.next()))
{
itr.remove();
return true;
}
return false;
}
/**
* Remove from this collection all its elements that are contained in a given
* collection (optional operation). 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
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
public boolean removeAll(Collection c)
{
return removeAllInternal(c);
}
/**
* Remove from this collection all its elements that are contained in a given
* collection (optional operation). 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). This method is necessary for ArrayList,
* which cannot publicly override removeAll but can optimize this call.
*
* @param c the collection to remove the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
boolean removeAllInternal(Collection c)
{
Iterator itr = iterator();
boolean modified = false;
int pos = size();
while (--pos >= 0)
if (c.contains(itr.next()))
{
itr.remove();
modified = true;
}
return modified;
}
/**
* Remove from this collection all its elements that are not contained in a
* given collection (optional operation). 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
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
public boolean retainAll(Collection c)
{
return retainAllInternal(c);
}
/**
* Remove from this collection all its elements that are not contained in a
* given collection (optional operation). 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). This method is necessary for
* ArrayList, which cannot publicly override retainAll but can optimize
* this call.
*
* @param c the collection to retain the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
boolean retainAllInternal(Collection c)
{
Iterator itr = iterator();
boolean modified = false;
int pos = size();
while (--pos >= 0)
if (!c.contains(itr.next()))
{
itr.remove();
modified = true;
}
return modified;
}
/**
* 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. The returned array is safe, and is not backed
* by the collection.
*
* @return an array containing the elements of this collection
*/
public Object[] toArray()
{
Iterator itr = iterator();
int size = size();
Object[] a = new Object[size];
for (int pos = 0; pos < size; pos++)
a[pos] = itr.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.
* The returned array is safe; it is not backed by the collection. Note that
* null may not mark the last element, if the collection allows null
* elements.
*
* @param a the array to copy into, or of the correct run-time type
* @return the array that was produced
* @throws NullPointerException if the given array is null
* @throws ArrayStoreException if the type of the array precludes holding
* one of the elements of the Collection
*/
public Object[] toArray(Object[] a)
{
throw new RuntimeException("toArray(Object[]) is unimplemented");
// int size = size();
// if (a.length < size)
// a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
// size);
// else if (a.length > size)
// a[size] = null;
// Iterator itr = iterator();
// for (int pos = 0; pos < size; pos++)
// a[pos] = itr.next();
//
// 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()
{ return super.toString();
//Iterator itr = iterator();
//StringBuffer r = new StringBuffer("[");
//for (int pos = size(); pos > 0; pos--)
// {
// r.append(itr.next());
// if (pos > 1)
// r.append(", ");
// }
//r.append("]");
//return r.toString();
}
/**
* Compare two objects according to Collection semantics.
*
* @param o1 the first object
* @param o2 the second object
* @return o1 == null ? o2 == null : o1.equals(o2)
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final boolean equals(Object o1, Object o2)
{
return o1 == null ? o2 == null : o1.equals(o2);
}
/**
* Hash an object according to Collection semantics.
*
* @param o the object to hash
* @return o1 == null ? 0 : o1.hashCode()
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final int hashCode(Object o)
{
return o == null ? 0 : o.hashCode();
}
}

974
collects/profj/libs/java/util/AbstractList.java Normal file
View File

@ -0,0 +1,974 @@
/* AbstractList.java -- Abstract implementation of most of List
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* 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. If
* the list is sequential (such as a linked list), use AbstractSequentialList.
* 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.
* <p>
*
* As recommended by Collection and List, the subclass should provide at
* least a no-argument and a Collection constructor. This class is not
* synchronized.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see List
* @see AbstractSequentialList
* @see AbstractCollection
* @see ListIterator
* @since 1.2
* @status updated to 1.4
*/
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). Structural modifications
* are ones which change the list size or affect how iterations would
* behave. This field is available for use by Iterator and ListIterator,
* in order to throw a {@link ConcurrentModificationException} in response
* to the next operation on the iterator. This <i>fail-fast</i> behavior
* saves the user from many subtle bugs otherwise possible from concurrent
* modification during iteration.
* <p>
*
* To make lists fail-fast, increment this field by just 1 in the
* <code>add(int, Object)</code> and <code>remove(int)</code> methods.
* Otherwise, this field may be ignored.
*/
protected int modCount;
public boolean contains(Object o) { return super.contains(o); }
public boolean containsAll( Collection c) { return super.containsAll(c); }
public boolean isEmpty() { return super.isEmpty(); }
public boolean remove(Object o) { return super.remove(o); }
public boolean removeAll( Collection c) { return super.removeAll(c); }
public boolean retainAll( Collection c) { return super.retainAll(c); }
abstract public int size();
public Object[] toArray() { return super.toArray(); }
public Object[] toArray(Object[] o){ return super.toArray(o); }
/**
* The main constructor, for use by subclasses.
*/
protected AbstractList()
{
}
/**
* Returns the elements at the specified position in the list.
*
* @param index the element to return
* @return the element at that position
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
*/
public abstract Object get(int index);
/**
* Insert an element into the list at a given position (optional operation).
* This shifts all existing elements from that position to the end one
* index to the right. This version of add has no return, since it is
* assumed to always succeed if there is no exception. This implementation
* always throws UnsupportedOperationException, and must be overridden to
* make a modifiable List. If you want fail-fast iterators, be sure to
* increment modCount when overriding this.
*
* @param index the location to insert the item
* @param o the object to insert
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
* @see #modCount
*/
public void add(int index, Object o)
{
throw new UnsupportedOperationException();
}
/**
* Add an element to the end of the list (optional operation). If the list
* imposes restraints on what can be inserted, such as no null elements,
* this should be documented. This implementation calls
* <code>add(size(), o);</code>, and will fail if that version does.
*
* @param o the object to add
* @return true, as defined by Collection for a modified list
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
* @see #add(int, Object)
*/
public boolean add(Object o)
{
add(size(), o);
return true;
}
/**
* Insert the contents of a collection into the list at a given position
* (optional operation). Shift all elements at that position to the right
* by the number of elements inserted. This operation is undefined if
* this list is modified during the operation (for example, if you try
* to insert a list into itself). This implementation uses the iterator of
* the collection, repeatedly calling add(int, Object); this will fail
* if add does. This can often be made more efficient.
*
* @param index the location to insert the collection
* @param c the collection to insert
* @return true if the list was modified by this action, that is, if c is
* non-empty
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
* @see #add(int, Object)
*/
public boolean addAll(int index, Collection c)
{
Iterator itr = c.iterator();
int size = c.size();
for (int pos = size; pos > 0; pos--)
add(index++, itr.next());
return size > 0;
}
public boolean addAll(Collection c) { return super.addAll(c); }
/**
* Clear the list, such that a subsequent call to isEmpty() would return
* true (optional operation). This implementation calls
* <code>removeRange(0, size())</code>, so it will fail unless remove
* or removeRange is overridden.
*
* @throws UnsupportedOperationException if this list does not support the
* clear operation
* @see #remove(int)
* @see #removeRange(int, int)
*/
public void clear()
{
removeRange(0, size());
}
/**
* 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 have the same sequence. Two lists l1 and l2 are 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>.
* <p>
*
* This implementation returns true if the object is this, or false if the
* object is not a List. Otherwise, it iterates over both lists (with
* iterator()), returning false if two elements compare false or one list
* is shorter, and true if the iteration completes successfully.
*
* @param o the object to test for equality with this list
* @return true if o is equal to this list
* @see Object#equals(Object)
* @see #hashCode()
*/
public boolean equals(Object o)
{
if (o == this)
return true;
if (! (o instanceof List))
return false;
int size = size();
if (size != ((List) o).size())
return false;
Iterator itr1 = iterator();
Iterator itr2 = ((List) o).iterator();
while (--size >= 0)
if (! AbstractCollection.equals(itr1.next(), itr2.next()))
return false;
return true;
}
/**
* Obtains 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.
*
* @return the hash code of this list
*
* @see Object#hashCode()
* @see #equals(Object)
*/
public int hashCode()
{
int hashCode = 1;
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
hashCode = 31 * hashCode + AbstractCollection.hashCode(itr.next());
return hashCode;
}
/**
* Obtain the first index at which a given object is to be found in this
* list. This implementation follows a listIterator() until a match is found,
* or returns -1 if the list end is reached.
*
* @param o the object to search for
* @return 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
*/
public int indexOf(Object o)
{
ListIterator itr = listIterator();
int size = size();
for (int pos = 0; pos < size; pos++)
if (AbstractCollection.equals(o, itr.next()))
return pos;
return -1;
}
/**
* Obtain an Iterator over this list, whose sequence is the list order.
* This implementation uses size(), get(int), and remove(int) of the
* backing list, and does not support remove unless the list does. This
* implementation is fail-fast if you correctly maintain modCount.
* Also, this implementation is specified by Sun to be distinct from
* listIterator, although you could easily implement it as
* <code>return listIterator(0)</code>.
*
* @return an Iterator over the elements of this list, in order
* @see #modCount
*/
class ALIterator implements Iterator
{
private int pos = 0;
private int size = AbstractList.this.size();
private int last = -1;
private int knownMod = AbstractList.this.modCount;
// This will get inlined, since it is private.
private void checkMod()
{
if (knownMod != AbstractList.this.modCount)
throw new ConcurrentModificationException();
}
public boolean hasNext()
{
checkMod();
return pos < size;
}
public Object next()
{
checkMod();
if (pos == size)
throw new NoSuchElementException();
last = pos;
return AbstractList.this.get(pos++);
}
public void remove()
{
checkMod();
if (last < 0)
throw new IllegalStateException();
AbstractList.this.remove(last);
pos--;
size--;
last = -1;
knownMod = AbstractList.this.modCount;
}
}
public Iterator iterator()
{
// Bah, Sun's implementation forbids using listIterator(0).
return new ALIterator();
}
/**
* Obtain the last index at which a given object is to be found in this
* list. This implementation grabs listIterator(size()), then searches
* backwards for a match or returns -1.
*
* @return the greatest integer n such that <code>o == null ? get(n) == null
* : o.equals(get(n))</code>, or -1 if there is no such index
*/
public int lastIndexOf(Object o)
{
int pos = size();
ListIterator itr = listIterator(pos);
while (--pos >= 0)
if (AbstractCollection.equals(o, itr.previous()))
return pos;
return -1;
}
/**
* Obtain a ListIterator over this list, starting at the beginning. This
* implementation returns listIterator(0).
*
* @return a ListIterator over the elements of this list, in order, starting
* at the beginning
*/
public ListIterator listIterator()
{
return listIterator(0);
}
/**
* Obtain a ListIterator over this list, starting at a given position.
* A first call to next() would return the same as get(index), and a
* first call to previous() would return the same as get(index - 1).
* <p>
*
* This implementation uses size(), get(int), set(int, Object),
* add(int, Object), and remove(int) of the backing list, and does not
* support remove, set, or add unless the list does. This implementation
* is fail-fast if you correctly maintain modCount.
*
* @param index the position, between 0 and size() inclusive, to begin the
* iteration from
* @return a ListIterator over the elements of this list, in order, starting
* at index
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @see #modCount
*/
class lIListIterator implements ListIterator {
int index;
lIListIterator(int i) { index = i; }
private int knownMod = AbstractList.this.modCount;
private int position = index;
private int lastReturned = -1;
private int size = AbstractList.this.size();
// This will get inlined, since it is private.
private void checkModL()
{
if (knownMod != AbstractList.this.modCount)
throw new ConcurrentModificationException();
}
public boolean hasNext()
{
checkModL();
return position < size;
}
public boolean hasPrevious()
{
checkModL();
return position > 0;
}
public Object next()
{
checkModL();
if (position == size)
throw new NoSuchElementException();
lastReturned = position;
return AbstractList.this.get(position++);
}
public Object previous()
{
checkModL();
if (position == 0)
throw new NoSuchElementException();
lastReturned = --position;
return AbstractList.this.get(lastReturned);
}
public int nextIndex()
{
checkModL();
return position;
}
public int previousIndex()
{
checkModL();
return position - 1;
}
public void remove()
{
checkModL();
if (lastReturned < 0)
throw new IllegalStateException();
AbstractList.this.remove(lastReturned);
size--;
position = lastReturned;
lastReturned = -1;
knownMod = AbstractList.this.modCount;
}
public void set(Object o)
{
checkModL();
if (lastReturned < 0)
throw new IllegalStateException();
AbstractList.this.set(lastReturned, o);
}
public void add(Object o)
{
checkModL();
AbstractList.this.add(position++, o);
size++;
lastReturned = -1;
knownMod = AbstractList.this.modCount;
}
}
public ListIterator listIterator(final int index)
{
if (index < 0 || index > size())
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size());
return new lIListIterator(index);
}
/**
* Remove the element at a given position in this list (optional operation).
* Shifts all remaining elements to the left to fill the gap. This
* implementation always throws an UnsupportedOperationException.
* If you want fail-fast iterators, be sure to increment modCount when
* overriding this.
*
* @param index the position within the list of the object to remove
* @return the object that was removed
* @throws UnsupportedOperationException if this list does not support the
* remove operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
* @see #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. Overriding this can reduce quadratic efforts to constant time
* in some cases!
* <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.
*/
protected void removeRange(int fromIndex, int toIndex)
{
ListIterator itr = listIterator(fromIndex);
for (int index = fromIndex; index < toIndex; index++)
{
itr.next();
itr.remove();
}
}
/**
* Replace an element of this list with another object (optional operation).
* This implementation always throws an UnsupportedOperationException.
*
* @param index the position within this list of the element to be replaced
* @param o the object to replace it with
* @return the object that was replaced
* @throws UnsupportedOperationException if this list does not support the
* set operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
*/
public Object set(int index, Object o)
{
throw new UnsupportedOperationException();
}
/**
* Obtain a List view of a subsection of this list, from fromIndex
* (inclusive) to toIndex (exclusive). If the two indices are equal, the
* sublist is empty. 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.
* <p>
*
* This implementation returns a subclass of AbstractList. It stores, in
* private fields, the offset and size of the sublist, and the expected
* modCount of the backing list. If the backing list implements RandomAccess,
* the sublist will also.
* <p>
*
* The subclass's <code>set(int, Object)</code>, <code>get(int)</code>,
* <code>add(int, Object)</code>, <code>remove(int)</code>,
* <code>addAll(int, Collection)</code> and
* <code>removeRange(int, int)</code> methods all delegate to the
* corresponding methods on the backing abstract list, after
* bounds-checking the index and adjusting for the offset. The
* <code>addAll(Collection c)</code> method merely returns addAll(size, c).
* The <code>listIterator(int)</code> method returns a "wrapper object"
* over a list iterator on the backing list, which is created with the
* corresponding method on the backing list. The <code>iterator()</code>
* method merely returns listIterator(), and the <code>size()</code> method
* merely returns the subclass's size field.
* <p>
*
* All methods first check to see if the actual modCount of the backing
* list is equal to its expected value, and throw a
* ConcurrentModificationException if it is not.
*
* @param fromIndex the index that the returned list should start from
* (inclusive)
* @param toIndex the index that the returned list should go to (exclusive)
* @return a List backed by a subsection of this list
* @throws IndexOutOfBoundsException if fromIndex &lt; 0
* || toIndex &gt; size()
* @throws IllegalArgumentException if fromIndex &gt; toIndex
* @see ConcurrentModificationException
* @see RandomAccess
*/
public List subList(int fromIndex, int toIndex)
{
// This follows the specification of AbstractList, but is inconsistent
// with the one in List. Don't you love Sun's inconsistencies?
if (fromIndex > toIndex)
throw new IllegalArgumentException(fromIndex + " > " + toIndex);
if (fromIndex < 0 || toIndex > size())
throw new IndexOutOfBoundsException();
if (((Object) this) instanceof RandomAccess)
return new RandomAccessSubList(this, fromIndex, toIndex);
return new SubList(this, fromIndex, toIndex);
}
} // class AbstractList
/**
* This class follows the implementation requirements set forth in
* {@link AbstractList#subList(int, int)}. It matches Sun's implementation
* by using a non-public top-level class in the same package.
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
*/
class SubList extends AbstractList
{
// Package visible, for use by iterator.
/** The original list. */
AbstractList backingList;
/** The index of the first element of the sublist. */
int offset;
/** The size of the sublist. */
int size;
public boolean contains(Object o) { return super.contains(o); }
public boolean containsAll( Collection c) { return super.containsAll(c); }
public boolean isEmpty() { return super.isEmpty(); }
public boolean remove(Object o) { return super.remove(o); }
public boolean removeAll( Collection c) { return super.removeAll(c); }
public boolean retainAll( Collection c) { return super.retainAll(c); }
public Object[] toArray() { return super.toArray(); }
public Object[] toArray(Object[] o){ return super.toArray(o); }
/**
* Construct the sublist.
*
* @param backing the list this comes from
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
*/
SubList(AbstractList backing, int fromIndex, int toIndex)
{
backingList = backing;
modCount = backing.modCount;
offset = fromIndex;
size = toIndex - fromIndex;
}
/**
* This method checks the two modCount fields to ensure that there has
* not been a concurrent modification, returning if all is okay.
*
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
*/
// This can be inlined. Package visible, for use by iterator.
void checkMod()
{
if (modCount != backingList.modCount)
throw new ConcurrentModificationException();
}
/**
* This method checks that a value is between 0 and size (inclusive). If
* it is not, an exception is thrown.
*
* @param index the value to check
* @throws IndexOutOfBoundsException if the value is out of range
*/
// This will get inlined, since it is private.
private void checkBoundsInclusive(int index)
{
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size);
}
/**
* This method checks that a value is between 0 (inclusive) and size
* (exclusive). If it is not, an exception is thrown.
*
* @param index the value to check
* @throws IndexOutOfBoundsException if the value is out of range
*/
// This will get inlined, since it is private.
private void checkBoundsExclusive(int index)
{
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size);
}
/**
* Specified by AbstractList.subList to return the private field size.
*
* @return the sublist size
*/
public int size()
{
checkMod();
return size;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to modify
* @param o the new value
* @return the old value
*/
public Object set(int index, Object o)
{
checkMod();
checkBoundsExclusive(index);
return backingList.set(index + offset, o);
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to get from
* @return the object at that location
*/
public Object get(int index)
{
checkMod();
checkBoundsExclusive(index);
return backingList.get(index + offset);
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the index to insert at
* @param o the object to add
*/
public void add(int index, Object o)
{
checkMod();
checkBoundsInclusive(index);
backingList.add(index + offset, o);
size++;
modCount = backingList.modCount;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the index to remove
* @return the removed object
*/
public Object remove(int index)
{
checkMod();
checkBoundsExclusive(index);
Object o = backingList.remove(index + offset);
size--;
modCount = backingList.modCount;
return o;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
* This does no bounds checking, as it assumes it will only be called
* by trusted code like clear() which has already checked the bounds.
*
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
*/
protected void removeRange(int fromIndex, int toIndex)
{
checkMod();
backingList.removeRange(offset + fromIndex, offset + toIndex);
size -= toIndex - fromIndex;
modCount = backingList.modCount;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to insert at
* @param c the collection to insert
* @return true if this list was modified, in other words, c is non-empty
*/
public boolean addAll(int index, Collection c)
{
checkMod();
checkBoundsInclusive(index);
int csize = c.size();
boolean result = backingList.addAll(offset + index, c);
size += csize;
modCount = backingList.modCount;
return result;
}
/**
* Specified by AbstractList.subList to return addAll(size, c).
*
* @param c the collection to insert
* @return true if this list was modified, in other words, c is non-empty
*/
public boolean addAll(Collection c)
{
return addAll(size, c);
}
/**
* Specified by AbstractList.subList to return listIterator().
*
* @return an iterator over the sublist
*/
public Iterator iterator()
{
return ((Iterator) ((Object) listIterator()));
}
/**
* Specified by AbstractList.subList to return a wrapper around the
* backing list's iterator.
*
* @param index the start location of the iterator
* @return a list iterator over the sublist
*/
class SLListIterator implements ListIterator
{
int index;
SLListIterator(int i) { index = i; }
private final ListIterator i =
SubList.this.backingList.listIterator(index + SubList.this.offset);
private int position = index;
public boolean hasNext()
{
SubList.this.checkMod();
return position < SubList.this.size;
}
public boolean hasPrevious()
{
SubList.this.checkMod();
return position > 0;
}
public Object next()
{
if (position == SubList.this.size)
throw new NoSuchElementException();
position++;
return i.next();
}
public Object previous()
{
if (position == 0)
throw new NoSuchElementException();
position--;
return i.previous();
}
public int nextIndex()
{
return i.nextIndex() - SubList.this.offset;
}
public int previousIndex()
{
return i.previousIndex() - SubList.this.offset;
}
public void remove()
{
i.remove();
SubList.this.size--;
position = nextIndex();
SubList.this.modCount = SubList.this.backingList.modCount;
}
public void set(Object o)
{
i.set(o);
}
public void add(Object o)
{
i.add(o);
SubList.this.size++;
position++;
SubList.this.modCount = SubList.this.backingList.modCount;
}
// 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 modCount = backingList.modCount must be executed 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 ListIterator listIterator(final int index)
{
checkMod();
checkBoundsInclusive(index);
return new SLListIterator(index);
}
} // class SubList
/**
* This class is a RandomAccess version of SubList, as required by
* {@link AbstractList#subList(int, int)}.
*
* @author Eric Blake <ebb9@email.byu.edu>
*/
final class RandomAccessSubList extends SubList
implements RandomAccess
{
/**
* Construct the sublist.
*
* @param backing the list this comes from
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
*/
RandomAccessSubList(AbstractList backing, int fromIndex, int toIndex)
{
super(backing, fromIndex, toIndex);
}
} // class RandomAccessSubList

229
collects/profj/libs/java/util/AbstractSequentialList.java Normal file
View File

@ -0,0 +1,229 @@
/* AbstractSequentialList.java -- List implementation for sequential access
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* Abstract superclass to make it easier to implement the List interface when
* backed by a sequential-access store, such as a linked list. For random
* access data, use AbstractList. This class implements the random access
* methods (<code>get</code>, <code>set</code>, <code>add</code>, and
* <code>remove</code>) atop the list iterator, opposite of AbstractList's
* approach of implementing the iterator atop random access.
* <p>
*
* To implement a list, you need an implementation for <code>size()</code>
* and <code>listIterator</code>. With just <code>hasNext</code>,
* <code>next</code>, <code>hasPrevious</code>, <code>previous</code>,
* <code>nextIndex</code>, and <code>previousIndex</code>, you have an
* unmodifiable list. For a modifiable one, add <code>set</code>, and for
* a variable-size list, add <code>add</code> and <code>remove</code>.
* <p>
*
* The programmer should provide a no-argument constructor, and one that
* accepts another Collection, as recommended by the Collection interface.
* Unfortunately, there is no way to enforce this in Java.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see List
* @see AbstractList
* @see AbstractCollection
* @see ListIterator
* @see LinkedList
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractSequentialList extends AbstractList
{
/**
* The main constructor, for use by subclasses.
*/
protected AbstractSequentialList()
{
}
/**
* Returns a ListIterator over the list, starting from position index.
* Subclasses must provide an implementation of this method.
*
* @param index the starting position of the list
* @return the list iterator
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
*/
public abstract ListIterator listIterator(int index);
/**
* Insert an element into the list at a given position (optional operation).
* This shifts all existing elements from that position to the end one
* index to the right. This version of add has no return, since it is
* assumed to always succeed if there is no exception. This iteration
* uses listIterator(index).add(o).
*
* @param index the location to insert the item
* @param o the object to insert
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
*/
public void add(int index, Object o)
{
listIterator(index).add(o);
}
/**
* Insert the contents of a collection into the list at a given position
* (optional operation). Shift all elements at that position to the right
* by the number of elements inserted. This operation is undefined if
* this list is modified during the operation (for example, if you try
* to insert a list into itself).
* <p>
*
* This implementation grabs listIterator(index), then proceeds to use add
* for each element returned by c's iterator. Sun's online specs are wrong,
* claiming that this also calls next(): listIterator.add() correctly
* skips the added element.
*
* @param index the location to insert the collection
* @param c the collection to insert
* @return true if the list was modified by this action, that is, if c is
* non-empty
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
* @see #add(int, Object)
*/
public boolean addAll(int index, Collection c)
{
Iterator ci = c.iterator();
int size = c.size();
ListIterator i = listIterator(index);
for (int pos = size; pos > 0; pos--)
i.add(ci.next());
return size > 0;
}
/**
* Get the element at a given index in this list. This implementation
* returns listIterator(index).next().
*
* @param index the index of the element to be returned
* @return the element at index index in this list
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
*/
public Object get(int index)
{
// This is a legal listIterator position, but an illegal get.
if (index == size())
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size());
return listIterator(index).next();
}
/**
* Obtain an Iterator over this list, whose sequence is the list order. This
* implementation returns listIterator().
*
* @return an Iterator over the elements of this list, in order
*/
public Iterator iterator()
{
return (Iterator) ((Object) listIterator());
}
/**
* Remove the element at a given position in this list (optional operation).
* Shifts all remaining elements to the left to fill the gap. This
* implementation uses listIterator(index) and ListIterator.remove().
*
* @param index the position within the list of the object to remove
* @return the object that was removed
* @throws UnsupportedOperationException if this list does not support the
* remove operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
*/
public Object remove(int index)
{
// This is a legal listIterator position, but an illegal remove.
if (index == size())
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size());
ListIterator i = listIterator(index);
Object removed = i.next();
i.remove();
return removed;
}
/**
* Replace an element of this list with another object (optional operation).
* This implementation uses listIterator(index) and ListIterator.set(o).
*
* @param index the position within this list of the element to be replaced
* @param o the object to replace it with
* @return the object that was replaced
* @throws UnsupportedOperationException if this list does not support the
* set operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
*/
public Object set(int index, Object o)
{
// This is a legal listIterator position, but an illegal set.
if (index == size())
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size());
ListIterator i = listIterator(index);
Object old = i.next();
i.set(o);
return old;
}
}

258
collects/profj/libs/java/util/Collection.java Normal file
View File

@ -0,0 +1,258 @@
/* Collection.java -- Interface that represents a collection of objects
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.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).
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
* @see List
* @see Set
* @see Map
* @see SortedSet
* @see SortedMap
* @see HashSet
* @see TreeSet
* @see ArrayList
* @see LinkedList
* @see Vector
* @see Collections
* @see Arrays
* @see AbstractCollection
* @since 1.2
* @status updated to 1.4
*/
public interface Collection
{
/**
* Add an element to this collection.
*
* @param o the object to add.
* @return true if the collection was modified as a result of this action.
* @throws UnsupportedOperationException if this collection does not
* support the add operation.
* @throws ClassCastException if o cannot be added to this collection due
* to its type.
* @throws 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.
* @return true if the collection was modified as a result of this action.
* @throws UnsupportedOperationException if this collection does not
* support the addAll operation.
* @throws ClassCastException if some element of c cannot be added to this
* collection due to its type.
* @throws 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.
*
* @throws 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.
* @return 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.
* @return 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.
* @return 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.
*
* @return a hash code for this collection.
*/
//int hashCode();
/**
* Test whether this collection is empty, that is, if size() == 0.
*
* @return true if this collection contains no elements.
*/
boolean isEmpty();
/**
* Obtain an Iterator over this collection.
*
* @return 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.
* @return true if the collection changed as a result of this call, that is,
* if the collection contained at least one occurrence of o.
* @throws 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).
*
* @return true if this collection was modified as a result of this call.
* @throws 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).
*
* @return true if this collection was modified as a result of this call.
* @throws UnsupportedOperationException if this collection does not
* support the retainAll operation.
*/
boolean retainAll(Collection c);
/**
* Get the number of elements in this collection.
*
* @return the number of elements in the collection.
*/
int size();
/**
* Copy the current contents of this collection into an array.
*
* @return 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.
* @return an array containing the elements currently in this collection, in
* any order.
* @throws ArrayStoreException if the type of any element of the
* collection is not a subtype of the element type of a.
*/
Object[] toArray(Object[] a);
}

92
collects/profj/libs/java/util/ConcurrentModificationException.java Normal file
View File

@ -0,0 +1,92 @@
/* ConcurrentModificationException.java -- Data structure concurrently modified
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
*/
/**
* 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. Notice that this can occur
* even in single-threaded designs, if you call methods out of order.
*
* @author Warren Levy <warrenl@cygnus.com>
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see Iterator
* @see ListIterator
* @see Vector
* @see LinkedList
* @see HashSet
* @see Hashtable
* @see TreeMap
* @see AbstractList
* @since 1.2
* @status updated to 1.4
*/
public class ConcurrentModificationException extends RuntimeException
{
/**
* Compatible with JDK 1.2.
*/
private static final long serialVersionUID = -3666751008965953603L;
/**
* Constructs a ConcurrentModificationException with no detail message.
*/
public ConcurrentModificationException()
{
}
/**
* Constructs a ConcurrentModificationException with a detail message.
*
* @param detail the detail message for the exception
*/
public ConcurrentModificationException(String detail)
{
super(detail);
}
}

87
collects/profj/libs/java/util/Iterator.java Normal file
View File

@ -0,0 +1,87 @@
/* Iterator.java -- Interface for iterating over collections
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.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.
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see ListIterator
* @see Enumeration
* @since 1.2
* @status updated to 1.4
*/
public interface Iterator
{
/**
* Tests whether there are elements remaining in the collection. In other
* words, calling <code>next()</code> will not throw an exception.
*
* @return true if there is at least one more element in the collection
*/
boolean hasNext();
/**
* Obtain the next element in the collection.
*
* @return the next element in the collection
* @throws NoSuchElementException if there are no more elements
*/
Object next();
/**
* Remove from the underlying collection the last element returned by next
* (optional operation). This method can be called only once after each
* call to <code>next()</code>. It does not affect what will be returned
* by subsequent calls to next.
*
* @throws IllegalStateException if next has not yet been called or remove
* has already been called since the last call to next.
* @throws UnsupportedOperationException if this Iterator does not support
* the remove operation.
*/
void remove();
}

415
collects/profj/libs/java/util/List.java Normal file
View File

@ -0,0 +1,415 @@
/* List.java -- An ordered collection which allows indexed access
Copyright (C) 1998, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* An ordered collection (also known as a list). This collection allows
* access to elements by position, as well as control on where elements
* are inserted. Unlike sets, duplicate elements are permitted by this
* general contract (if a subclass forbids duplicates, this should be
* documented).
* <p>
*
* List places additional requirements on <code>iterator</code>,
* <code>add</code>, <code>remove</code>, <code>equals</code>, and
* <code>hashCode</code>, in addition to requiring more methods. List
* indexing is 0-based (like arrays), although some implementations may
* require time proportional to the index to obtain an arbitrary element.
* The List interface is incompatible with Set; you cannot implement both
* simultaneously.
* <p>
*
* Lists also provide a <code>ListIterator</code> which allows bidirectional
* traversal and other features atop regular iterators. Lists can be
* searched for arbitrary elements, and allow easy insertion and removal
* of multiple elements in one method call.
* <p>
*
* Note: While lists may contain themselves as elements, this leads to
* undefined (usually infinite recursive) behavior for some methods like
* hashCode or equals.
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see Set
* @see ArrayList
* @see LinkedList
* @see Vector
* @see Arrays#asList(Object[])
* @see Collections#nCopies(int, Object)
* @see Collections#EMPTY_LIST
* @see AbstractList
* @see AbstractSequentialList
* @since 1.2
* @status updated to 1.4
*/
public interface List extends Collection
{
/**
* Insert an element into the list at a given position (optional operation).
* This shifts all existing elements from that position to the end one
* index to the right. This version of add has no return, since it is
* assumed to always succeed if there is no exception.
*
* @param index the location to insert the item
* @param o the object to insert
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws 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 (optional operation). If the list
* imposes restraints on what can be inserted, such as no null elements,
* this should be documented.
*
* @param o the object to add
* @return true, as defined by Collection for a modified list
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws 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
* (optional operation). Shift all elements at that position to the right
* by the number of elements inserted. This operation is undefined if
* this list is modified during the operation (for example, if you try
* to insert a list into itself).
*
* @param index the location to insert the collection
* @param c the collection to insert
* @return true if the list was modified by this action, that is, if c is
* non-empty
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
* @see #add(int, Object)
*/
boolean addAll(int index, Collection c);
/**
* Add the contents of a collection to the end of the list (optional
* operation). This operation is undefined if this list is modified
* during the operation (for example, if you try to insert a list into
* itself).
*
* @param c the collection to add
* @return true if the list was modified by this action, that is, if c is
* non-empty
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
* @see #add(Object)
*/
boolean addAll(Collection c);
/**
* Clear the list, such that a subsequent call to isEmpty() would return
* true (optional operation).
*
* @throws 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.
* This is defined as the existence of an element e such that
* <code>o == null ? e == null : o.equals(e)</code>.
*
* @param o the element to look for
* @return true if this list contains the element
*/
boolean contains(Object o);
/**
* Test whether this list contains every element in a given collection.
*
* @param c the collection to test for
* @return true if for every element o in c, contains(o) would return true
* @throws NullPointerException if the collection is null
* @see #contains(Object)
*/
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 have the same sequence. Two lists l1 and l2 are 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
* @return true if o is equal to this list
* @see Object#equals(Object)
* @see #hashCode()
*/
//boolean equals(Object o);
/**
* Get the element at a given index in this list.
*
* @param index the index of the element to be returned
* @return the element at index index in this list
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
*/
Object get(int index);
/**
* Obtains 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:
*
<p><pre>hashCode = 1;
Iterator i = list.iterator();
while (i.hasNext())
{
Object obj = i.next();
hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
}</pre>
*
* <p>This ensures that the general contract of Object.hashCode()
* is adhered to.
*
* @return the hash code of this list
* @see Object#hashCode()
* @see #equals(Object)
*/
//int hashCode();
/**
* Obtain the first index at which a given object is to be found in this
* list.
*
* @param o the object to search for
* @return 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.
*
* @return true if this list contains no elements
*/
boolean isEmpty();
/**
* Obtain an Iterator over this list, whose sequence is the list order.
*
* @return 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.
*
* @return the greatest integer n such that <code>o == null ? get(n) == null
* : o.equals(get(n))</code>, or -1 if there is no such index
*/
int lastIndexOf(Object o);
/**
* Obtain a ListIterator over this list, starting at the beginning.
*
* @return 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.
* A first call to next() would return the same as get(index), and a
* first call to previous() would return the same as get(index - 1).
*
* @param index the position, between 0 and size() inclusive, to begin the
* iteration from
* @return a ListIterator over the elements of this list, in order, starting
* at index
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt; size()
*/
ListIterator listIterator(int index);
/**
* Remove the element at a given position in this list (optional operation).
* Shifts all remaining elements to the left to fill the gap.
*
* @param index the position within the list of the object to remove
* @return the object that was removed
* @throws UnsupportedOperationException if this list does not support the
* remove operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
*/
Object remove(int index);
/**
* Remove the first occurence of an object from this list (optional
* operation). That is, remove the first element e such that
* <code>o == null ? e == null : o.equals(e)</code>.
*
* @param o the object to remove
* @return true if the list changed as a result of this call, that is, if
* the list contained at least one occurrence of o
* @throws UnsupportedOperationException if this list does not support the
* remove operation
*/
boolean remove(Object o);
/**
* Remove all elements of a given collection from this list (optional
* operation). That is, remove every element e such that c.contains(e).
*
* @param c the collection to filter out
* @return true if this list was modified as a result of this call
* @throws UnsupportedOperationException if this list does not support the
* removeAll operation
* @throws NullPointerException if the collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean removeAll(Collection c);
/**
* Remove all elements of this list that are not contained in a given
* collection (optional operation). That is, remove every element e such
* that !c.contains(e).
*
* @param c the collection to retain
* @return true if this list was modified as a result of this call
* @throws UnsupportedOperationException if this list does not support the
* retainAll operation
* @throws NullPointerException if the collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean retainAll(Collection c);
/**
* Replace an element of this list with another object (optional operation).
*
* @param index the position within this list of the element to be replaced
* @param o the object to replace it with
* @return the object that was replaced
* @throws UnsupportedOperationException if this list does not support the
* set operation
* @throws IndexOutOfBoundsException if index &lt; 0 || index &gt;= size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws 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. If the list contains more
* than Integer.MAX_VALUE elements, return Integer.MAX_VALUE.
*
* @return 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). If the two indices are equal, the
* sublist is empty. 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)
* @return a List backed by a subsection of this list
* @throws IndexOutOfBoundsException if fromIndex &lt; 0
* || toIndex &gt; size() || fromIndex &gt; toIndex
* @throws IllegalArgumentException if fromIndex &gt; toIndex (according to
* AbstractList). Don't you love Sun's inconsistent specifications?
*/
List subList(int fromIndex, int toIndex);
/**
* Copy the current contents of this list into an array.
*
* @return 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
* @return an array containing the elements currently in this list, in
* order
* @throws ArrayStoreException if the type of any element of the
* collection is not a subtype of the element type of a
* @throws NullPointerException if the specified array is null
*/
Object[] toArray(Object[] a);
}

170
collects/profj/libs/java/util/ListIterator.java Normal file
View File

@ -0,0 +1,170 @@
/* ListIterator.java -- Extended Iterator for iterating over ordered lists
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.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.
* <p>
*
* A list with n elements provides n+1 iterator positions (the front, the end,
* or between two elements). Note that <code>remove</code> and <code>set</code>
* operate on the last element returned, whether it was by <code>next</code>
* or <code>previous</code>.
*
* @author Original author unknown
* @author Eric Blake <ebb9@email.byu.edu>
* @see Collection
* @see List
* @see Iterator
* @see Enumeration
* @since 1.2
* @status updated to 1.4
*/
public interface ListIterator extends Iterator
{
/**
* Tests whether there are elements remaining in the list in the forward
* direction. In other words, next() will not fail with a
* NoSuchElementException.
*
* @return true if the list continues in the forward direction
*/
boolean hasNext();
/**
* Tests whether there are elements remaining in the list in the reverse
* direction. In other words, previous() will not fail with a
* NoSuchElementException.
*
* @return true if the list continues in the reverse direction
*/
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
* @throws 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
* @throws NoSuchElementException if there are no more elements
*/
Object previous();
/**
* Find the index of the element that would be returned by a call to next.
* If hasNext() returns false, this returns the list size.
*
* @return the index of the element that would be returned by next()
*/
int nextIndex();
/**
* Find the index of the element that would be returned by a call to
* previous. If hasPrevious() returns false, this returns -1.
*
* @return the index of the element that would be returned by previous()
*/
int previousIndex();
/**
* Insert an element into the list at the current position of the iterator
* (optional operation). 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. The values returned
* by nextIndex() and previousIndex() are incremented.
*
* @param o the object to insert into the list
* @throws ClassCastException the object is of a type which cannot be added
* to this list
* @throws IllegalArgumentException some other aspect of the object stops
* it being added to this list
* @throws 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 (optional operation). This method may only be called if neither
* add nor remove have been called since the last call to next or previous.
*
* @throws 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
* @throws 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 (optional operation). This method may only be called if
* neither add nor remove have been called since the last call to next or
* previous.
*
* @param o the object to replace the element with
* @throws ClassCastException the object is of a type which cannot be added
* to this list
* @throws IllegalArgumentException some other aspect of the object stops
* it being added to this list
* @throws 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
* @throws UnsupportedOperationException if this ListIterator does not
* support the set operation
*/
void set(Object o);
}

88
collects/profj/libs/java/util/NoSuchElementException.java Normal file
View File

@ -0,0 +1,88 @@
/* NoSuchElementException.java -- Attempt to access element that does not exist
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
*/
/**
* Exception thrown when an attempt is made to access an element that does not
* exist. This exception is thrown by the Enumeration, Iterator and
* ListIterator classes if the nextElement, next or previous method goes
* beyond the end of the list of elements that are being accessed. It is also
* thrown by Vector and Stack when attempting to access the first or last
* element of an empty collection.
*
* @author Warren Levy <warrenl@cygnus.com>
* @author Eric Blake <ebb9@email.byu.edu>
* @see Enumeration
* @see Iterator
* @see ListIterator
* @see Enumeration#nextElement()
* @see Iterator#next()
* @see ListIterator#previous()
* @since 1.0
* @status updated to 1.4
*/
public class NoSuchElementException extends RuntimeException
{
/**
* Compatible with JDK 1.0.
*/
private static final long serialVersionUID = 6769829250639411880L;
/**
* Constructs a NoSuchElementException with no detail message.
*/
public NoSuchElementException()
{
}
/**
* Constructs a NoSuchElementException with a detail message.
*
* @param detail the detail message for the exception
*/
public NoSuchElementException(String detail)
{
super(detail);
}
}

64
collects/profj/libs/java/util/RandomAccess.java Normal file
View File

@ -0,0 +1,64 @@
/* RandomAccess.java -- A tagging interface that lists can use to tailor
operations to the correct algorithm
Copyright (C) 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* Marker interface used to inform <code>List</code> implementations that
* they support fast (usually constant time) random access. This allows
* generic list algorithms to tailor their behavior based on the list
* type.
* <p>
*
* For example, some sorts are n*log(n) on an array, but decay to quadratic
* time on a linked list. As a rule of thumb, this interface should be
* used is this loop:<br>
* <code>for (int i = 0, n = list.size(); i &lt; n; i++) list.get(i);</code>
* <br>runs faster than this loop:<br>
* <code>for (Iterator i = list.iterator(); i.hasNext(); ) i.next();</code>
*
* @author Eric Blake <ebb9@email.byu.edu>
* @see List
* @since 1.4
* @status updated to 1.4
*/
public interface RandomAccess
{
// Tagging interface only.
}

13
collects/profj/libs/java/util/installer.ss
View File

@ -15,4 +15,15 @@
(build-path java.util file)
#f
#f)))])
(javac "Random.java")))))
(javac "Random.java")
(javac "RandomAccess.java")
(javac "Iterator.java")
(javac "ListIterator.java")
(javac "Collection.java")
(javac "List.java")
(javac "AbstractCollection.java")
(javac "ConcurrentModificationException.java")
(javac "NoSuchElementException.java")
(javac "AbstractList.java")
(javac "AbstractSequentialList.java")
))))