Author: j16sdiz
Date: 2009-02-22 11:20:57 +0000 (Sun, 22 Feb 2009)
New Revision: 25759
Modified:
trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java
Log:
Fix Build: New Generic for DoublyLinkedListImpl (bug 2512)
Modified: trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java
===================================================================
--- trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java 2009-02-22
11:20:23 UTC (rev 25758)
+++ trunk/freenet/src/freenet/support/DoublyLinkedListImpl.java 2009-02-22
11:20:57 UTC (rev 25759)
@@ -11,15 +11,15 @@
* TODO: there are still some unimplemented methods
* -- it remains to be seen if they are needed at all
*/
-public class DoublyLinkedListImpl<T> implements DoublyLinkedList<T>{
+public class DoublyLinkedListImpl<T extends DoublyLinkedList.Item<? extends
T>> implements DoublyLinkedList<T> {
protected int size;
- protected DoublyLinkedList.Item<T> _firstItem, _lastItem;
+ protected T _firstItem, _lastItem;
- @Override
- public final DoublyLinkedListImpl<T> clone() {
- return new DoublyLinkedListImpl<T>(this);
- }
+ //@Override
+ //public final DoublyLinkedListImpl<T> clone() {
+ // return new DoublyLinkedListImpl<T>(this);
+ //}
/**
* A new list with no items.
@@ -28,41 +28,43 @@
clear();
}
- protected DoublyLinkedListImpl(DoublyLinkedList.Item<T> _h,
DoublyLinkedList.Item<T> _t, int size) {
+ protected DoublyLinkedListImpl(T _h, T _t, int size) {
_firstItem = _h;
_lastItem = _t;
- DoublyLinkedList.Item i = _firstItem;
+ T i = _firstItem;
while (i != null ) {
i.setParent(this);
- i = i.getNext();
+ i = i.getNext();
}
this.size = size;
}
+ // /**
+ // *
+ // * XXX: FIXME this doesn't really work. it use .clone() method
+ // *
+ // * @param impl
+ // */
+ // protected DoublyLinkedListImpl(DoublyLinkedListImpl<T> impl) {
+ // this();
+ // Enumeration<T> e = impl.forwardElements();
+ // boolean checked = false;
+ // for(;e.hasMoreElements();) {
+ // DoublyLinkedListImpl.Item oi =
(DoublyLinkedListImpl.Item) e.nextElement();
+ // T i = (T) oi.clone();
+ // if(!checked) {
+ // checked = true;
+ //
if(!i.getClass().getName().equals(oi.getClass().getName())) {
+ // System.err.println("Clone constructor failed for
"+oi+": "+i);
+ // new Exception("error").printStackTrace();
+ // }
+ // }
+ // this.push(i);
+ // }
+ // }
- /**
- * @param impl
- */
- protected DoublyLinkedListImpl(DoublyLinkedListImpl impl) {
- this();
- Enumeration<DoublyLinkedListImpl.Item<T>> e = impl.forwardElements();
- boolean checked = false;
- for(;e.hasMoreElements();) {
- DoublyLinkedListImpl.Item<T> oi = e.nextElement();
- DoublyLinkedList.Item<T> i = oi.clone();
- if(!checked) {
- checked = true;
- if(!i.getClass().getName().equals(oi.getClass().getName())) {
- System.err.println("Clone constructor failed for "+oi+":
"+i);
- new Exception("error").printStackTrace();
- }
- }
- this.push(i);
- }
- }
-
//=== DoublyLinkedList implementation
======================================
/**
@@ -75,15 +77,15 @@
if (_firstItem == null)
return;
- DoublyLinkedList.Item<T> pos = _firstItem;
- DoublyLinkedList.Item<T> opos;
+ T pos = _firstItem;
+ T opos;
while(true) {
if(pos == null) break;
pos.setParent(null);
pos.setPrev(null);
opos = pos;
- pos = pos.getNext();
+ pos = pos.getNext();
opos.setNext(null);
}
@@ -115,7 +117,7 @@
return forwardElements();
}
- public boolean contains(DoublyLinkedList.Item<T> item) {
+ public boolean contains(T item) {
for(T i : this) {
if(i == item)
return true;
@@ -126,14 +128,14 @@
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> head() {
+ public final T head() {
return size == 0 ? null : _firstItem;
}
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> tail() {
+ public final T tail() {
return size == 0 ? null : _lastItem;
}
@@ -142,14 +144,14 @@
/**
* {...@inheritdoc}
*/
- public final void unshift(DoublyLinkedList.Item<T> i) {
+ public final void unshift(T i) {
insertNext(null, i);
}
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> shift() {
+ public final T shift() {
return size == 0 ? null : remove(_firstItem);
}
/**
@@ -159,12 +161,12 @@
if (n > size) n = size;
if (n < 1) return new DoublyLinkedListImpl<T>();
- DoublyLinkedList.Item<T> i = _firstItem;
+ T i = _firstItem;
for (int m = 0; m < n - 1; ++m)
- i = i.getNext();
+ i = i.getNext();
- DoublyLinkedList.Item<T> newTailItem = i;
- DoublyLinkedList.Item<T> newFirstItem = newTailItem.getNext();
+ T newTailItem = i;
+ T newFirstItem = newTailItem.getNext();
newTailItem.setNext(null);
DoublyLinkedList<T> newlist = new
DoublyLinkedListImpl<T>(_firstItem, newTailItem, n);
@@ -185,14 +187,14 @@
/**
* {...@inheritdoc}
*/
- public final void push(DoublyLinkedList.Item<T> i) {
+ public final void push(T i) {
insertPrev(null, i);
}
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> pop() {
+ public final T pop() {
return size == 0 ? null : remove(_lastItem);
}
@@ -203,12 +205,12 @@
if (n > size) n = size;
if (n < 1) return new DoublyLinkedListImpl<T>();
- DoublyLinkedList.Item<T> i = _lastItem;
+ T i = _lastItem;
for (int m = 0; m < n - 1; ++m)
- i = i.getPrev();
+ i = i.getPrev();
- DoublyLinkedList.Item<T> newFirstItem = i;
- DoublyLinkedList.Item<T> newLastItem = newFirstItem.getPrev();
+ T newFirstItem = i;
+ T newLastItem = newFirstItem.getPrev();
newFirstItem.setPrev(null);
DoublyLinkedList<T> newlist = new
DoublyLinkedListImpl<T>(newFirstItem, _lastItem, n);
@@ -228,29 +230,29 @@
/**
* {...@inheritdoc}
*/
- public final boolean hasNext(DoublyLinkedList.Item<T> i) {
- DoublyLinkedList.Item<T> next = i.getNext();
+ public final boolean hasNext(T i) {
+ T next = i.getNext();
return next != null;
}
/**
* {...@inheritdoc}
*/
- public final boolean hasPrev(DoublyLinkedList.Item<T> i) {
- DoublyLinkedList.Item<T> prev = i.getPrev();
+ public final boolean hasPrev(T i) {
+ T prev = i.getPrev();
return prev != null;
}
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> next(DoublyLinkedList.Item<T> i) {
- DoublyLinkedList.Item<T> next = i.getNext();
+ public final T next(T i) {
+ T next = i.getNext();
return next;
}
/**
* {...@inheritdoc}
*/
- public final DoublyLinkedList.Item<T> prev(DoublyLinkedList.Item<T> i) {
- DoublyLinkedList.Item<T> prev = i.getPrev();
+ public final T prev(T i) {
+ T prev = i.getPrev();
return prev;
}
@@ -260,14 +262,14 @@
/**
* {...@inheritdoc}
*/
- public DoublyLinkedList.Item<T> remove(DoublyLinkedList.Item<T> i) {
+ public T remove(T i) {
if (i.getParent() == null || isEmpty())
return null; // not in list
if (i.getParent() != this)
throw new PromiscuousItemException(i, i.getParent());
- DoublyLinkedList.Item<T> next = i.getNext();
- DoublyLinkedList.Item<T> prev = i.getPrev();
+ T next = i.getNext();
+ T prev = i.getPrev();
if ((next == null) && (prev == null)) // only item in list
assert size == 1;
@@ -298,7 +300,7 @@
/**
* {...@inheritdoc}
*/
- public void insertPrev(DoublyLinkedList.Item<T> i,
DoublyLinkedList.Item<T> j) {
+ public void insertPrev(T i, T j) {
if (j.getParent() != null)
throw new PromiscuousItemException(j, j.getParent());
if ((j.getNext() != null) || (j.getPrev() != null))
@@ -323,7 +325,7 @@
throw new PromiscuousItemException(i,
i.getParent()); // different trace to make easier debugging
if (i.getParent() != this)
throw new PromiscuousItemException(i,
i.getParent());
- DoublyLinkedList.Item<T> prev = i.getPrev();
+ T prev = i.getPrev();
if (prev == null) {
if (i != _firstItem)
throw new VirginItemException(i);
@@ -342,7 +344,7 @@
/**
* {...@inheritdoc}
*/
- public void insertNext(DoublyLinkedList.Item<T> i,
DoublyLinkedList.Item<T> j) {
+ public void insertNext(T i, T j) {
if (j.getParent() != null)
throw new PromiscuousItemException(j, i.getParent());
if ((j.getNext() != null) || (j.getPrev() != null))
@@ -365,7 +367,7 @@
} else {
if (i.getParent() != this)
throw new PromiscuousItemException(i,
i.getParent());
- DoublyLinkedList.Item next = i.getNext();
+ T next = i.getNext();
if (next == null) {
if (i != _lastItem)
throw new VirginItemException(i);
@@ -398,14 +400,10 @@
}
private class ForwardWalker implements Enumeration<T> {
- protected DoublyLinkedList.Item<T> next;
+ protected T next;
protected ForwardWalker() {
next = _firstItem;
}
- protected ForwardWalker(DoublyLinkedList.Item<T> startAt,
- boolean inclusive) {
- next = (inclusive ? startAt : startAt.getNext());
- }
public final boolean hasMoreElements() {
return next != null;
}
@@ -413,21 +411,17 @@
public T nextElement() {
if (next == null)
throw new NoSuchElementException();
- DoublyLinkedList.Item<T> result = next;
+ T result = next;
next = next.getNext();
- return (T) result;
+ return result;
}
}
private class ReverseWalker implements Enumeration<T> {
- protected DoublyLinkedList.Item<T> next;
+ protected T next;
protected ReverseWalker() {
next = _lastItem;
}
- protected ReverseWalker(DoublyLinkedList.Item<T> startAt,
- boolean inclusive) {
- next = (inclusive ? startAt : startAt.getPrev());
- }
public final boolean hasMoreElements() {
return next != null;
}
@@ -435,47 +429,54 @@
public T nextElement() {
if (next == null)
throw new NoSuchElementException();
- DoublyLinkedList.Item<T> result = next;
+ T result = next;
if(next == null) throw new IllegalStateException("next==null");
next = next.getPrev();
- return (T) result;
+ return result;
}
}
//=== list element ====================================================
- public static class Item<T> implements DoublyLinkedList.Item<T> {
- private DoublyLinkedList.Item<T> prev;
- private DoublyLinkedList.Item<T> next;
- private DoublyLinkedList list;
- @Override
- public DoublyLinkedList.Item<T> clone() {
- if(getClass() != Item.class)
- throw new RuntimeException("Must implement clone() for
"+getClass());
- return new Item<T>();
- }
- public final DoublyLinkedList.Item getNext() {
+ public static class Item<T extends DoublyLinkedListImpl.Item<?>>
implements DoublyLinkedList.Item<T> {
+ private T prev;
+ private T next;
+ private DoublyLinkedList<? super T> list;
+
+ // @Override
+ // public T clone() {
+ // if(getClass() != Item.class)
+ // throw new RuntimeException("Must implement
clone() for "+getClass());
+ // return (T) new Item<T>();
+ // }
+
+ public final T getNext() {
return next;
}
- public final DoublyLinkedList.Item setNext(DoublyLinkedList.Item<T> i)
{
- DoublyLinkedList.Item<T> old = next;
- next = i;
+
+ public final T setNext(DoublyLinkedList.Item<?> i) {
+ T old = next;
+ next = (T) i;
return old;
}
- public final DoublyLinkedList.Item getPrev() {
+
+ public final T getPrev() {
return prev;
}
- public final DoublyLinkedList.Item setPrev(DoublyLinkedList.Item<T> i)
{
- DoublyLinkedList.Item<T> old = prev;
- prev = i;
+
+ public final T setPrev(DoublyLinkedList.Item<?> i) {
+ T old = prev;
+ prev = (T) i;
return old;
}
- public DoublyLinkedList getParent() {
+
+ public DoublyLinkedList<? super T> getParent() {
return list;
}
- public DoublyLinkedList setParent(DoublyLinkedList<T> l) {
- DoublyLinkedList old = list;
+
+ public DoublyLinkedList<? super T> setParent(DoublyLinkedList<?
super T> l) {
+ DoublyLinkedList<? super T> old = list;
list = l;
return old;
}
_______________________________________________
cvs mailing list
[email protected]
http://emu.freenetproject.org/cgi-bin/mailman/listinfo/cvs
