public Collection<Integer> getFileIDs() { return inflightFileIDs.values(); }
public Collection<Long> getInFlightPointers() { return inflightEvents.values(); }
@Override public List<Node> allNodes() { return ImmutableList.copyOf(nodeMap.get().get().getNodesByHostAndPort().values()); }
@Override public AllNodes getAllNodes() { return new AllNodes(ImmutableSet.<Node>builder().add(localNode).addAll(remoteNodes.values()).build(), ImmutableSet.of(), ImmutableSet.of(), ImmutableSet.of(localNode)); }
@Override public List<Node> allNodes() { return ImmutableList.copyOf(nodeMap.get().get().getNodesByHostAndPort().values()); }
public NodeAssignmentStats(NodeTaskMap nodeTaskMap, NodeMap nodeMap, List<RemoteTask> existingTasks) { this.nodeTaskMap = requireNonNull(nodeTaskMap, "nodeTaskMap is null"); // pre-populate the assignment counts with zeros. This makes getOrDefault() faster for (Node node : nodeMap.getNodesByHostAndPort().values()) { assignmentCount.put(node, 0); } for (RemoteTask task : existingTasks) { checkArgument(queuedSplitCountByNode.put(task.getNodeId(), task.getQueuedPartitionedSplitCount()) == null, "A single stage may not have multiple tasks running on the same node"); } }
public static ResettableRandomizedIterator<Node> randomizedNodes(NodeMap nodeMap, boolean includeCoordinator, Set<Node> excludedNodes) { ImmutableList<Node> nodes = nodeMap.getNodesByHostAndPort().values().stream() .filter(node -> includeCoordinator || !nodeMap.getCoordinatorNodeIds().contains(node.getNodeIdentifier())) .filter(node -> !excludedNodes.contains(node)) .collect(toImmutableList()); return new ResettableRandomizedIterator<>(nodes); }
@Override public void unregisterEventHandler(ComponentSystem handler) { for (SetMultimap<Class<? extends Component>, EventHandlerInfo> eventHandlers : componentSpecificHandlers.values()) { Iterator<EventHandlerInfo> eventHandlerIterator = eventHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(handler)) { eventHandlerIterator.remove(); } } } Iterator<EventHandlerInfo> eventHandlerIterator = generalHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(handler)) { eventHandlerIterator.remove(); } } }
@Override public void unregisterEventHandler(ComponentSystem handler) { for (SetMultimap<Class<? extends Component>, EventSystemReplayImpl.EventHandlerInfo> eventHandlers : componentSpecificHandlers.values()) { Iterator<EventHandlerInfo> eventHandlerIterator = eventHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventSystemReplayImpl.EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(handler)) { eventHandlerIterator.remove(); } } } Iterator<EventSystemReplayImpl.EventHandlerInfo> eventHandlerIterator = generalHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventSystemReplayImpl.EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(handler)) { eventHandlerIterator.remove(); } } }
@Override public <T extends Event> void unregisterEventReceiver(EventReceiver<T> eventReceiver, Class<T> eventClass, Class<? extends Component>... componentTypes) { SetMultimap<Class<? extends Component>, EventHandlerInfo> eventHandlerMap = componentSpecificHandlers.get(eventClass); if (eventHandlerMap != null) { ReceiverEventHandlerInfo testReceiver = new ReceiverEventHandlerInfo<>(eventReceiver, 0, componentTypes); for (Class<? extends Component> c : componentTypes) { eventHandlerMap.remove(c, testReceiver); for (Class<? extends Event> childType : childEvents.get(eventClass)) { eventHandlerMap.remove(childType, testReceiver); } } } if (0 == componentTypes.length) { Iterator<EventHandlerInfo> eventHandlerIterator = generalHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(eventReceiver)) { eventHandlerIterator.remove(); } } } }
@Override public <T extends Event> void unregisterEventReceiver(EventReceiver<T> eventReceiver, Class<T> eventClass, Class<? extends Component>... componentTypes) { SetMultimap<Class<? extends Component>, EventSystemReplayImpl.EventHandlerInfo> eventHandlerMap = componentSpecificHandlers.get(eventClass); if (eventHandlerMap != null) { EventSystemReplayImpl.ReceiverEventHandlerInfo testReceiver = new EventSystemReplayImpl.ReceiverEventHandlerInfo<>(eventReceiver, 0, componentTypes); for (Class<? extends Component> c : componentTypes) { eventHandlerMap.remove(c, testReceiver); for (Class<? extends Event> childType : childEvents.get(eventClass)) { eventHandlerMap.remove(childType, testReceiver); } } } if (0 == componentTypes.length) { Iterator<EventSystemReplayImpl.EventHandlerInfo> eventHandlerIterator = generalHandlers.values().iterator(); while (eventHandlerIterator.hasNext()) { EventSystemReplayImpl.EventHandlerInfo eventHandler = eventHandlerIterator.next(); if (eventHandler.getHandler().equals(eventReceiver)) { eventHandlerIterator.remove(); } } } }
Collection<Long> values = inflightEvents.values(); if (!fileChannel.isOpen()) { file = new RandomAccessFile(inflightEventsFile, "rw");
} else { constructorInitInfo = checkConstructorInitialization(entities, state); notInitializedInConstructors = ImmutableSet.copyOf(constructorInitInfo.values());
.pack(Lists.newArrayList(workUnitsMap.values()), this.weighter); log.info(String.format( "Bin packed work units. Initial work units: %d, packed work units: %d, max weight per bin: %d, "
@Test public void no_measure_if_there_is_no_period() { periodsHolder.setPeriod(null); treeRootHolder.setRoot(builder(PROJECT, 1).build()); underTest.visit(treeRootHolder.getRoot()); assertThat(measureRepository.getAddedRawMeasures(1).values()).isEmpty(); }
private Set<LockDescriptor> getOutstandingDescriptors() { return outstandingLockRequestMultimap.values().stream() .map(LockRequest::getLockDescriptors) .flatMap(SortedLockCollection::stream) .collect(Collectors.toSet()); }
return ImmutableSet.copyOf(methods.values());
private SetMultimap<String, QualifiedName> computeTypesInScope(QualifiedName scope) { SetMultimap<String, QualifiedName> visibleInScope = HashMultimap.create(); visibleTypes.put(scope, visibleInScope); reflect.find(scope.toString()).ifPresent(element -> { element.supertypes().forEach(supertype -> { typesInScope(supertype.name()).values().forEach(type -> { if (maybeVisibleInScope(scope, visibilityOf(type), type)) { visibleInScope.put(type.getSimpleName(), type); } }); }); element.nestedTypes().forEach(nested -> { visibleInScope.put(nested.name().getSimpleName().toString(), nested.name()); }); }); return visibleInScope; }
void declareGeneratedType( Visibility visibility, QualifiedName generatedType, Set<String> supertypes) { generatedTypes.put(generatedType.toString(), generatedType); typeVisibility.put(generatedType, visibility); if (!generatedType.isTopLevel()) { get(visibleTypes, generatedType.enclosingType()) .put(generatedType.getSimpleName(), generatedType); } SetMultimap<String, QualifiedName> visibleInScope = get(visibleTypes, generatedType); supertypes.stream().flatMap(this::lookup).forEach(supertype -> { for (QualifiedName type : typesInScope(supertype).values()) { if (maybeVisibleInScope(generatedType, visibilityOf(type), type)) { visibleInScope.put(type.getSimpleName(), type); } } }); }
@Override public ImmutableSet<Element> process( SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) { List<TypeElement> modules = typesIn(elementsByAnnotation.values()); moduleValidator.addKnownModules(modules); return super.process(elementsByAnnotation); }