Author: j16sdiz
Date: 2008-08-18 13:50:32 +0000 (Mon, 18 Aug 2008)
New Revision: 22007
Modified:
trunk/freenet/src/freenet/support/DoublyLinkedList.java
trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java
trunk/freenet/src/freenet/support/LRUHashtable.java
Log:
Revert r21989 "fix generic"
Modified: trunk/freenet/src/freenet/support/DoublyLinkedList.java
===================================================================
--- trunk/freenet/src/freenet/support/DoublyLinkedList.java 2008-08-18
13:45:25 UTC (rev 22006)
+++ trunk/freenet/src/freenet/support/DoublyLinkedList.java 2008-08-18
13:50:32 UTC (rev 22007)
@@ -6,31 +6,31 @@
* Framework for managing a doubly linked list.
* @author tavin
*/
-public interface DoublyLinkedList<T extends DoublyLinkedList.Item<T>> {
+public interface DoublyLinkedList<T> {
public abstract DoublyLinkedList<T> clone();
/**
* List element
*/
- public interface Item<T extends Item<T>> {
+ public interface Item<T> {
/**
* Get next {@link Item}. May or may not return
* <code>null</code> if this is the last <code>Item</code>.
*
* @see DoublyLinkedList#hasNext()
*/
- T getNext();
+ DoublyLinkedList.Item<T> getNext();
/** Set next {@link Item} */
- T setNext(T i);
+ DoublyLinkedList.Item<T> setNext(DoublyLinkedList.Item<T> i);
/**
* Get previous {@link Item}. May or may not return <code>null</code>
* if this is the first <code>Item</code>.
*
* @see DoublyLinkedList#hasNext()
*/
- T getPrev();
+ Item<T> getPrev();
/** Get previous {@link Item} */
- T setPrev(T i);
+ Item<T> setPrev(DoublyLinkedList.Item<T> i);
/** Return the contained list. <strong>For sanity checking
only.</strong> */
DoublyLinkedList<T> getParent();
@@ -45,23 +45,23 @@
/** Check if this list is empty. @return <code>true</code> if this list is
empty, <code>false</code> otherwise. */
boolean isEmpty();
/** Get a {@link Enumeration} of {@link DoublyLinkedList.Item}. */
- Enumeration<T> elements(); // for consistency w/ typical Java API
+ Enumeration elements(); // for consistency w/ typical Java API
/**
* Returns the first item.
* @return the item at the head of the list, or <code>null</code> if empty
*/
- T head();
+ Item head();
/**
* Returns the last item.
* @return the item at the tail of the list, or <code>null</code> if empty
*/
- T tail();
+ Item tail();
/**
* Puts the item before the first item.
*/
- void unshift(T i);
+ void unshift(DoublyLinkedList.Item<T> i);
/**
* Put all items in the specified list before the first item.
*/
@@ -69,7 +69,7 @@
/**
* Removes and returns the first item.
*/
- T shift();
+ Item shift();
/**
* Remove <tt>n</tt> elements from head and return them as a
<code>DoublyLinkedList</code>.
*/
@@ -78,7 +78,7 @@
/**
* Puts the item after the last item.
*/
- void push(T i);
+ void push(DoublyLinkedList.Item<T> i);
/**
* Puts all items in the specified list after the last item.
*/
@@ -86,41 +86,41 @@
/**
* Removes and returns the last item.
*/
- T pop();
+ Item pop();
/**
* Remove <tt>n</tt> elements from tail and return them as a
<code>DoublyLinkedList</code>.
*/
DoublyLinkedList pop(int n);
- /** @return <code>true</code> if <code>i</code> has next item. (ie. not
the last item); <code>false</code> otherwise */
- boolean hasNext(T i);
+ /** @return <code>true</code> if <code>i</code> has next item. (ie. not
the last item); <code>false</code> otherwise */
+ boolean hasNext(DoublyLinkedList.Item<T> i);
/** @return <code>true</code> if <code>i</code> has previous item. (ie.
not the first item); <code>false</code> otherwise */
- boolean hasPrev(T i);
+ boolean hasPrev(DoublyLinkedList.Item<T> i);
/** @return next item of <code>i</code>. If this is the last element,
return <code>null</code> */
- T next(T i);
+ Item next(DoublyLinkedList.Item<T> i);
/** @return previous item of <code>i</code>. If this is the first element,
return <code>null</code> */
- T prev(T i);
- /** Remove and return a element
+ Item prev(DoublyLinkedList.Item<T> i);
+ /** Remove and return a element
* @return this item, or <code>null</code> if the item was not in the list
*/
- T remove(T i);
+ Item remove(DoublyLinkedList.Item<T> i);
/**
* Inserts item <code>j</code> before item <code>i</code>.
*/
- void insertPrev(T i, T j);
+ void insertPrev(DoublyLinkedList.Item<T> i, DoublyLinkedList.Item<T> j);
/**
* Inserts the entire {@link DoublyLinkedList} <code>l</code> before item
<code>i</code>.
*/
- void insertPrev(T i, DoublyLinkedList<T> l);
+ void insertPrev(DoublyLinkedList.Item<T> i, DoublyLinkedList<T> l);
/**
* Inserts item <code>j</code> after item <code>i</code.
*/
- void insertNext(T i, T j);
+ void insertNext(DoublyLinkedList.Item<T> i, DoublyLinkedList.Item<T> j);
/**
* Inserts the entire {@link DoublyLinkedList} <code>l</code> after item
<code>i</code>.
*/
- void insertNext(T i, DoublyLinkedList<T> l);
+ void insertNext(DoublyLinkedList.Item<T> i, DoublyLinkedList<T> l);
}
Modified: trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java
===================================================================
--- trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java 2008-08-18
13:45:25 UTC (rev 22006)
+++ trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java 2008-08-18
13:50:32 UTC (rev 22007)
@@ -10,10 +10,10 @@
* TODO: there are still some unimplemented methods
* -- it remains to be seen if they are needed at all
*/
-public class DoublyLinkedListImpl<T extends DoublyLinkedListImpl.Item<T>>
implements DoublyLinkedList<T> {
+public class DoublyLinkedListImpl<T> implements DoublyLinkedList<T>{
protected int size;
- protected T _headptr, _tailptr;
+ protected DoublyLinkedListImpl.Item<T> _headptr, _tailptr;
@Override
public final DoublyLinkedListImpl<T> clone() {
@@ -24,14 +24,14 @@
* A new list with no items.
*/
public DoublyLinkedListImpl() {
- _headptr = (T) new Item();
- _tailptr = (T) new Item();
+ _headptr = new Item<T>();
+ _tailptr = new Item<T>();
_headptr.setParent(this);
_tailptr.setParent(this);
clear();
}
- protected DoublyLinkedListImpl(T _h, T _t, int size) {
+ protected DoublyLinkedListImpl(DoublyLinkedListImpl.Item<T> _h,
DoublyLinkedListImpl.Item<T> _t, int size) {
_headptr = _h;
_tailptr = _t;
_headptr.setParent(this);
@@ -43,13 +43,13 @@
/**
* @param impl
*/
- protected DoublyLinkedListImpl(DoublyLinkedListImpl<T> impl) {
+ protected DoublyLinkedListImpl(DoublyLinkedListImpl impl) {
this();
- Enumeration<T> e = impl.forwardElements();
+ Enumeration<DoublyLinkedListImpl.Item<T>> e = impl.forwardElements();
boolean checked = false;
for(;e.hasMoreElements();) {
- T oi = e.nextElement();
- T i = oi.clone();
+ DoublyLinkedListImpl.Item<T> oi = e.nextElement();
+ DoublyLinkedList.Item<T> i = oi.clone();
if(!checked) {
checked = true;
if(!i.getClass().getName().equals(oi.getClass().getName())) {
@@ -70,8 +70,8 @@
// Help to detect removal after clear().
// The check in remove() is enough, strictly,
// as long as people don't add elements afterwards.
- DoublyLinkedList.Item pos = _headptr.next;
- DoublyLinkedList.Item opos = _headptr;
+ DoublyLinkedList.Item<T> pos = _headptr.next;
+ DoublyLinkedList.Item<T> opos = _headptr;
while(true) {
if(pos == _tailptr) break;
if(pos == null) break;
@@ -104,22 +104,22 @@
* {@inheritDoc}
* @see #forwardElements()
*/
- public final Enumeration elements() {
+ public final Enumeration<T> elements() {
return forwardElements();
}
/**
* {@inheritDoc}
*/
- public final T head() {
- return size == 0 ? null : (T) _headptr.next;
+ public final DoublyLinkedList.Item<T> head() {
+ return size == 0 ? null : _headptr.next;
}
/**
* {@inheritDoc}
*/
- public final T tail() {
- return size == 0 ? null : (T) _tailptr.prev;
+ public final DoublyLinkedList.Item<T> tail() {
+ return size == 0 ? null : _tailptr.prev;
}
@@ -127,8 +127,8 @@
/**
* {@inheritDoc}
*/
- public final void unshift(T i) {
- insertNext((T) _headptr, i);
+ public final void unshift(DoublyLinkedList.Item<T> i) {
+ insertNext(_headptr, i);
}
/**
@@ -141,8 +141,8 @@
/**
* {@inheritDoc}
*/
- public final T shift() {
- return size == 0 ? null : (T) remove((T) _headptr.next);
+ public final DoublyLinkedList.Item<T> shift() {
+ return size == 0 ? null : remove(_headptr.next);
}
/**
* {@inheritDoc}
@@ -152,13 +152,13 @@
if (n > size) n = size;
if (n < 1) return new DoublyLinkedListImpl<T>();
- T i = _headptr;
+ DoublyLinkedList.Item<T> i = _headptr;
for (int m=0; m<n; ++m)
i = i.getNext();
- T j = i.getNext();
- T newheadptr = (T) new Item<T>();
- T newtailptr = (T) new Item<T>();
+ DoublyLinkedList.Item<T> j = i.getNext();
+ Item<T> newheadptr = new Item<T>();
+ Item<T> newtailptr = new Item<T>();
j.setPrev(newheadptr);
newheadptr.setNext(j);
@@ -179,8 +179,8 @@
/**
* {@inheritDoc}
*/
- public final void push(T i) {
- insertPrev((T) _tailptr, i);
+ public final void push(DoublyLinkedList.Item<T> i) {
+ insertPrev(_tailptr, i);
}
/**
* {@inheritDoc}
@@ -192,8 +192,8 @@
/**
* {@inheritDoc}
*/
- public final T pop() {
- return size == 0 ? null : (T) remove((T) _tailptr.prev);
+ public final DoublyLinkedList.Item<T> pop() {
+ return size == 0 ? null : remove(_tailptr.prev);
}
/**
* {@inheritDoc}
@@ -203,13 +203,13 @@
if (n > size) n = size;
if (n < 1) return new DoublyLinkedListImpl<T>();
- T i = _tailptr;
+ DoublyLinkedList.Item<T> i = _tailptr;
for (int m=0; m<n; ++m)
i = i.getPrev();
- T j = i.getPrev();
- T newtailptr = (T) new Item<T>();
- T newheadptr = (T) new Item<T>();
+ DoublyLinkedList.Item<T> j = i.getPrev();
+ DoublyLinkedListImpl.Item<T> newtailptr = new Item<T>();
+ DoublyLinkedListImpl.Item<T> newheadptr = new Item<T>();
j.setNext(newtailptr);
newtailptr.setPrev(j);
@@ -230,29 +230,29 @@
/**
* {@inheritDoc}
*/
- public final boolean hasNext(T i) {
- DoublyLinkedList.Item next = i.getNext();
+ public final boolean hasNext(DoublyLinkedList.Item<T> i) {
+ DoublyLinkedList.Item<T> next = i.getNext();
return (next != null) && (next != _tailptr);
}
/**
* {@inheritDoc}
*/
- public final boolean hasPrev(T i) {
- DoublyLinkedList.Item prev = i.getPrev();
+ public final boolean hasPrev(DoublyLinkedList.Item<T> i) {
+ DoublyLinkedList.Item<T> prev = i.getPrev();
return (prev != null) && (prev != _headptr);
}
/**
* {@inheritDoc}
*/
- public final T next(T i) {
- T next = i.getNext();
- return next == _tailptr ? null : (T) next;
+ public final DoublyLinkedList.Item<T> next(DoublyLinkedList.Item<T> i) {
+ DoublyLinkedList.Item<T> next = i.getNext();
+ return next == _tailptr ? null : next;
}
/**
* {@inheritDoc}
*/
- public final T prev(T i) {
- T prev = i.getPrev();
+ public final DoublyLinkedList.Item<T> prev(DoublyLinkedList.Item<T> i) {
+ DoublyLinkedList.Item<T> prev = i.getPrev();
return prev == _headptr ? null : prev;
}
@@ -262,7 +262,7 @@
/**
* {@inheritDoc}
*/
- public T remove(T i) {
+ public DoublyLinkedList.Item<T> remove(DoublyLinkedList.Item<T> i) {
if (i.getParent() == null) return null; // not in list
if(isEmpty()) {
Logger.error(this, "Illegal ERROR: Removing from an empty
list!!");
@@ -270,7 +270,7 @@
}
if (i.getParent() != this)
throw new PromiscuousItemException(i, i.getParent());
- T next = i.getNext(), prev = i.getPrev();
+ DoublyLinkedList.Item<T> next = i.getNext(), prev = i.getPrev();
if ((next == null) && (prev == null)) return null; // not in the list
if ((next == null) || (prev == null))
throw new NullPointerException("next="+next+", prev="+prev); //
partially in the list?!
@@ -291,7 +291,7 @@
/**
* {@inheritDoc}
*/
- public void insertPrev(T i, T j) {
+ public void insertPrev(DoublyLinkedList.Item<T> i,
DoublyLinkedList.Item<T> j) {
if (i.getParent() == null)
throw new PromiscuousItemException(i, i.getParent()); //
different trace to make easier debugging
if (i.getParent() != this)
@@ -300,7 +300,7 @@
throw new PromiscuousItemException(j, j.getParent());
if ((j.getNext() != null) || (j.getPrev() != null))
throw new PromiscuousItemException(j);
- T prev = i.getPrev();
+ DoublyLinkedList.Item<T> prev = i.getPrev();
if (prev == null)
throw new VirginItemException(i);
prev.setNext(j);
@@ -315,21 +315,21 @@
* {@inheritDoc}
* FIXME: unimplemented
*/
- public void insertPrev(T i, DoublyLinkedList<T> l) {
+ public void insertPrev(DoublyLinkedList.Item<T> i, DoublyLinkedList<T> l) {
throw new RuntimeException("function currently unimplemented because i
am a lazy sod");
}
/**
* {@inheritDoc}
*/
- public void insertNext(T i, T j) {
+ public void insertNext(DoublyLinkedList.Item<T> i,
DoublyLinkedList.Item<T> j) {
if (i.getParent() != this)
throw new PromiscuousItemException(i, i.getParent());
if (j.getParent() != null)
throw new PromiscuousItemException(j, i.getParent());
if ((j.getNext() != null) || (j.getPrev() != null))
throw new PromiscuousItemException(j);
- T next = i.getNext();
+ DoublyLinkedList.Item next = i.getNext();
if (next == null)
throw new VirginItemException(i);
next.setPrev(j);
@@ -344,7 +344,7 @@
* {@inheritDoc}
* FIXME: unimplemented
*/
- public void insertNext(T i, DoublyLinkedList<T> l) {
+ public void insertNext(DoublyLinkedList.Item<T> i, DoublyLinkedList<T> l) {
throw new RuntimeException("function currently unimplemented because i
am a lazy sod");
}
@@ -362,46 +362,46 @@
* @return an Enumeration of list elements from tail to head
*/
protected Enumeration<T> reverseElements() {
- return new ReverseWalker();
+ return new ReverseWalker();
}
- private class ForwardWalker implements Enumeration<T> {
- protected DoublyLinkedList.Item next;
+ private class ForwardWalker<T extends DoublyLinkedListImpl.Item<T>>
implements Enumeration<DoublyLinkedList.Item<T>> {
+ protected DoublyLinkedList.Item<T> next;
protected ForwardWalker() {
next = _headptr.getNext();
}
- protected ForwardWalker(DoublyLinkedList.Item startAt,
+ protected ForwardWalker(DoublyLinkedList.Item<T> startAt,
boolean inclusive) {
next = (inclusive ? startAt : startAt.getNext());
}
public final boolean hasMoreElements() {
return next != _tailptr;
}
- public T nextElement() {
+ public DoublyLinkedList.Item<T> nextElement() {
if (next == _tailptr)
throw new NoSuchElementException();
- T result = (T) next;
+ DoublyLinkedList.Item<T> result = next;
next = next.getNext();
return result;
}
}
- private class ReverseWalker implements Enumeration<T> {
- protected DoublyLinkedList.Item next;
+ private class ReverseWalker<T extends DoublyLinkedList.Item<T>> implements
Enumeration<DoublyLinkedList.Item<T>> {
+ protected DoublyLinkedList.Item<T> next;
protected ReverseWalker() {
next = _tailptr.getPrev();
}
- protected ReverseWalker(DoublyLinkedList.Item startAt,
+ protected ReverseWalker(DoublyLinkedList.Item<T> startAt,
boolean inclusive) {
next = (inclusive ? startAt : startAt.getPrev());
}
public final boolean hasMoreElements() {
return next != _headptr;
}
- public T nextElement() {
+ public DoublyLinkedList.Item<T> nextElement() {
if (next == _headptr)
throw new NoSuchElementException();
- T result = (T) next;
+ DoublyLinkedList.Item<T> result = next;
if(next == null) throw new IllegalStateException("next==null");
next = next.getPrev();
return result;
@@ -411,36 +411,36 @@
//=== list element ====================================================
- public static class Item<T extends Item<T>> implements
DoublyLinkedList.Item<T> {
- private T prev;
- private T next;
+ public static class Item<T> implements DoublyLinkedList.Item<T> {
+ private DoublyLinkedList.Item<T> prev;
+ private DoublyLinkedList.Item<T> next;
private DoublyLinkedList list;
@Override
- public T clone() {
+ public DoublyLinkedList.Item<T> clone() {
if(getClass() != Item.class)
throw new RuntimeException("Must implement clone() for
"+getClass());
- return (T) new Item();
+ return new Item<T>();
}
- public final T getNext() {
+ public final DoublyLinkedList.Item getNext() {
return next;
}
- public final T setNext(T i) {
- T old = next;
+ public final DoublyLinkedList.Item setNext(DoublyLinkedList.Item<T> i)
{
+ DoublyLinkedList.Item<T> old = next;
next = i;
return old;
}
- public final T getPrev() {
+ public final DoublyLinkedList.Item getPrev() {
return prev;
}
- public final T setPrev(T i) {
- T old = prev;
+ public final DoublyLinkedList.Item setPrev(DoublyLinkedList.Item<T> i)
{
+ DoublyLinkedList.Item<T> old = prev;
prev = i;
return old;
}
- public DoublyLinkedList<T> getParent() {
+ public DoublyLinkedList getParent() {
return list;
}
- public DoublyLinkedList<T> setParent(DoublyLinkedList<T> l) {
+ public DoublyLinkedList setParent(DoublyLinkedList<T> l) {
DoublyLinkedList old = list;
list = l;
return old;
Modified: trunk/freenet/src/freenet/support/LRUHashtable.java
===================================================================
--- trunk/freenet/src/freenet/support/LRUHashtable.java 2008-08-18 13:45:25 UTC
(rev 22006)
+++ trunk/freenet/src/freenet/support/LRUHashtable.java 2008-08-18 13:50:32 UTC
(rev 22007)
@@ -12,7 +12,7 @@
* push is by far the most done operation, this should be an
* overall improvement.
*/
- private final DoublyLinkedListImpl<QItem<K, V>> list = new
DoublyLinkedListImpl<QItem<K, V>>();
+ private final DoublyLinkedListImpl<V> list = new DoublyLinkedListImpl<V>();
private final Hashtable<K, QItem<K, V>> hash = new Hashtable<K, QItem<K,
V>>();
/**
@@ -34,12 +34,12 @@
Logger.minor(this, "Pushed "+insert+" ( "+key+ ' ' +value+" )");
list.unshift(insert);
- }
+ }
/**
* @return Least recently pushed key.
*/
- public final synchronized K popKey() {
+ public final synchronized Object popKey() {
if ( list.size() > 0 ) {
return ( hash.remove(((QItem) list.pop()).obj)).obj;
} else {
@@ -50,7 +50,7 @@
/**
* @return Least recently pushed value.
*/
- public final synchronized V popValue() {
+ public final synchronized Object popValue() {
if ( list.size() > 0 ) {
return ( hash.remove(((QItem) list.pop()).obj)).value;
} else {
@@ -58,7 +58,7 @@
}
}
- public final synchronized V peekValue() {
+ public final synchronized Object peekValue() {
if ( list.size() > 0 ) {
return ( hash.get(((QItem) list.tail()).obj)).value;
} else {
@@ -99,39 +99,39 @@
return q.value;
}
- public Enumeration<K> keys() {
+ public Enumeration keys() {
return new ItemEnumeration();
}
- public Enumeration<V> values() {
+ public Enumeration values() {
return new ValuesEnumeration();
}
- private class ItemEnumeration implements Enumeration<K> {
- private Enumeration<QItem<K, V>> source =
list.reverseElements();
+ private class ItemEnumeration implements Enumeration {
+ private Enumeration source = list.reverseElements();
public boolean hasMoreElements() {
return source.hasMoreElements();
}
- public K nextElement() {
- return source.nextElement().obj;
+ public Object nextElement() {
+ return ((QItem) source.nextElement()).obj;
}
}
- private class ValuesEnumeration implements Enumeration<V> {
- private Enumeration<QItem<K, V>> source =
list.reverseElements();
+ private class ValuesEnumeration implements Enumeration {
+ private Enumeration source = list.reverseElements();
public boolean hasMoreElements() {
return source.hasMoreElements();
}
- public V nextElement() {
- return (source.nextElement()).value;
+ public Object nextElement() {
+ return ((QItem) source.nextElement()).value;
}
}
- protected static class QItem<K, V> extends
DoublyLinkedListImpl.Item<QItem<K, V>> {
+ public static class QItem<K, V> extends DoublyLinkedListImpl.Item<V> {
public K obj;
public V value;
@@ -151,7 +151,7 @@
}
/**
- * Note that unlike the java.util versions, this will not reallocate
(hence it doesn't return),
+ * Note that unlike the java.util versions, this will not reallocate
(hence it doesn't return),
* so pass in an appropriately big array, and make sure you hold the
lock!
* @param entries
* @return
