created a WeakPriorityBlockingQueue as special implementation of a PriorityBlockingQueue with a weak object binding. - better abstraction of ordering technique - fixed some bugs according to result numbering (distinguish different counters in Queue) - fixed a ordering bug in post-ranking (ordering was decreased instead of increased) - reversed ordering numbering using a reversed ordering. The higher the ranking number the better (now). git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@7128 6c8d7289-2bf4-0310-a012-ef5d649a1542pull/1/head
orbiter
15 years ago
parent
03eb021568
commit
348dece62f
@ -0,0 +1,352 @@
|
|||||||
|
/**
|
||||||
|
* WeakPriorityBlockingQueue
|
||||||
|
* an priority blocking queue that drains elements if it gets too large
|
||||||
|
* Copyright 2010 by Michael Peter Christen, mc@yacy.net, Frankfurt a. M., Germany
|
||||||
|
* First released 09.09.2010 at http://yacy.net
|
||||||
|
*
|
||||||
|
* This library is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
* License as published by the Free Software Foundation; either
|
||||||
|
* version 2.1 of the License, or (at your option) any later version.
|
||||||
|
*
|
||||||
|
* This library 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
|
||||||
|
* Lesser General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with this program in the file lgpl21.txt
|
||||||
|
* If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.yacy.cora.storage;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Comparator;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.TreeSet;
|
||||||
|
import java.util.concurrent.Semaphore;
|
||||||
|
import java.util.concurrent.TimeUnit;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* implements a stack where elements 'float' on-top of the stack according to a weight value.
|
||||||
|
* objects pushed on the stack must implement the hashCode() method to provide a handle
|
||||||
|
* for a double-check.
|
||||||
|
* If the queue gets larger that the given maxsize, then elements from the tail of the queue
|
||||||
|
* are drained (deleted).
|
||||||
|
*/
|
||||||
|
public class WeakPriorityBlockingQueue<E> {
|
||||||
|
|
||||||
|
|
||||||
|
private final TreeSet<E> queue; // object within the stack, ordered using a TreeSet
|
||||||
|
private final Semaphore enqueued; // semaphore for elements in the stack
|
||||||
|
private final ArrayList<E> drained; // objects that had been on the stack but had been removed
|
||||||
|
protected int maxsize;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* create a new WeakPriorityBlockingQueue
|
||||||
|
* all elements in the stack are not ordered by their insert order but by a given element weight
|
||||||
|
* weights that are preferred are returned first when a pop from the stack is made
|
||||||
|
* @param maxsize the maximum size of the stack. When the stack exceeds this number, then entries are removed
|
||||||
|
*/
|
||||||
|
public WeakPriorityBlockingQueue(final int maxsize) {
|
||||||
|
// the maxsize is the maximum number of entries in the stack
|
||||||
|
// if this is set to -1, the size is unlimited
|
||||||
|
this.queue = new TreeSet<E>();
|
||||||
|
this.drained = new ArrayList<E>();
|
||||||
|
this.enqueued = new Semaphore(0);
|
||||||
|
this.maxsize = maxsize;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* clear the queue
|
||||||
|
*/
|
||||||
|
public synchronized void clear() {
|
||||||
|
this.drained.clear();
|
||||||
|
this.queue.clear();
|
||||||
|
this.enqueued.drainPermits();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* test if the queue is empty
|
||||||
|
* @return true if the queue is empty, false if not
|
||||||
|
*/
|
||||||
|
public boolean isEmpty() {
|
||||||
|
return this.queue.isEmpty() & this.drained.isEmpty();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* get the number of elements in the queue, waiting to be removed with take() or poll()
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
public synchronized int sizeQueue() {
|
||||||
|
return this.queue.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* get the number of elements that had been drained so far and are wainting
|
||||||
|
* in a list to get enumerated with element()
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
public synchronized int sizeDrained() {
|
||||||
|
return this.drained.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* get the number of elements that are available for retrieval
|
||||||
|
* this is a combined number of sizeQueue() and sizeDrained();
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
public synchronized int sizeAvailable() {
|
||||||
|
return this.queue.size() + this.drained.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* put a element on the stack using a order of the weight
|
||||||
|
* elements that had been on the stack cannot be put in again,
|
||||||
|
* they are checked against the drained list
|
||||||
|
* @param element the element (must have a equals() method)
|
||||||
|
* @param weight the weight of the element
|
||||||
|
* @param remove - the rating of the element that shall be removed in case that the stack has an size overflow
|
||||||
|
*/
|
||||||
|
public synchronized void put(final E element) {
|
||||||
|
// put the element on the stack
|
||||||
|
if (this.drained.contains(element)) return;
|
||||||
|
if (this.queue.size() == this.maxsize) {
|
||||||
|
// remove last elements if stack is too large
|
||||||
|
this.queue.remove(this.queue.last());
|
||||||
|
this.queue.add(element);
|
||||||
|
} else {
|
||||||
|
this.queue.add(element);
|
||||||
|
this.enqueued.release();
|
||||||
|
}
|
||||||
|
assert this.queue.size() == this.enqueued.availablePermits();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* return the element with the smallest weight and remove it from the stack
|
||||||
|
* @return null if no element is on the queue or the head of the queue
|
||||||
|
*/
|
||||||
|
public synchronized E poll() {
|
||||||
|
if (this.queue.isEmpty()) return null;
|
||||||
|
this.enqueued.tryAcquire();
|
||||||
|
return takeUnsafe();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieves and removes the head of this queue, waiting if necessary
|
||||||
|
* up to the specified wait time if no elements are present on this queue.
|
||||||
|
* @param timeout milliseconds until timeout
|
||||||
|
* @return the head element from the queue
|
||||||
|
* @throws InterruptedException
|
||||||
|
*/
|
||||||
|
public synchronized E poll(long timeout) throws InterruptedException {
|
||||||
|
boolean a = this.enqueued.tryAcquire(timeout, TimeUnit.MILLISECONDS);
|
||||||
|
if (!a) return null;
|
||||||
|
return takeUnsafe();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieves and removes the head of this queue, waiting if no elements are present on this queue.
|
||||||
|
* @return the head element from the queue
|
||||||
|
* @throws InterruptedException
|
||||||
|
*/
|
||||||
|
public synchronized E take() throws InterruptedException {
|
||||||
|
this.enqueued.acquire();
|
||||||
|
return takeUnsafe();
|
||||||
|
}
|
||||||
|
|
||||||
|
private E takeUnsafe() {
|
||||||
|
final E element = this.queue.first();
|
||||||
|
assert element != null;
|
||||||
|
this.queue.remove(element);
|
||||||
|
this.drained.add(element);
|
||||||
|
assert this.queue.size() == this.enqueued.availablePermits();
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* return the element with the smallest weight, but do not remove it
|
||||||
|
* @return null if no element is on the queue or the head of the queue
|
||||||
|
*/
|
||||||
|
public synchronized E peek() {
|
||||||
|
if (this.queue.isEmpty()) return null;
|
||||||
|
return this.queue.first();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* all objects that have been returned by poll or take are stored in a back-up list
|
||||||
|
* where they can be retrieved afterward. The elements from that list are stored in
|
||||||
|
* the specific order as they had been retrieved. This method returns the elements
|
||||||
|
* in that specific order and if the list is not large enough, elements available
|
||||||
|
* with poll() are taken and written to the list until the required position is
|
||||||
|
* written. If the stach size together with the recorded list is not large enough,
|
||||||
|
* null is returned
|
||||||
|
* @param position inside the drained queue
|
||||||
|
* @return the element from the recorded position or null if that position is not available
|
||||||
|
*/
|
||||||
|
public synchronized E element(final int position) {
|
||||||
|
if (position < this.drained.size()) {
|
||||||
|
return this.drained.get(position);
|
||||||
|
}
|
||||||
|
if (position >= this.queue.size() + this.drained.size()) return null; // we don't have that element
|
||||||
|
while (position >= this.drained.size()) this.poll();
|
||||||
|
return this.drained.get(position);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* retrieve an element from the drained queue but wait until a timeout
|
||||||
|
* until returning null when no element will be available within the time
|
||||||
|
* from the input queue
|
||||||
|
* @param position inside the drained queue
|
||||||
|
* @param time the timeout
|
||||||
|
* @return the element from the recorded position or null if that position is not available within the timeout
|
||||||
|
* @throws InterruptedException
|
||||||
|
*/
|
||||||
|
public synchronized E element(final int position, long time) throws InterruptedException {
|
||||||
|
long timeout = System.currentTimeMillis() + time;
|
||||||
|
if (position < this.drained.size()) {
|
||||||
|
return this.drained.get(position);
|
||||||
|
}
|
||||||
|
if (position >= this.queue.size() + this.drained.size()) return null; // we don't have that element
|
||||||
|
while (position >= this.drained.size()) {
|
||||||
|
long t = timeout - System.currentTimeMillis();
|
||||||
|
if (t <= 0) break;
|
||||||
|
this.poll(t);
|
||||||
|
}
|
||||||
|
if (position >= this.drained.size()) return null; // we still don't have that element
|
||||||
|
return this.drained.get(position);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* return the specific amount of entrie as they would be retrievable with element()
|
||||||
|
* if count is < 0 then all elements are taken
|
||||||
|
* the returned list is not cloned from the internal list and shall not be modified in any way (read-only)
|
||||||
|
* @param count
|
||||||
|
* @return a list of elements in the stack
|
||||||
|
*/
|
||||||
|
public synchronized ArrayList<E> list(final int count) {
|
||||||
|
if (count < 0) {
|
||||||
|
// shift all elements
|
||||||
|
while (!this.queue.isEmpty()) this.poll();
|
||||||
|
return this.drained;
|
||||||
|
}
|
||||||
|
if (count > sizeAvailable()) throw new RuntimeException("list(" + count + ") exceeded avaiable number of elements (" + sizeAvailable() + ")");
|
||||||
|
while (count > this.drained.size()) this.poll();
|
||||||
|
return this.drained;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* iterate over all elements available. All elements that are still in the queue are drained to recorded positions
|
||||||
|
* @return an iterator over all drained positions.
|
||||||
|
*/
|
||||||
|
public synchronized Iterator<E> iterator() {
|
||||||
|
// shift all elements to the offstack
|
||||||
|
while (!this.queue.isEmpty()) this.poll();
|
||||||
|
return this.drained.iterator();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected interface Element<E> {
|
||||||
|
public long getWeight();
|
||||||
|
public E getElement();
|
||||||
|
public boolean equals(Element<E> o);
|
||||||
|
public int hashCode();
|
||||||
|
public String toString();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected abstract static class AbstractElement<E> {
|
||||||
|
|
||||||
|
public long weight;
|
||||||
|
public E element;
|
||||||
|
|
||||||
|
public long getWeight() {
|
||||||
|
return this.weight;
|
||||||
|
}
|
||||||
|
|
||||||
|
public E getElement() {
|
||||||
|
return this.element;
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean equals(Element<E> o) {
|
||||||
|
return this.element.equals(o.getElement());
|
||||||
|
}
|
||||||
|
|
||||||
|
public int hashCode() {
|
||||||
|
return this.element.hashCode();
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
return element.toString() + "/" + weight;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* natural ordering elements, can be used as container of objects <E> in the priority queue
|
||||||
|
* the elements with smallest ordering weights are first in the queue when elements are taken
|
||||||
|
*/
|
||||||
|
public static class NaturalElement<E> extends AbstractElement<E> implements Comparable<NaturalElement<E>>, Comparator<NaturalElement<E>> {
|
||||||
|
|
||||||
|
public NaturalElement(final E element, final long weight) {
|
||||||
|
this.element = element;
|
||||||
|
this.weight = weight;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int compare(NaturalElement<E> o1, NaturalElement<E> o2) {
|
||||||
|
return o1.compareTo(o2);
|
||||||
|
}
|
||||||
|
|
||||||
|
public int compareTo(NaturalElement<E> o) {
|
||||||
|
if (this.element == o.getElement()) return 0;
|
||||||
|
if (this.element.equals(o.getElement())) return 0;
|
||||||
|
if (this.weight > o.getWeight()) return 1;
|
||||||
|
if (this.weight < o.getWeight()) return -1;
|
||||||
|
int o1h = this.hashCode();
|
||||||
|
int o2h = o.hashCode();
|
||||||
|
if (o1h > o2h) return 1;
|
||||||
|
if (o1h < o2h) return -1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* reverse ordering elements, can be used as container of objects <E> in the priority queue
|
||||||
|
* the elements with highest ordering weights are first in the queue when elements are taken
|
||||||
|
*/
|
||||||
|
public static class ReverseElement<E> extends AbstractElement<E> implements Comparable<ReverseElement<E>>, Comparator<ReverseElement<E>> {
|
||||||
|
|
||||||
|
public ReverseElement(final E element, final long weight) {
|
||||||
|
this.element = element;
|
||||||
|
this.weight = weight;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int compare(ReverseElement<E> o1, ReverseElement<E> o2) {
|
||||||
|
return o1.compareTo(o2);
|
||||||
|
}
|
||||||
|
|
||||||
|
public int compareTo(ReverseElement<E> o) {
|
||||||
|
if (this.element == o.getElement()) return 0;
|
||||||
|
if (this.element.equals(o.getElement())) return 0;
|
||||||
|
if (this.weight > o.getWeight()) return -1;
|
||||||
|
if (this.weight < o.getWeight()) return 1;
|
||||||
|
int o1h = this.hashCode();
|
||||||
|
int o2h = o.hashCode();
|
||||||
|
if (o1h > o2h) return -1;
|
||||||
|
if (o1h < o2h) return 1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
WeakPriorityBlockingQueue<ReverseElement<String>> a = new WeakPriorityBlockingQueue<ReverseElement<String>>(3);
|
||||||
|
a.put(new ReverseElement<String>("abc", 1));
|
||||||
|
//a.poll();
|
||||||
|
a.put(new ReverseElement<String>("abcx", 2));
|
||||||
|
a.put(new ReverseElement<String>("6s_7dfZk4xvc", 3));
|
||||||
|
a.put(new ReverseElement<String>("6s_7dfZk4xvcx", 4));
|
||||||
|
//a.poll();
|
||||||
|
System.out.println("size = " + a.sizeAvailable());
|
||||||
|
while (a.sizeQueue() > 0) System.out.println("> " + a.poll().toString());
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1,205 +0,0 @@
|
|||||||
// kelondroSortStack.java
|
|
||||||
// (C) 2008 by Michael Peter Christen; mc@yacy.net, Frankfurt a. M., Germany
|
|
||||||
// first published 20.02.2008 on http://yacy.net
|
|
||||||
//
|
|
||||||
// This is a part of YaCy, a peer-to-peer based web search engine
|
|
||||||
//
|
|
||||||
// $LastChangedDate: 2006-04-02 22:40:07 +0200 (So, 02 Apr 2006) $
|
|
||||||
// $LastChangedRevision: 1986 $
|
|
||||||
// $LastChangedBy: orbiter $
|
|
||||||
//
|
|
||||||
// LICENSE
|
|
||||||
//
|
|
||||||
// This program is free software; you can redistribute it and/or modify
|
|
||||||
// it under the terms of the GNU General Public License as published by
|
|
||||||
// the Free Software Foundation; either version 2 of the License, or
|
|
||||||
// (at your option) any later version.
|
|
||||||
//
|
|
||||||
// This program is distributed in the hope that it will be useful,
|
|
||||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
// GNU General Public License for more details.
|
|
||||||
//
|
|
||||||
// You should have received a copy of the GNU General Public License
|
|
||||||
// along with this program; if not, write to the Free Software
|
|
||||||
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
||||||
|
|
||||||
package net.yacy.kelondro.util;
|
|
||||||
|
|
||||||
import java.util.Iterator;
|
|
||||||
import java.util.LinkedList;
|
|
||||||
import java.util.List;
|
|
||||||
import java.util.Map;
|
|
||||||
import java.util.TreeMap;
|
|
||||||
import java.util.concurrent.ConcurrentHashMap;
|
|
||||||
|
|
||||||
public class SortStack<E> {
|
|
||||||
|
|
||||||
// implements a stack where elements 'float' on-top of the stack according to a weight value.
|
|
||||||
// objects pushed on the stack must implement the hashCode() method to provide a handle
|
|
||||||
// for a double-check.
|
|
||||||
|
|
||||||
private static final Object PRESENT = new Object(); // Dummy value to associate with an Object in the backing Map
|
|
||||||
private TreeMap<Long, List<E>> onstack; // object within the stack
|
|
||||||
private ConcurrentHashMap<E, Object> instack; // keeps track which element has been on the stack
|
|
||||||
protected int maxsize;
|
|
||||||
private boolean upward;
|
|
||||||
|
|
||||||
public SortStack(boolean upward) {
|
|
||||||
this(-1, upward);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* create a new sort stack
|
|
||||||
* all elements in the stack are not ordered by their insert order but by a given element weight
|
|
||||||
* weights that are preferred are returned first when a pop from the stack is made
|
|
||||||
* the stack may be ordered upward (preferring small weights) or downward (preferring high wights)
|
|
||||||
* @param maxsize the maximum size of the stack. When the stack exceeds this number, then the worst entries according to entry order are removed
|
|
||||||
* @param upward is the entry order and controls which elements are returned on pop. if true, then the smallest is returned first
|
|
||||||
*/
|
|
||||||
public SortStack(final int maxsize, boolean upward) {
|
|
||||||
// the maxsize is the maximum number of entries in the stack
|
|
||||||
// if this is set to -1, the size is unlimited
|
|
||||||
this.onstack = new TreeMap<Long, List<E>>();
|
|
||||||
this.instack = new ConcurrentHashMap<E, Object>();
|
|
||||||
this.maxsize = maxsize;
|
|
||||||
this.upward = upward;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public boolean isEmpty() {
|
|
||||||
return this.instack.isEmpty();
|
|
||||||
}
|
|
||||||
|
|
||||||
public int size() {
|
|
||||||
/*
|
|
||||||
int c = 0;
|
|
||||||
synchronized (onstack) {
|
|
||||||
for (List<E> l: onstack.values()) c += l.size();
|
|
||||||
assert c == this.instack.size() : "c = " + c + "; this.size() = " + this.instack.size();
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
return this.instack.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* put a element on the stack using a order of the weight
|
|
||||||
* @param element
|
|
||||||
* @param weight
|
|
||||||
*/
|
|
||||||
public void push(final E element, Long weight) {
|
|
||||||
// put the element on the stack
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
if (this.instack.put(element, PRESENT) != null) return;
|
|
||||||
|
|
||||||
List<E> l = this.onstack.get(weight);
|
|
||||||
if (l == null) {
|
|
||||||
l = new LinkedList<E>();
|
|
||||||
l.add(element);
|
|
||||||
this.onstack.put(weight, l);
|
|
||||||
} else {
|
|
||||||
l.add(element);
|
|
||||||
}
|
|
||||||
//this.instack.put(element, PRESENT);
|
|
||||||
}
|
|
||||||
// check maximum size of the stack an remove elements if the stack gets too large
|
|
||||||
if (this.maxsize <= 0) return;
|
|
||||||
while (!this.onstack.isEmpty() && this.onstack.size() > this.maxsize) synchronized (this.onstack) {
|
|
||||||
List<E> l;
|
|
||||||
if (!this.onstack.isEmpty() && this.onstack.size() > this.maxsize) {
|
|
||||||
l = this.onstack.remove((this.upward) ? this.onstack.lastKey() : this.onstack.firstKey());
|
|
||||||
for (E e: l) instack.remove(e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* return the element with the smallest weight
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public stackElement top() {
|
|
||||||
// returns the element that is currently on top of the stack
|
|
||||||
final E element;
|
|
||||||
final Long w;
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
if (this.onstack.isEmpty()) return null;
|
|
||||||
w = (this.upward) ? this.onstack.firstKey() : this.onstack.lastKey();
|
|
||||||
final List<E> l = this.onstack.get(w);
|
|
||||||
element = l.get(0);
|
|
||||||
}
|
|
||||||
return new stackElement(element, w);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* return the element with the smallest weight and remove it from the stack
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public stackElement pop() {
|
|
||||||
// returns the element that is currently on top of the stack
|
|
||||||
// it is removed and added to the offstack list
|
|
||||||
final E element;
|
|
||||||
final Long w;
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
if (this.onstack.isEmpty()) return null;
|
|
||||||
w = (this.upward) ? this.onstack.firstKey() : this.onstack.lastKey();
|
|
||||||
final List<E> l = this.onstack.get(w);
|
|
||||||
element = l.remove(0);
|
|
||||||
this.instack.remove(element);
|
|
||||||
if (l.isEmpty()) this.onstack.remove(w);
|
|
||||||
}
|
|
||||||
return new stackElement(element, w);
|
|
||||||
}
|
|
||||||
|
|
||||||
public boolean exists(final E element) {
|
|
||||||
// uses the hashCode of the element to find out of the element had been on the list or the stack
|
|
||||||
return this.instack.contains(element);
|
|
||||||
}
|
|
||||||
|
|
||||||
public void remove(final E element) {
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
if (!this.instack.contains(element)) return;
|
|
||||||
for (Map.Entry<Long,List<E>> entry: this.onstack.entrySet()) {
|
|
||||||
Iterator<E> i = entry.getValue().iterator();
|
|
||||||
while (i.hasNext()) {
|
|
||||||
if (i.next().equals(element)) {
|
|
||||||
i.remove();
|
|
||||||
if (entry.getValue().isEmpty()) {
|
|
||||||
this.onstack.remove(entry.getKey());
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public boolean bottom(final long weight) {
|
|
||||||
// returns true if the element with that weight would be on the bottom of the stack after inserting
|
|
||||||
if (this.onstack.isEmpty()) return true;
|
|
||||||
Long l;
|
|
||||||
|
|
||||||
if (this.upward) {
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
l = this.onstack.lastKey();
|
|
||||||
}
|
|
||||||
return weight > l.longValue();
|
|
||||||
} else {
|
|
||||||
synchronized (this.onstack) {
|
|
||||||
l = this.onstack.firstKey();
|
|
||||||
}
|
|
||||||
return weight < l.longValue();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public class stackElement {
|
|
||||||
public Long weight;
|
|
||||||
public E element;
|
|
||||||
public stackElement(final E element, final Long weight) {
|
|
||||||
this.element = element;
|
|
||||||
this.weight = weight;
|
|
||||||
}
|
|
||||||
public String toString() {
|
|
||||||
return element.toString() + "/" + weight;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,168 +0,0 @@
|
|||||||
// kelondroSortStore.java
|
|
||||||
// (C) 2008 by Michael Peter Christen; mc@yacy.net, Frankfurt a. M., Germany
|
|
||||||
// first published 20.02.2008 on http://yacy.net
|
|
||||||
//
|
|
||||||
// This is a part of YaCy, a peer-to-peer based web search engine
|
|
||||||
//
|
|
||||||
// $LastChangedDate: 2006-04-02 22:40:07 +0200 (So, 02 Apr 2006) $
|
|
||||||
// $LastChangedRevision: 1986 $
|
|
||||||
// $LastChangedBy: orbiter $
|
|
||||||
//
|
|
||||||
// LICENSE
|
|
||||||
//
|
|
||||||
// This program is free software; you can redistribute it and/or modify
|
|
||||||
// it under the terms of the GNU General Public License as published by
|
|
||||||
// the Free Software Foundation; either version 2 of the License, or
|
|
||||||
// (at your option) any later version.
|
|
||||||
//
|
|
||||||
// This program is distributed in the hope that it will be useful,
|
|
||||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
// GNU General Public License for more details.
|
|
||||||
//
|
|
||||||
// You should have received a copy of the GNU General Public License
|
|
||||||
// along with this program; if not, write to the Free Software
|
|
||||||
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
||||||
|
|
||||||
package net.yacy.kelondro.util;
|
|
||||||
|
|
||||||
import java.util.ArrayList;
|
|
||||||
import java.util.Iterator;
|
|
||||||
import java.util.concurrent.ConcurrentHashMap;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* extends the sortStack in such a way that it adds a list where objects, that had
|
|
||||||
* been pulled from the stack with pop are listed. Provides access methods to address
|
|
||||||
* specific elements in the list.
|
|
||||||
* @param <E>
|
|
||||||
*/
|
|
||||||
public class SortStore<E> extends SortStack<E> {
|
|
||||||
|
|
||||||
private static final Object PRESENT = new Object(); // Dummy value to associate with an Object in the backing Map
|
|
||||||
private final ArrayList<stackElement> offstack; // objects that had been on the stack but had been removed
|
|
||||||
private ConcurrentHashMap<E, Object> offset; // keeps track which element has been on the stack or is now in the offstack
|
|
||||||
private long largest;
|
|
||||||
|
|
||||||
public SortStore(boolean upward) {
|
|
||||||
this(-1, upward);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* create a new sort stack
|
|
||||||
* all elements in the stack are not ordered by their insert order but by a given element weight
|
|
||||||
* weights that are preferred are returned first when a pop from the stack is made
|
|
||||||
* the stack may be ordered upward (preferring small weights) or downward (preferring high wights)
|
|
||||||
* @param maxsize the maximum size of the stack. When the stack exceeds this number, then the worst entries according to entry order are removed
|
|
||||||
* @param upward is the entry order and controls which elements are returned on pop. if true, then the smallest is returned first
|
|
||||||
*/
|
|
||||||
public SortStore(final int maxsize, boolean upward) {
|
|
||||||
super(maxsize, upward);
|
|
||||||
this.largest = Long.MIN_VALUE;
|
|
||||||
this.offstack = new ArrayList<stackElement>();
|
|
||||||
this.offset = new ConcurrentHashMap<E, Object>();
|
|
||||||
}
|
|
||||||
|
|
||||||
public boolean isEmpty() {
|
|
||||||
if (!super.isEmpty()) return false;
|
|
||||||
return this.offstack.isEmpty();
|
|
||||||
}
|
|
||||||
|
|
||||||
public int size() {
|
|
||||||
return super.size() + this.offstack.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void push(final E element, final Long weight) {
|
|
||||||
if (this.offset.containsKey(element)) return;
|
|
||||||
if (super.exists(element)) return;
|
|
||||||
super.push(element, weight);
|
|
||||||
this.largest = Math.max(this.largest, weight.longValue());
|
|
||||||
if (this.maxsize <= 0) return;
|
|
||||||
while (!super.isEmpty() && this.size() > this.maxsize) {
|
|
||||||
this.pop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* return the element that is currently on top of the stack
|
|
||||||
* it is removed and added to the offstack list
|
|
||||||
* this is exactly the same as element(offstack.size())
|
|
||||||
*/
|
|
||||||
public stackElement pop() {
|
|
||||||
final stackElement se = super.pop();
|
|
||||||
if (se == null) return null;
|
|
||||||
this.offset.put(se.element, PRESENT);
|
|
||||||
this.offstack.add(se);
|
|
||||||
return se;
|
|
||||||
}
|
|
||||||
|
|
||||||
public stackElement top() {
|
|
||||||
return super.top();
|
|
||||||
}
|
|
||||||
|
|
||||||
public boolean exists(final E element) {
|
|
||||||
return super.exists(element) || this.offset.containsKey(element);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* return an element from a specific position. It is either taken from the offstack,
|
|
||||||
* or removed from the onstack.
|
|
||||||
* The offstack will grow if elements are not from the offstack and present at the onstack.
|
|
||||||
* @param position
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public stackElement element(final int position) {
|
|
||||||
if (position < this.offstack.size()) {
|
|
||||||
return this.offstack.get(position);
|
|
||||||
}
|
|
||||||
if (position >= super.size() + this.offstack.size()) return null; // we don't have that element
|
|
||||||
while (position >= this.offstack.size()) this.pop();
|
|
||||||
return this.offstack.get(position);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* return the specific amount of entries. If they are not yet present in the offstack, they are shifted there from the onstack
|
|
||||||
* if count is < 0 then all elements are taken
|
|
||||||
* the returned list is not cloned from the internal list and shall not be modified in any way (read-only)
|
|
||||||
* @param count
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public ArrayList<stackElement> list(final int count) {
|
|
||||||
if (count < 0) {
|
|
||||||
// shift all elements
|
|
||||||
while (!super.isEmpty()) this.pop();
|
|
||||||
return this.offstack;
|
|
||||||
}
|
|
||||||
if (count > super.size() + this.offstack.size()) throw new RuntimeException("list(" + count + ") exceeded avaiable number of elements (" + size() + ")");
|
|
||||||
while (count > this.offstack.size()) this.pop();
|
|
||||||
return this.offstack;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void remove(final E element) {
|
|
||||||
super.remove(element);
|
|
||||||
synchronized (this.offstack) {
|
|
||||||
Iterator<stackElement> i = this.offstack.iterator();
|
|
||||||
while (i.hasNext()) {
|
|
||||||
if (i.next().element.equals(element)) {
|
|
||||||
i.remove();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public synchronized boolean bottom(final long weight) {
|
|
||||||
if (super.bottom(weight)) return true;
|
|
||||||
return weight > this.largest;
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
SortStore<String> a = new SortStore<String>(true);
|
|
||||||
a.push("abc", 1L);
|
|
||||||
a.pop();
|
|
||||||
a.push("abc", 2L);
|
|
||||||
a.push("6s_7dfZk4xvc", 1L);
|
|
||||||
a.push("6s_7dfZk4xvc", 1L);
|
|
||||||
a.pop();
|
|
||||||
System.out.println("size = " + a.size());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in new issue