@CollectionSize.Require(absent = ZERO) public void testOrderedByComparator() { @SuppressWarnings("unchecked") Comparator<? super K> comparator = navigableMap.comparator(); if (comparator == null) { comparator = new Comparator<K>() { @SuppressWarnings("unchecked") @Override public int compare(K o1, K o2) { return ((Comparable) o1).compareTo(o2); } }; } Iterator<Entry<K, V>> entryItr = navigableMap.entrySet().iterator(); Entry<K, V> prevEntry = entryItr.next(); while (entryItr.hasNext()) { Entry<K, V> nextEntry = entryItr.next(); assertTrue(comparator.compare(prevEntry.getKey(), nextEntry.getKey()) < 0); prevEntry = nextEntry; } } }
public void testTailMapClearThrough() { final SortedMap<K, V> map; try { map = makePopulatedMap(); } catch (UnsupportedOperationException e) { return; } int oldSize = map.size(); if (map.size() < 2 || !supportsClear) { return; } Iterator<Entry<K, V>> iterator = map.entrySet().iterator(); iterator.next(); // advance Entry<K, V> secondEntry = iterator.next(); K key = secondEntry.getKey(); SortedMap<K, V> subMap = map.tailMap(key); int subMapSize = subMap.size(); subMap.clear(); assertEquals(map.size(), oldSize - subMapSize); assertTrue(subMap.isEmpty()); } }
@Override public boolean advanceNextPosition() { if (nanoStart == 0) { nanoStart = System.nanoTime(); } try { if (iterator.hasNext()) { serializer.reset(); Entry<Key, Value> row = iterator.next(); for (Entry<Key, Value> entry : WholeRowIterator.decodeRow(row.getKey(), row.getValue()).entrySet()) { bytesRead += entry.getKey().getSize() + entry.getValue().getSize(); serializer.deserialize(entry); } return true; } else { return false; } } catch (IOException e) { throw new PrestoException(IO_ERROR, "Caught IO error from serializer on read", e); } }
/** {@inheritDoc} */ @Override public Iterator<Cache.Entry<?, ?>> query(@Nullable String cacheName, Collection<Object> params, @Nullable IndexingQueryFilter filters) throws IgniteSpiException { if (params.size() < 2) throw new IgniteSpiException("Range parameters required."); Iterator<Object> paramsIt = params.iterator(); Object from = paramsIt.next(); Object to = paramsIt.next(); from = from instanceof BinaryObject ? ((BinaryObject)from).deserialize() : from; to = to instanceof BinaryObject ? ((BinaryObject)to).deserialize() : to; SortedMap<Object, Object> map = idx.subMap(from, to); Collection<Cache.Entry<?, ?>> res = new ArrayList<>(map.size()); for (Map.Entry<Object, Object> entry : map.entrySet()) res.add(new CacheEntryImpl<>(entry.getKey(), entry.getValue())); return res.iterator(); }
public void installNodes(List<Address> new_nodes) { nodes.clear(); for(Address node: new_nodes) { int hash=Math.abs((node.hashCode() * FACTOR) & (HASH_SPACE - 1)); for(int i=hash; i < hash + HASH_SPACE; i++) { short new_index=(short)(i & (HASH_SPACE - 1)); if(!nodes.containsKey(new_index)) { nodes.put(new_index, node); break; } } } if(log.isTraceEnabled()) { StringBuilder sb=new StringBuilder("node mappings:\n"); for(Map.Entry<Short,Address> entry: nodes.entrySet()) { sb.append(entry.getKey() + ": " + entry.getValue()).append("\n"); } log.trace(sb); } }
private Describe appendAllAttributes() { Map<String, String> map = driver.executeJavaScript( "var s = {};" + "var attrs = arguments[0].attributes;" + "for (var i = 0; i < attrs.length; i++) {" + " var a = attrs[i]; " + " if (a.name != 'style') {" + " s[a.name] = a.value;" + " }" + "}" + "return s;", element); SortedMap<String, String> sortedByName = new TreeMap<>(); if (map != null) { sortedByName.putAll(map); } sortedByName.put("value", element.getAttribute("value")); if (!sortedByName.containsKey("type")) { sortedByName.put("type", element.getAttribute("type")); } for (Map.Entry<String, String> entry : sortedByName.entrySet()) { attr(entry.getKey(), entry.getValue()); } return this; }
public void testTailMapWriteThrough() { final SortedMap<K, V> map; try { map = makePopulatedMap(); } catch (UnsupportedOperationException e) { return; } if (map.size() < 2 || !supportsPut) { return; } Iterator<Entry<K, V>> iterator = map.entrySet().iterator(); Entry<K, V> firstEntry = iterator.next(); Entry<K, V> secondEntry = iterator.next(); K key = secondEntry.getKey(); SortedMap<K, V> subMap = map.tailMap(key); V value = getValueNotInPopulatedMap(); subMap.put(key, value); assertEquals(secondEntry.getValue(), value); assertEquals(map.get(key), value); try { subMap.put(firstEntry.getKey(), value); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
public void testTailMapRemoveThrough() { final SortedMap<K, V> map; try { map = makePopulatedMap(); } catch (UnsupportedOperationException e) { return; } int oldSize = map.size(); if (map.size() < 2 || !supportsRemove) { return; } Iterator<Entry<K, V>> iterator = map.entrySet().iterator(); Entry<K, V> firstEntry = iterator.next(); Entry<K, V> secondEntry = iterator.next(); K key = secondEntry.getKey(); SortedMap<K, V> subMap = map.tailMap(key); subMap.remove(key); assertNull(subMap.remove(firstEntry.getKey())); assertEquals(map.size(), oldSize - 1); assertFalse(map.containsKey(key)); assertEquals(subMap.size(), oldSize - 2); }
@Override public TagSet queryMetricTags(DatastoreMetricQuery query) throws DatastoreException { TagSetImpl tagSet = new TagSetImpl(); Iterator<DataPointsRowKey> rowKeys = getKeysForQueryIterator(query); MemoryMonitor mm = new MemoryMonitor(20); while (rowKeys.hasNext()) { DataPointsRowKey dataPointsRowKey = rowKeys.next(); for (Map.Entry<String, String> tag : dataPointsRowKey.getTags().entrySet()) { tagSet.addTag(tag.getKey(), tag.getValue()); mm.checkMemoryAndThrowException(); } } return (tagSet); }
/** * Return an Iterator over the set of keys and values that have been added. * Using the entry set to iterate is more efficient in the case where you * need to access respective counts as well as values, since it doesn't * require a "get" for every key...the value is provided in the Map.Entry. * <p> * If added values are integral (i.e., integers, longs, Integers, or Longs), * they are converted to Longs when they are added, so the values of the * map entries returned by the Iterator will in this case be Longs.</p> * * @return entry set Iterator * @since 3.1 */ public Iterator<Map.Entry<Comparable<?>, Long>> entrySetIterator() { return freqTable.entrySet().iterator(); }
private void mapBufferEntries() throws IOException { SortedMap<Long, IndexEntry> indexStartMap = new TreeMap<>(); for (Map.Entry<IndexKey, IndexEntry> columnEntry : columnEntries.entrySet()) { long startOffset = columnEntry.getValue().startOffset; indexStartMap.put(startOffset, columnEntry.getValue()); } long runningSize = 0; List<Long> offsetAccum = new ArrayList<>(); for (Map.Entry<Long, IndexEntry> offsetEntry : indexStartMap.entrySet()) { IndexEntry entry = offsetEntry.getValue(); runningSize += entry.size; if (runningSize >= MAX_ALLOCATION_SIZE) { mapAndSliceFile(indexStartMap, offsetAccum, offsetEntry.getKey()); runningSize = entry.size; offsetAccum.clear(); } offsetAccum.add(offsetEntry.getKey()); } if (offsetAccum.size() > 0) { mapAndSliceFile(indexStartMap, offsetAccum, offsetAccum.get(0) + runningSize); } }
Iterator<Map.Entry<K2, V2>> i2 = map2.entrySet().iterator(); for (Map.Entry<K1, V1> entry1 : map1.entrySet()) { Map.Entry<K2, V2> entry2 = i2.next(); DualKey dk = new DualKey(path, entry1.getKey(), entry2.getKey()); if (!visited.contains(dk)) { toCompare.addFirst(dk); dk = new DualKey(path, entry1.getValue(), entry2.getValue()); if (!visited.contains(dk)) { toCompare.addFirst(dk);
private static void assertRanges( AllEntriesLabelScanReader reader, Labels[] data ) { Iterator<NodeLabelRange> iterator = reader.iterator(); long highestRangeId = highestRangeId( data ); for ( long rangeId = 0; rangeId <= highestRangeId; rangeId++ ) { SortedMap<Long/*nodeId*/,List<Long>/*labelIds*/> expected = rangeOf( data, rangeId ); if ( expected != null ) { assertTrue( "Was expecting range " + expected, iterator.hasNext() ); NodeLabelRange range = iterator.next(); assertEquals( rangeId, range.id() ); for ( Map.Entry<Long,List<Long>> expectedEntry : expected.entrySet() ) { long[] labels = range.labels( expectedEntry.getKey() ); assertArrayEquals( asArray( expectedEntry.getValue().iterator() ), labels ); } } // else there was nothing in this range } assertFalse( iterator.hasNext() ); }
protected String getCanonicalizedHeadersForStringToSign(SignableRequest<?> request) { List<String> headersToSign = getHeadersForStringToSign(request); for (int i = 0; i < headersToSign.size(); i++) { headersToSign.set(i, StringUtils.lowerCase(headersToSign.get(i))); } SortedMap<String, String> sortedHeaderMap = new TreeMap<String, String>(); for (Map.Entry<String, String> entry : request.getHeaders().entrySet()) { if (headersToSign.contains(StringUtils.lowerCase(entry.getKey()))) { sortedHeaderMap.put(StringUtils.lowerCase(entry.getKey()), entry.getValue()); } } StringBuilder builder = new StringBuilder(); for (Map.Entry<String, String> entry : sortedHeaderMap.entrySet()) { builder.append(StringUtils.lowerCase(entry.getKey())).append(":") .append(entry.getValue()).append("\n"); } return builder.toString(); }
static void writeAttributes( OutputStream out, SortedMap<String, String> attributesSortedByName) throws IOException { for (Map.Entry<String, String> attribute : attributesSortedByName.entrySet()) { String attrName = attribute.getKey(); String attrValue = attribute.getValue(); writeAttribute(out, attrName, attrValue); } } }
public Address hash(K key, List<Address> members) { int index=Math.abs(key.hashCode() & (HASH_SPACE - 1)); if(members != null && !members.isEmpty()) { SortedMap<Short,Address> tmp=new TreeMap<>(nodes); for(Iterator<Map.Entry<Short,Address>> it=tmp.entrySet().iterator(); it.hasNext();) { Map.Entry<Short, Address> entry=it.next(); if(!members.contains(entry.getValue())) { it.remove(); } } return findFirst(tmp, index); } return findFirst(nodes, index); }