public static void addtoMinheap() {
for (RankedDoc i : R) {
lminheap.put(i.novelty, Integer.toString(i.DOC));
}
lminheap = lminheap.descendingMap();
}
@CollectionSize.Require(SEVERAL)
public void testDescendingNavigation() {
List<Entry<K, V>> descending = new ArrayList<Entry<K, V>>();
for (Entry<K, V> entry : navigableMap.descendingMap().entrySet()) {
descending.add(entry);
}
Collections.reverse(descending);
assertEquals(entries, descending);
}
private NavigableMap<Number640, Data> filterCopyOrig(
final NavigableMap<Number640, Data> tmp, int limit, boolean ascending) {
NavigableMap<Number640, Data> retVal = new TreeMap<Number640, Data>();
int counter = 0;
for (Map.Entry<Number640, Data> entry :
ascending ? tmp.entrySet() : tmp.descendingMap().entrySet()) {
if (!entry.getValue().hasPrepareFlag()) {
if (limit >= 0 && counter++ >= limit) {
break;
}
retVal.put(entry.getKey(), entry.getValue());
}
}
return retVal;
}
private static AffinityLock acquireCore(boolean bind, int cpuId, AffinityStrategy... strategies) {
synchronized (AffinityLock.class) {
for (AffinityStrategy strategy : strategies) {
LOOP:
for (AffinityLock[] als : CORES.descendingMap().values()) {
for (AffinityLock al : als)
if (!al.canReserve() || !strategy.matches(cpuId, al.cpuId)) continue LOOP;
final AffinityLock al = als[0];
al.assignCurrentThread(bind, true);
return al;
}
}
}
if (LOGGER.isLoggable(Level.WARNING))
LOGGER.warning("No reservable Core for " + Thread.currentThread());
return acquireLock(bind, cpuId, strategies);
}
public void testDescendingMap() {
NavigableMap<String, Integer> map = create();
NavigableMap<String, Integer> descendingMap = map.descendingMap();
assertTrue(descendingMap instanceof SynchronizedNavigableMap);
assertSame(mutex, ((SynchronizedNavigableMap<String, Integer>) descendingMap).mutex);
}
@Override
public NavigableMap<K, V> create(Object... entries) {
NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
return map.descendingMap();
}
