/** * add hash to load value after invoking load method * @param textType * @param hash */ public void addTextHash(TextTypeEnum textType, int hash) { if (hash == 0) { return; } Set<Integer> hashSet = typedHashes.computeIfAbsent(textType, k -> new HashSet<>()); hashSet.add(hash); }
/** * Instantiating an instance if it hasn't already been instantiated. * * See {@link InstanceSelector#select(IndexSlot)} */ @Override T select( IndexSlot slot ) { return instances.computeIfAbsent( slot, s -> { assertOpen(); return factory.apply( s ); } ); }
/** * Adds a handler to the collection. Note that the order in which you register the handlers determines the order * in which they will be handled during the various stages of a unit of work. * * @param phase The phase of the unit of work to attach the handler to * @param handler The handler to invoke in the given phase */ public void addHandler(Phase phase, Consumer<UnitOfWork<T>> handler) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Adding handler {} for phase {}", handler.getClass().getName(), phase.toString()); } final Deque<Consumer<UnitOfWork<T>>> consumers = handlers.computeIfAbsent(phase, p -> new ArrayDeque<>()); if (phase.isReverseCallbackOrder()) { consumers.addFirst(handler); } else { consumers.add(handler); } }
@Override public void progress( ImportStage stage, int percent ) { if ( percent > 100 ) { fail( "Expected percentage to be 0..100% but was " + percent ); } AtomicInteger stageProgress = progress.computeIfAbsent( stage, s -> new AtomicInteger() ); int previous = stageProgress.getAndSet( percent ); if ( previous > percent ) { fail( "Progress should go forwards only, but went from " + previous + " to " + percent ); } }
@Override public void accept(SourceRecord record) { if (record.value() == null) { tombstones.incrementAndGet(); } else { Operation op = Envelope.operationFor(record); if (op != null) { statsByOperation.computeIfAbsent(op, key -> new AtomicLong()).incrementAndGet(); } } }
/** * add hash to load value after invoking load method * @param textType * @param hash */ public void addTextHash(TextTypeEnum textType, int hash) { if (hash == 0) { return; } Set<Integer> hashSet = typedHashes.computeIfAbsent(textType, k -> new HashSet<>()); hashSet.add(hash); }
private static void register(ComponentConverter r, ProtocolVersion... versions) { for (ProtocolVersion version : versions) { registry.computeIfAbsent(version, k -> new ArrayList<>()).add(r); } }
public T getTable(ProtocolVersion version) { return registry.computeIfAbsent(version, k -> { throw new IllegalArgumentException(MessageFormat.format("Missing remapping table for version {0}", k)); }); }
public void setStrategies(List<TriggerStrategy> strategies) { EnumMap<TriggerStrategyType, List<TriggerStrategy>> ss = new EnumMap<>(TriggerStrategyType.class); strategies.forEach(st -> ss.computeIfAbsent(st.type(), k -> new ArrayList<>()).add(st)); this.strategies = ss; }
ScannerRunner(List<JavaFileScanner> executableScanners) { checks = new EnumMap<>(Tree.Kind.class); subscriptionVisitors = executableScanners.stream() .filter(isIssuableSubscriptionVisitor) .map(s -> (SubscriptionVisitor) s) .collect(Collectors.toList()); subscriptionVisitors.forEach(s -> s.nodesToVisit().forEach(k -> checks.computeIfAbsent(k, key -> new ArrayList<>()).add(s)) ); }
ScannerRunner(List<JavaFileScanner> executableScanners) { checks = new EnumMap<>(Tree.Kind.class); subscriptionVisitors = executableScanners.stream() .filter(isIssuableSubscriptionVisitor) .map(s -> (SubscriptionVisitor) s) .collect(Collectors.toList()); subscriptionVisitors.forEach(s -> s.nodesToVisit().forEach(k -> checks.computeIfAbsent(k, key -> new ArrayList<>()).add(s)) ); }
@Override public SeqType seqType(final Occ occ) { // cannot be statically instantiated due to circular dependencies if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
@Override public final SeqType seqType(final Occ occ) { if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
@Override public SeqType seqType(final Occ occ) { if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
@Override public final SeqType seqType(final Occ occ) { if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
@Override public SeqType seqType(final Occ occ) { if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
@Override public final SeqType seqType(final Occ occ) { if(seqTypes == null) seqTypes = new EnumMap<>(Occ.class); return seqTypes.computeIfAbsent(occ, o -> new SeqType(this, o)); }
protected static void register( Int2ObjectOpenHashMap<EnumMap<ProtocolVersion, List<ItemStackComplexRemapper>>> registry, Material material, ItemStackComplexRemapper transformer, ProtocolVersion... versions ) { if (!material.isItem()) { throw new IllegalArgumentException(material + " is not an item"); } EnumMap<ProtocolVersion, List<ItemStackComplexRemapper>> map = registry.computeIfAbsent(ItemMaterialLookup.getRuntimeId(material), k -> new EnumMap<>(ProtocolVersion.class)); Arrays.stream(versions).forEach(version -> map.computeIfAbsent(version, k -> new ArrayList<>()).add(transformer)); }
private int calculateMaxWidth(Column column, String string) { final int maxWidth = Math.max(maxWidths.computeIfAbsent(column, c -> 0), string.length()); maxWidths.put(column, maxWidth); return maxWidth; }
static EnumMap<LogEntryBodyCase, AtomicLong> countEntries(RaftLog raftLog) throws Exception { final EnumMap<LogEntryBodyCase, AtomicLong> counts = new EnumMap<>(LogEntryBodyCase.class); for(long i = 0; i < raftLog.getNextIndex(); i++) { final LogEntryProto e = raftLog.get(i); counts.computeIfAbsent(e.getLogEntryBodyCase(), c -> new AtomicLong()).incrementAndGet(); } return counts; }