public void testOrderedEntries() { TreeMultimap<String, Integer> multimap = createPopulate(); assertThat(multimap.entries()) .containsExactly( Maps.immutableEntry("foo", 1), Maps.immutableEntry("foo", 3), Maps.immutableEntry("foo", 7), Maps.immutableEntry("google", 2), Maps.immutableEntry("google", 6), Maps.immutableEntry("tree", 0), Maps.immutableEntry("tree", 4)) .inOrder(); }
public void testOrderedEntries() { TreeMultimap<String, Integer> multimap = createPopulate(); assertThat(multimap.entries()) .containsExactly( Maps.immutableEntry((String) null, 7), Maps.immutableEntry((String) null, 3), Maps.immutableEntry((String) null, 1), Maps.immutableEntry("tree", (Integer) null), Maps.immutableEntry("tree", 0), Maps.immutableEntry("google", 6), Maps.immutableEntry("google", 2)) .inOrder(); }
for(Entry<Integer, Integer> stealerToPartition: stealerToStolenPrimaryPartitions.entries()) { partitionsMoved.add(stealerToPartition); batchFinalCluster = UpdateClusterUtils.createUpdatedCluster(batchFinalCluster,
private static String formatIssues(final TreeMultimap<Integer, String> issuesMultiMap) { final StringBuilder builder = new StringBuilder(); for (final Entry<Integer, String> entry : issuesMultiMap.entries()) { builder.append(System.lineSeparator()) .append("\t") .append("line: ") .append(entry.getKey()) .append(" / message: ") .append(entry.getValue()); } return builder.toString(); }
/** * Get a rank of senses ordered by MFS. * @param lemmaPOSClass the lemma#pos entry * @param rankSize the size of the rank * @return the ordered multimap containing the rank */ public TreeMultimap<Integer, String> getMFSRanking(String lemmaPOSClass, Integer rankSize) { TreeMultimap<Integer, String> mfsResultsMap = getOrderedMap(lemmaPOSClass); TreeMultimap<Integer, String> mfsRankMap = TreeMultimap.create(Ordering.natural().reverse(), Ordering.natural()); for (Map.Entry<Integer, String> freqSenseEntry : Iterables.limit(mfsResultsMap.entries(), rankSize)) { mfsRankMap.put(freqSenseEntry.getKey(), freqSenseEntry.getValue()); } return mfsRankMap; }
private void updateScheduledMessages() { try { // first see if we have new messages ConsumerRecords<UUID, ScheduledMessage> consumerRecords = scheduledMessagesConsumer.poll(0); if (!consumerRecords.isEmpty()) { consumerRecords.partitions().forEach(topicPartition -> consumerRecords.records(topicPartition).forEach(consumerRecord -> { // can be null (for deleted messages) // @todo: get the shardkey from a topicmap ManagedActorShard managedActorShard = this.localShards.get(new ShardKey(internalActorSystem.getName(), topicPartition.partition())); if (managedActorShard != null) { if (consumerRecord.value() != null) { managedActorShard.scheduledMessages.put(consumerRecord.value().getFireTime(TimeUnit.MILLISECONDS), consumerRecord.value()); } else { // for removed scheduledmessages we only have the id, we will have to search managedActorShard.scheduledMessages.entries().removeIf(entry -> entry.getValue().getId().equals(consumerRecord.key())); } } })); } } catch(WakeupException | InterruptException e) { logger.warn("Recoverable exception while polling for ScheduledMessages", e); } catch(KafkaException e) { logger.error("FATAL: Unrecoverable exception while polling for ScheduledMessages", e); // @todo: this is an unrecoverable error } catch(Throwable t) { logger.error("Unexpected exception while polling for ScheduledMessages", t); } }
public void testOrderedEntries() { TreeMultimap<String, Integer> multimap = createPopulate(); assertThat(multimap.entries()).containsExactly( Maps.immutableEntry("foo", 1), Maps.immutableEntry("foo", 3), Maps.immutableEntry("foo", 7), Maps.immutableEntry("google", 2), Maps.immutableEntry("google", 6), Maps.immutableEntry("tree", 0), Maps.immutableEntry("tree", 4)).inOrder(); }
private Multimap<Long, OrdersGap> getGaps(final TreeMultimap<DateTime, Order> ordersByStartTime) { Multimap<Long, OrdersGap> gaps = HashMultimap.create(); NavigableSet<DateTime> keys = ordersByStartTime.keySet(); for (Map.Entry<DateTime, Order> startTimeAndOrder : ordersByStartTime.entries()) { Order fromOrder = startTimeAndOrder.getValue(); DateTime end = fromOrder.interval.getEnd(); DateTime closestNextOrderStartDate = keys.higher(end); if (closestNextOrderStartDate == null) { continue; } for (Order toOrder : ordersByStartTime.get(closestNextOrderStartDate)) { if (ObjectUtils.equals(fromOrder.productionLineId, toOrder.productionLineId)) { gaps.put(fromOrder.productionLineId, OrdersGap.between(fromOrder, toOrder)); } } } return gaps; }
@Override public String getShardsAndDaysHint(String field, Date begin, Date end, Date rangeBegin, Date rangeEnd, Set<String> datatypeFilter) throws TableNotFoundException { SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd"); String beginStr = formatter.format(begin); String endStr = formatter.format(end); StringBuilder builder = new StringBuilder(); for (Map.Entry<String,Entry> entry : entries.entries()) { if (endStr.compareTo(entry.getKey()) < 0) { return builder.toString(); } else if (beginStr.compareTo(entry.getKey()) <= 0) { if (entry.getValue().field.equals(field) && (datatypeFilter == null || datatypeFilter.isEmpty() || datatypeFilter.contains(entry.getValue().dataType))) { if (builder.length() > 0) { builder.append(','); } builder.append(entry.getValue().shard); } } } return builder.toString(); } }
public void testOrderedEntries() { TreeMultimap<String, Integer> multimap = createPopulate(); assertThat(multimap.entries()).containsExactly( Maps.immutableEntry((String) null, 7), Maps.immutableEntry((String) null, 3), Maps.immutableEntry((String) null, 1), Maps.immutableEntry("tree", (Integer) null), Maps.immutableEntry("tree", 0), Maps.immutableEntry("google", 6), Maps.immutableEntry("google", 2)).inOrder(); }
int min = this.rdfMax; for (Map.Entry<Integer, Node> entry: nodeReplicaSizeMap.entries()) { int replicaSize = entry.getKey(); Node node = entry.getValue();
if (greatestNumCompleteFutures >= quorum) { // normal exit, quorum done = true; return valuesSortedByCount.entries().iterator().next().getValue();
} else { partitionsToShards.get(consumerRecord.partition()).scheduledMessages.entries() .removeIf(entry -> entry.getValue().getId().equals(consumerRecord.key()));
wal.fileDescriptors.entries().iterator(); while (fileIterator.hasNext()) { Map.Entry<Integer, FSWindowReplayWAL.FileDescriptor> entry = fileIterator.next();
private static void assertHasIssues(final TreeMultimap<Integer, String> actualIssues, final TreeMultimap<Integer, String> expectedIssues) { final TreeMultimap<Integer, String> detectedUnexpectedIssues = TreeMultimap.create(); final TreeMultimap<Integer, String> undetectedExpectedIssues = TreeMultimap.create(); Preconditions.checkArgument(!expectedIssues.isEmpty(), "Test file must declare expected issues!"); for (final Entry<Integer, String> issue : expectedIssues.entries()) { if (!actualIssues.containsEntry(issue.getKey(), issue.getValue())) { undetectedExpectedIssues.put(issue.getKey(), issue.getValue()); } } for (final Entry<Integer, String> issue : actualIssues.entries()) { if (!expectedIssues.containsEntry(issue.getKey(), issue.getValue())) { detectedUnexpectedIssues.put(issue.getKey(), issue.getValue()); } } final SoftAssertions softly = new SoftAssertions(); softly.assertThat(undetectedExpectedIssues.isEmpty()) .overridingErrorMessage(EXPECTED_MESSAGE_PREFIX, formatIssues(undetectedExpectedIssues)) .isTrue(); softly.assertThat(detectedUnexpectedIssues.isEmpty()) .overridingErrorMessage(UNEXPECTED_MESSAGE_PREFIX, formatIssues(detectedUnexpectedIssues)) .isTrue(); softly.assertAll(); }
for (Map.Entry<String,Entry> entry : entries.entries()) { if (entry.getValue().type.equals(dateType) && (datatypeFilter == null || datatypeFilter.isEmpty() || datatypeFilter.contains(entry.getValue().dataType))) {
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { if (interruptFlag != null && interruptFlag.get()) throw new IterationInterruptedException(); this.range = range; Key key = range.getStartKey(); if (key == null) { key = new Key(); } iter = map.entries().iterator(); if (iter.hasNext()) { entry = iter.next(); while (entry.getKey().compareTo(key) <= 0) entry = iter.next(); if (range.afterEndKey(entry.getKey())) { entry = null; } } else entry = null; while (hasTop() && range.beforeStartKey(getTopKey())) { next(); } }