protected Map<String, Collection<Scan>> getSnapshotScanMapping(final List<Scan> scans) { return Multimaps.index(scans, new Function<Scan, String>() { @Nullable @Override public String apply(Scan input) { return snapshotNameForTable( Bytes.toStringBinary(input.getAttribute(Scan.SCAN_ATTRIBUTES_TABLE_NAME))); } }).asMap(); }
Multimap<K, V> unfiltered, final Predicate<? super K> keyPredicate) { if (unfiltered instanceof SetMultimap) { return filterKeys((SetMultimap<K, V>) unfiltered, keyPredicate); } else if (unfiltered instanceof ListMultimap) { return filterKeys((ListMultimap<K, V>) unfiltered, keyPredicate); } else if (unfiltered instanceof FilteredKeyMultimap) { FilteredKeyMultimap<K, V> prev = (FilteredKeyMultimap<K, V>) unfiltered; } else if (unfiltered instanceof FilteredMultimap) { FilteredMultimap<K, V> prev = (FilteredMultimap<K, V>) unfiltered; return filterFiltered(prev, Maps.<K>keyPredicateOnEntries(keyPredicate)); } else { return new FilteredKeyMultimap<K, V>(unfiltered, keyPredicate);
checkNotNull(entryPredicate); if (unfiltered instanceof SetMultimap) { return filterEntries((SetMultimap<K, V>) unfiltered, entryPredicate); ? filterFiltered((FilteredMultimap<K, V>) unfiltered, entryPredicate) : new FilteredEntryMultimap<K, V>(checkNotNull(unfiltered), entryPredicate);
@Override public <K extends K0, V> SetMultimap<K, V> build() { return Multimaps.newSetMultimap( MultimapBuilderWithKeys.this.<K, V>createMap(), new HashSetSupplier<V>(expectedValuesPerKey)); } };
@GuardedBy("monitor") void checkHealthy() { if (states.count(RUNNING) != numberOfServices) { IllegalStateException exception = new IllegalStateException( "Expected to be healthy after starting. The following services are not running: " + Multimaps.filterKeys(servicesByState, not(equalTo(RUNNING)))); throw exception; } } }
@Override public <K extends K0, V> ListMultimap<K, V> build() { return Multimaps.newListMultimap( MultimapBuilderWithKeys.this.<K, V>createMap(), new ArrayListSupplier<V>(expectedValuesPerKey)); } };
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
checkNotNull(entryPredicate); return (unfiltered instanceof FilteredSetMultimap) ? filterFiltered((FilteredSetMultimap<K, V>) unfiltered, entryPredicate) : new FilteredEntrySetMultimap<K, V>(checkNotNull(unfiltered), entryPredicate);
checkNotNull(valuesFunction); return Collectors.collectingAndThen( Multimaps.flatteningToMultimap( input -> checkNotNull(keyFunction.apply(input)), input -> valuesFunction.apply(input).peek(Preconditions::checkNotNull),
@Override public boolean equals(@Nullable Object object) { return Multimaps.equalsImpl(this, object); }
@Override public <K extends K0, V extends V0> SortedSetMultimap<K, V> build() { return Multimaps.newSortedSetMultimap( MultimapBuilderWithKeys.this.<K, V>createMap(), new TreeSetSupplier<V>(comparator)); } };
@Override public <K extends K0, V> SetMultimap<K, V> build() { return Multimaps.newSetMultimap( MultimapBuilderWithKeys.this.<K, V>createMap(), new LinkedHashSetSupplier<V>(expectedValuesPerKey)); } };
void awaitStopped(long timeout, TimeUnit unit) throws TimeoutException { monitor.enter(); try { if (!monitor.waitForUninterruptibly(stoppedGuard, timeout, unit)) { throw new TimeoutException( "Timeout waiting for the services to stop. The following " + "services have not stopped: " + Multimaps.filterKeys(servicesByState, not(in(EnumSet.of(TERMINATED, FAILED))))); } } finally { monitor.leave(); } }
@Override public <K extends K0, V> ListMultimap<K, V> build() { return Multimaps.newListMultimap( MultimapBuilderWithKeys.this.<K, V>createMap(), LinkedListSupplier.<V>instance()); } };
return filterEntries(unfiltered, Maps.<V>valuePredicateOnEntries(valuePredicate));
} else if (unfiltered instanceof FilteredSetMultimap) { FilteredSetMultimap<K, V> prev = (FilteredSetMultimap<K, V>) unfiltered; return filterFiltered(prev, Maps.<K>keyPredicateOnEntries(keyPredicate)); } else { return new FilteredKeySetMultimap<K, V>(unfiltered, keyPredicate);
checkNotNull(valuesFunction); return Collectors.collectingAndThen( Multimaps.flatteningToMultimap( input -> checkNotNull(keyFunction.apply(input)), input -> valuesFunction.apply(input).peek(Preconditions::checkNotNull),
return index(values.iterator(), keyFunction);
@Override public <K extends K0, V extends V0> SetMultimap<K, V> build() { // V must actually be V0, since enums are effectively final // (their subclasses are inaccessible) @SuppressWarnings({"unchecked", "rawtypes"}) Supplier<Set<V>> factory = (Supplier) new EnumSetSupplier<V0>(valueClass); return Multimaps.newSetMultimap(MultimapBuilderWithKeys.this.<K, V>createMap(), factory); } };
void awaitHealthy(long timeout, TimeUnit unit) throws TimeoutException { monitor.enter(); try { if (!monitor.waitForUninterruptibly(awaitHealthGuard, timeout, unit)) { throw new TimeoutException( "Timeout waiting for the services to become healthy. The " + "following services have not started: " + Multimaps.filterKeys(servicesByState, in(ImmutableSet.of(NEW, STARTING)))); } checkHealthy(); } finally { monitor.leave(); } }