Author: j16sdiz
Date: 2008-08-18 15:47:46 +0000 (Mon, 18 Aug 2008)
New Revision: 22012
Modified:
branches/saltedhashstore/freenet/src/freenet/node/KeyTracker.java
branches/saltedhashstore/freenet/src/freenet/node/LocationManager.java
branches/saltedhashstore/freenet/src/freenet/node/PeerManager.java
branches/saltedhashstore/freenet/src/freenet/node/TestnetHandler.java
branches/saltedhashstore/freenet/src/freenet/node/Version.java
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedList.java
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedListImpl.java
branches/saltedhashstore/freenet/src/freenet/support/LRUHashtable.java
branches/saltedhashstore/freenet/src/freenet/support/LRUQueue.java
branches/saltedhashstore/freenet/src/freenet/support/TimeSortedHashtable.java
Log:
Merge build 1158 (r22011) into saltedhashstore
Modified: branches/saltedhashstore/freenet/src/freenet/node/KeyTracker.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/node/KeyTracker.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/node/KeyTracker.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -411,7 +411,9 @@
* @throws UpdatableSortedLinkedListKilledException
*/
private void removeResendRequest(int seqNumber) throws
UpdatableSortedLinkedListKilledException {
- resendRequestQueue.removeByKey(seqNumber);
+ synchronized(resendRequestQueue) {
+ resendRequestQueue.removeByKey(seqNumber);
+ }
}
/**
@@ -486,14 +488,18 @@
* Is an ack request queued for this packet number?
*/
private boolean queuedAckRequest(int packetNumber) {
- return ackRequestQueue.containsKey(new Integer(packetNumber));
+ synchronized(ackRequestQueue) {
+ return ackRequestQueue.containsKey(packetNumber);
+ }
}
/**
* Is a resend request queued for this packet number?
*/
private boolean queuedResendRequest(int packetNumber) {
- return resendRequestQueue.containsKey(new
Integer(packetNumber));
+ synchronized(resendRequestQueue) {
+ return resendRequestQueue.containsKey(packetNumber);
+ }
}
/**
@@ -579,7 +585,11 @@
* @throws UpdatableSortedLinkedListKilledException
*/
private void removeAckRequest(int seqNo) throws
UpdatableSortedLinkedListKilledException {
- QueuedAckRequest qr = (QueuedAckRequest)
ackRequestQueue.removeByKey(seqNo);
+ QueuedAckRequest qr = null;
+
+ synchronized(ackRequestQueue) {
+ qr = (QueuedAckRequest)
ackRequestQueue.removeByKey(seqNo);
+ }
if(qr != null)
qr.onAcked();
else
@@ -941,8 +951,12 @@
synchronized(ackQueue) {
ackQueue.clear();
}
- resendRequestQueue.kill();
- ackRequestQueue.kill();
+ synchronized(resendRequestQueue) {
+ resendRequestQueue.kill();
+ }
+ synchronized(ackRequestQueue) {
+ ackRequestQueue.kill();
+ }
synchronized(packetsToResend) {
packetsToResend.clear();
}
@@ -1046,7 +1060,9 @@
}
public int countAckRequests() {
- return ackRequestQueue.size();
+ synchronized(ackRequestQueue) {
+ return ackRequestQueue.size();
+ }
}
public int countResendRequests() {
Modified: branches/saltedhashstore/freenet/src/freenet/node/LocationManager.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/node/LocationManager.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/node/LocationManager.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -1284,7 +1284,7 @@
private static final long MAX_AGE = 7*24*60*60*1000;
- private final TimeSortedHashtable knownLocs = new TimeSortedHashtable();
+ private final TimeSortedHashtable<Double> knownLocs = new
TimeSortedHashtable<Double>();
void registerLocationLink(double d, double t) {
if(logMINOR) Logger.minor(this, "Known Link: "+d+ ' ' +t);
@@ -1297,15 +1297,14 @@
void registerKnownLocation(double d) {
if(logMINOR) Logger.minor(this, "Known Location: "+d);
- Double dd = new Double(d);
long now = System.currentTimeMillis();
synchronized(knownLocs) {
- Logger.minor(this, "Adding location "+dd+" knownLocs size
"+knownLocs.size());
- knownLocs.push(dd, now);
- Logger.minor(this, "Added location "+dd+" knownLocs size
"+knownLocs.size());
+ Logger.minor(this, "Adding location "+d+" knownLocs size
"+knownLocs.size());
+ knownLocs.push(d, now);
+ Logger.minor(this, "Added location "+d+" knownLocs size
"+knownLocs.size());
knownLocs.removeBefore(now - MAX_AGE);
- Logger.minor(this, "Added and pruned location "+dd+" knownLocs
size "+knownLocs.size());
+ Logger.minor(this, "Added and pruned location "+d+" knownLocs
size "+knownLocs.size());
}
if(logMINOR) Logger.minor(this, "Estimated net size(session):
"+knownLocs.size());
}
Modified: branches/saltedhashstore/freenet/src/freenet/node/PeerManager.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/node/PeerManager.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/node/PeerManager.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -1107,11 +1107,7 @@
protected StringBuilder getOldOpennetPeersString(OpennetManager om) {
StringBuilder sb = new StringBuilder();
- PeerNode[] peers;
- synchronized(this) {
- peers = om.getOldPeers();
- }
- for(PeerNode pn : peers) {
+ for(PeerNode pn : om.getOldPeers()) {
if(pn instanceof OpennetPeerNode)
sb.append(pn.exportDiskFieldSet());
}
Modified: branches/saltedhashstore/freenet/src/freenet/node/TestnetHandler.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/node/TestnetHandler.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/node/TestnetHandler.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -182,6 +182,8 @@
fs =
node.exportOpennetPublicFieldSet();
fs.writeTo(bw);
}
+ bw.write("\n\nMy peers:\n");
+
bw.write(node.peers.getDarknetPeersString().toString());
bw.close();
}else {
Logger.error(this, "Unknown testnet
command: "+command);
Modified: branches/saltedhashstore/freenet/src/freenet/node/Version.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/node/Version.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/node/Version.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -24,11 +24,11 @@
public static final String protocolVersion = "1.0";
/** The build number of the current revision */
- private static final int buildNumber = 1157;
+ private static final int buildNumber = 1158;
/** Oldest build of Fred we will talk to */
private static final int oldLastGoodBuild = 1155;
- private static final int newLastGoodBuild = 1157;
+ private static final int newLastGoodBuild = 1158;
static final long transitionTime;
static {
Modified:
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedList.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedList.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedList.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -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:
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedListImpl.java
===================================================================
---
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedListImpl.java
2008-08-18 15:37:31 UTC (rev 22011)
+++
branches/saltedhashstore/freenet/src/freenet/support/DoublyLinkedListImpl.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -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: branches/saltedhashstore/freenet/src/freenet/support/LRUHashtable.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/support/LRUHashtable.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/support/LRUHashtable.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -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
Modified: branches/saltedhashstore/freenet/src/freenet/support/LRUQueue.java
===================================================================
--- branches/saltedhashstore/freenet/src/freenet/support/LRUQueue.java
2008-08-18 15:37:31 UTC (rev 22011)
+++ branches/saltedhashstore/freenet/src/freenet/support/LRUQueue.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -3,7 +3,7 @@
import java.util.Enumeration;
import java.util.Hashtable;
-public class LRUQueue<T> {
+public class LRUQueue {
/*
* I've just converted this to using the DLList and Hashtable
@@ -12,8 +12,8 @@
* push is by far the most done operation, this should be an
* overall improvement.
*/
- private final DoublyLinkedListImpl<QItem<T>> list = new
DoublyLinkedListImpl<QItem<T>>();
- private final Hashtable<T, QItem<T>> hash = new Hashtable<T, QItem<T>>();
+ private final DoublyLinkedListImpl list = new DoublyLinkedListImpl();
+ private final Hashtable hash = new Hashtable();
/**
* push()ing an object that is already in
@@ -21,10 +21,10 @@
* recently used position, but doesn't add
* a duplicate entry in the queue.
*/
- public final synchronized void push(T obj) {
- QItem<T> insert = hash.get(obj);
+ public final synchronized void push(Object obj) {
+ QItem insert = (QItem)hash.get(obj);
if (insert == null) {
- insert = new QItem<T>(obj);
+ insert = new QItem(obj);
hash.put(obj,insert);
} else {
list.remove(insert);
@@ -36,10 +36,10 @@
/**
* push to bottom (least recently used position)
*/
- public synchronized void pushLeast(T obj) {
- QItem<T> insert = hash.get(obj);
+ public synchronized void pushLeast(Object obj) {
+ QItem insert = (QItem)hash.get(obj);
if (insert == null) {
- insert = new QItem<T>(obj);
+ insert = new QItem(obj);
hash.put(obj,insert);
} else {
list.remove(insert);
@@ -51,9 +51,9 @@
/**
* @return Least recently pushed Object.
*/
- public final synchronized T pop() {
+ public final synchronized Object pop() {
if ( list.size() > 0 ) {
- return hash.remove(list.pop().obj).obj;
+ return ((QItem)hash.remove(((QItem)list.pop()).obj)).obj;
} else {
return null;
}
@@ -63,8 +63,8 @@
return list.size();
}
- public final synchronized boolean remove(T obj) {
- QItem<T> i = hash.remove(obj);
+ public final synchronized boolean remove(Object obj) {
+ QItem i = (QItem)(hash.remove(obj));
if(i != null) {
list.remove(i);
return true;
@@ -82,26 +82,26 @@
return hash.containsKey(obj);
}
- public Enumeration<T> elements() {
+ public Enumeration elements() {
return new ItemEnumeration();
}
- private class ItemEnumeration implements Enumeration<T> {
- private Enumeration<QItem<T>> source = list.reverseElements();
+ private class ItemEnumeration implements Enumeration {
+ private Enumeration source = list.reverseElements();
public boolean hasMoreElements() {
return source.hasMoreElements();
}
- public T nextElement() {
- return source.nextElement().obj;
+ public Object nextElement() {
+ return ((QItem) source.nextElement()).obj;
}
}
- private static class QItem<T> extends DoublyLinkedListImpl.Item<QItem<T>> {
- public T obj;
+ private static class QItem extends DoublyLinkedListImpl.Item {
+ public Object obj;
- public QItem(T obj) {
+ public QItem(Object obj) {
this.obj = obj;
}
}
@@ -119,7 +119,7 @@
* order.
* @param array The array to fill in. If it is too small a new array of
the same type will be allocated.
*/
- public synchronized <E> E[] toArray(E[] array) {
+ public synchronized Object[] toArray(Object[] array) {
return hash.keySet().toArray(array);
}
@@ -131,8 +131,8 @@
public synchronized Object[] toArrayOrdered() {
Object[] array = new Object[list.size()];
int x = 0;
- for(Enumeration<QItem<T>> e =
list.reverseElements();e.hasMoreElements();) {
- array[x++] = e.nextElement().obj;
+ for(Enumeration e =
list.reverseElements();e.hasMoreElements();) {
+ array[x++] = ((QItem)e.nextElement()).obj;
}
return array;
}
@@ -146,14 +146,14 @@
* The array to fill in. If it is too small a new array of
the
* same type will be allocated.
*/
- public synchronized <E> E[] toArrayOrdered(E[] array) {
+ public synchronized Object[] toArrayOrdered(Object[] array) {
array = toArray(array);
int listSize = list.size();
if(array.length != listSize)
throw new
IllegalStateException("array.length="+array.length+" but list.size="+listSize);
int x = 0;
- for(Enumeration<QItem<T>> e =
list.reverseElements();e.hasMoreElements();) {
- array[x++] = (E) e.nextElement().obj;
+ for(Enumeration e =
list.reverseElements();e.hasMoreElements();) {
+ array[x++] = ((QItem)e.nextElement()).obj;
}
return array;
}
Modified:
branches/saltedhashstore/freenet/src/freenet/support/TimeSortedHashtable.java
===================================================================
---
branches/saltedhashstore/freenet/src/freenet/support/TimeSortedHashtable.java
2008-08-18 15:37:31 UTC (rev 22011)
+++
branches/saltedhashstore/freenet/src/freenet/support/TimeSortedHashtable.java
2008-08-18 15:47:46 UTC (rev 22012)
@@ -9,41 +9,40 @@
/**
* Variant on LRUHashtable which provides an efficient how-many-since-time-T
operation.
*/
-public class TimeSortedHashtable implements Cloneable {
-
+public class TimeSortedHashtable<T extends Comparable> implements Cloneable {
public TimeSortedHashtable() {
- this.elements = new TreeSet(new MyComparator());
- this.valueToElement = new HashMap();
+ this.elements = new TreeSet<Comparable>(new MyComparator());
+ this.valueToElement = new HashMap<T, Element<T>>();
}
- private TimeSortedHashtable(TimeSortedHashtable c) {
- this.elements = new TreeSet(c.elements);
- this.valueToElement = new HashMap(c.valueToElement);
+ private TimeSortedHashtable(TimeSortedHashtable<T> c) {
+ this.elements = new TreeSet<Comparable>(c.elements);
+ this.valueToElement = new HashMap<T,
Element<T>>(c.valueToElement);
}
- private static class Element {
+ private static class Element<T extends Comparable> implements
Comparable<Element<T>> {
- Element(long t, Comparable v) {
+ Element(long t, T v) {
time = t;
value = v;
}
long time;
- final Comparable value;
+ final T value;
- public int compareTo(Object o) {
- Element e = (Element) o;
- if(time > e.time) return 1;
- if(time < e.time) return -1;
- return value.compareTo(e.value);
+ public int compareTo(Element<T> o) {
+ if(time > o.time) return 1;
+ if(time < o.time) return -1;
+ return value.compareTo(o.value);
}
}
- private static class MyComparator implements Comparator {
+ private static class MyComparator implements Comparator /* <Long ||
Element<T>> */{
public int compare(Object arg0, Object arg1) {
if(arg0 instanceof Long && arg1 instanceof Long) return
((Long)arg0).compareTo((Long)arg1);
- if(arg0 instanceof Element && arg1 instanceof Element)
return ((Element)arg0).compareTo(arg1);
+ if (arg0 instanceof Element && arg1 instanceof Element)
+ return ((Element) arg0).compareTo((Element)
arg1);
// Comparing a Long with an Element, because we are
searching for an Element by the value of a Long.
// Hence we do not need to consider the element value.
if(arg0 instanceof Long) {
@@ -64,14 +63,14 @@
}
- private final TreeSet elements;
- private final HashMap valueToElement;
+ private final TreeSet<Comparable> /* <Long || Element<T>> */elements;
+ private final HashMap<T, Element<T>> valueToElement;
- public TimeSortedHashtable clone() {
- return new TimeSortedHashtable(this);
+ public TimeSortedHashtable<T> clone() {
+ return new TimeSortedHashtable<T>(this);
}
- public final void push(Comparable value) {
+ public final void push(T value) {
push(value, System.currentTimeMillis());
}
@@ -82,14 +81,13 @@
* a duplicate entry in the queue.
* @param now
*/
- public final synchronized void push(Comparable value, long now) {
-
+ public final synchronized void push(T value, long now) {
assert(elements.size() == valueToElement.size());
- Element e = (Element) valueToElement.get(value);
+ Element<T> e = valueToElement.get(value);
if(e == null) {
- e = new Element(now, value);
+ e = new Element<T>(now, value);
elements.add(e);
valueToElement.put(value, e);
} else {
@@ -105,10 +103,10 @@
* Remove and return the least recently pushed value.
* @return Least recently pushed value.
*/
- public final synchronized Comparable popValue() {
+ public final synchronized T popValue() {
assert(elements.size() == valueToElement.size());
- Element e = (Element) elements.first();
+ Element<T> e = (Element<T>) elements.first();
valueToElement.remove(e.value);
elements.remove(e);
@@ -116,24 +114,24 @@
return e.value;
}
- public final synchronized Object peekValue() {
- return ((Element) elements.first()).value;
+ public final synchronized T peekValue() {
+ return ((Element<T>) elements.first()).value;
}
public final int size() {
return elements.size();
}
- public final synchronized boolean removeValue(Comparable value) {
+ public final synchronized boolean removeValue(T value) {
assert(elements.size() == valueToElement.size());
- Element e = (Element) valueToElement.remove(value);
+ Element<T> e = valueToElement.remove(value);
if(e == null) return false;
elements.remove(e);
assert(elements.size() == valueToElement.size());
return true;
}
- public final synchronized boolean containsValue(Comparable key) {
+ public final synchronized boolean containsValue(T key) {
return valueToElement.containsKey(key);
}
@@ -141,8 +139,8 @@
* Note that this does not automatically promote the key. You have
* to do that by hand with push(key, value).
*/
- public final synchronized long getTime(Object value) {
- Element e = (Element) valueToElement.remove(value);
+ public final synchronized long getTime(T value) {
+ Element<T> e = valueToElement.remove(value);
if(e == null) return -1;
return e.time;
}
@@ -151,14 +149,12 @@
* @return The set of times after the given time.
*/
public final synchronized Long[] timesAfter(long t) {
- Long time = new Long(t);
+ Set<Comparable> s = elements.tailSet(t);
- Set s = elements.tailSet(time);
-
Long[] times = new Long[s.size()];
int x = 0;
- for(Iterator i = s.iterator();i.hasNext();) {
- times[x++] = new Long(((Element)i.next()).time);
+ for(Iterator<Comparable> i = s.iterator();i.hasNext();) {
+ times[x++] = ((Element<T>) i.next()).time;
}
return times;
@@ -167,24 +163,20 @@
/**
* @return The set of values after the given time.
*/
- public final synchronized Comparable[] valuesAfter(long t, Comparable[]
values) {
- Long time = new Long(t);
+ public final synchronized <E extends Comparable> E[] valuesAfter(long t,
E[] values) {
+ Set<Comparable> s = elements.tailSet(t);
- Set s = elements.tailSet(time);
-
int x = 0;
- for(Iterator i = s.iterator();i.hasNext();) {
- values[x++] = ((Element)i.next()).value;
+ for(Iterator<Comparable> i = s.iterator();i.hasNext();) {
+ values[x++] = (E) ((Element<T>) i.next()).value;
}
return values;
}
public synchronized int countValuesAfter(long t) {
- Long time = new Long(t);
+ Set<Comparable> s = elements.tailSet(t);
- Set s = elements.tailSet(time);
-
return s.size();
}
@@ -193,12 +185,10 @@
*/
public final synchronized void removeBefore(long t) {
assert(elements.size() == valueToElement.size());
+ Set<Comparable> s = elements.headSet(t);
- Long time = new Long(t);
- Set s = elements.headSet(time);
-
- for(Iterator i = s.iterator();i.hasNext();) {
- Element e = (Element) i.next();
+ for(Iterator<Comparable> i = s.iterator();i.hasNext();) {
+ Element<T> e = (Element<T>) i.next();
valueToElement.remove(e.value);
i.remove();
}
@@ -206,8 +196,7 @@
assert(elements.size() == valueToElement.size());
}
- public final synchronized Object[] pairsAfter(long timestamp,
Comparable[] valuesArray) {
+ public final synchronized <E extends Comparable> Object[]
pairsAfter(long timestamp, E[] valuesArray) {
return new Object[] { valuesAfter(timestamp, valuesArray),
timesAfter(timestamp) };
}
-
-}
+}
\ No newline at end of file
