下面列出了org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition#com.google.common.collect.ArrayListMultimap 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
protected void doLinkModel(final EObject model, IDiagnosticConsumer consumer) {
final Multimap<EStructuralFeature.Setting, INode> settingsToLink = ArrayListMultimap.create();
final LinkingDiagnosticProducer producer = new LinkingDiagnosticProducer(consumer);
cache.execWithoutCacheClear(model.eResource(), new IUnitOfWork.Void<Resource>() {
@Override
public void process(Resource state) throws Exception {
TreeIterator<EObject> iterator = getAllLinkableContents(model);
boolean clearAllReferencesRequired = isClearAllReferencesRequired(state);
while (iterator.hasNext()) {
EObject eObject = iterator.next();
if (clearAllReferencesRequired) {
clearReferences(eObject);
}
installProxies(eObject, producer, settingsToLink);
}
}
});
installQueuedLinks(settingsToLink);
}
/**
* Associates the columns to be summarized with the functions that match their type. All valid
* combinations are used
*
* @param group A table slice group
* @param selectionFunction Function that provides the filter for the having clause
* @return A table containing a row of summarized data for each group in the table slice group
*/
private Table summarizeForHaving(
TableSliceGroup group, Function<Table, Selection> selectionFunction) {
List<Table> results = new ArrayList<>();
ArrayListMultimap<String, AggregateFunction<?, ?>> reductionMultimap =
getAggregateFunctionMultimap();
for (String name : reductionMultimap.keys()) {
List<AggregateFunction<?, ?>> reductions = reductionMultimap.get(name);
Table groupTable = group.aggregate(name, reductions.toArray(new AggregateFunction<?, ?>[0]));
groupTable = groupTable.where(selectionFunction);
if (!groupTable.isEmpty()) {
results.add(groupTable);
}
}
return combineTables(results);
}
@Test
public void testLimitDefault() throws Exception {
MetricFunction metricFunction = new MetricFunction(MetricAggFunction.AVG, METRIC.getMetricName(), this.metricId, COLLECTION, null, null);
TimeSpec timeSpec = new TimeSpec(METRIC.getMetricName(), TimeGranularity.fromString("1_SECONDS"), TimeSpec.SINCE_EPOCH_FORMAT);
ThirdEyeRequest request = ThirdEyeRequest.newBuilder()
.setMetricFunctions(Collections.singletonList(metricFunction))
.setStartTimeInclusive(1000)
.setEndTimeExclusive(2000)
.setGroupBy("dimension")
.build("ref");
String pql = PqlUtils.getPql(request, metricFunction, ArrayListMultimap.<String, String>create(), timeSpec);
Assert.assertEquals(pql, "SELECT AVG(metric) FROM collection WHERE metric >= 1 AND metric < 2 GROUP BY dimension TOP 100000");
}
private static Multimap<String, ReleaseNotesMessage> createNotes(
List<ReleaseNotesMessage> breakingMessages,
List<ReleaseNotesMessage> newFeatureMessages, List<ReleaseNotesMessage> bugMessages,
List<ReleaseNotesMessage> miscMessages, List<ReleaseNotesMessage> newModuleMessages) {
final Multimap<String, ReleaseNotesMessage> notes = ArrayListMultimap.create();
if (breakingMessages != null) {
notes.putAll(Constants.BREAKING_COMPATIBILITY_LABEL, breakingMessages);
}
if (newFeatureMessages != null) {
notes.putAll(Constants.NEW_FEATURE_LABEL, newFeatureMessages);
}
if (bugMessages != null) {
notes.putAll(Constants.BUG_LABEL, bugMessages);
}
if (miscMessages != null) {
notes.putAll(Constants.MISCELLANEOUS_LABEL, miscMessages);
}
if (newModuleMessages != null) {
notes.putAll(Constants.NEW_MODULE_LABEL, newModuleMessages);
}
return notes;
}
/**
* 设置首级菜单树
*
* @param aclDtoList
* @return
*/
private List<AclLevelRes> aclListToTree(List<AclLevelRes> aclDtoList) {
if (CollectionUtils.isEmpty(aclDtoList)) {
return Lists.newArrayList();
}
// level -> [dept1, dept2, ...] Map<String, List<Object>>
Multimap<String, AclLevelRes> levelDeptMap = ArrayListMultimap.create();
List<AclLevelRes> rootList = Lists.newArrayList();
for (AclLevelRes dto : aclDtoList) {
levelDeptMap.put(dto.getSysAclLevel(), dto);
if (LevelUtil.ROOT.equals(dto.getSysAclLevel())) {
rootList.add(dto);
}
}
// 按照seq从大到小排序
rootList.sort((o1, o2) -> o2.getSysAclSeq() - o1.getSysAclSeq());
// 递归生成树
transformDeptTree(rootList, LevelUtil.ROOT, levelDeptMap);
return rootList;
}
@Override
public Multimap<EventSlice, EventDTO> fetchEvents(Collection<EventSlice> slices) {
Multimap<EventSlice, EventDTO> output = ArrayListMultimap.create();
for (EventSlice slice : slices) {
List<Predicate> predicates = DetectionUtils.buildPredicatesOnTime(slice.getStart(), slice.getEnd());
if (predicates.isEmpty())
throw new IllegalArgumentException("Must provide at least one of start, or end");
List<EventDTO> events = this.eventDAO.findByPredicate(AND(predicates));
Iterator<EventDTO> itEvent = events.iterator();
while (itEvent.hasNext()) {
if (!slice.match(itEvent.next())) {
itEvent.remove();
}
}
output.putAll(slice, events);
}
return output;
}
@NotNull
public static ListMultimap<Chromosome, AmberSite> sites(@NotNull final String vcfFile) throws IOException {
final ListMultimap<Chromosome, AmberSite> result = ArrayListMultimap.create();
try (final AbstractFeatureReader<VariantContext, LineIterator> reader = getFeatureReader(vcfFile, new VCFCodec(), false)) {
for (VariantContext variant : reader.iterator()) {
if (variant.isNotFiltered()) {
if (HumanChromosome.contains(variant.getContig())) {
HumanChromosome chromosome = HumanChromosome.fromString(variant.getContig());
result.put(chromosome,
ImmutableAmberSite.builder()
.chromosome(variant.getContig())
.position(variant.getStart())
.ref(variant.getReference().getBaseString())
.alt(variant.getAlternateAllele(0).getBaseString())
.snpCheck(variant.hasAttribute("SNPCHECK"))
.build());
}
}
}
}
return result;
}
@Test
public void testEncodeDimensionsExclusions() {
Multimap<String, String> filters = ArrayListMultimap.create();
filters.put("a", "A");
filters.put("b", "!B");
filters.put("c", "<C");
filters.put("d", ">D");
filters.put("e", "<=E");
filters.put("f", ">=F");
List<String> encoded = EntityUtils.encodeDimensions(filters);
Assert.assertEquals(encoded.size(), 6);
Assert.assertEquals(encoded.get(0), "a%3DA");
Assert.assertEquals(encoded.get(1), "b!%3DB");
Assert.assertEquals(encoded.get(2), "c%3CC");
Assert.assertEquals(encoded.get(3), "d%3ED");
Assert.assertEquals(encoded.get(4), "e%3C%3DE");
Assert.assertEquals(encoded.get(5), "f%3E%3DF");
}
/**
* Creates a {@code Variables} configuration from a list of key/value pairs.
*
* <p>If there are multiple entries with the same key, the variable will be treated as sequence
* type.
*/
private CcToolchainVariables createVariables(String... entries) {
if (entries.length % 2 != 0) {
throw new IllegalArgumentException(
"createVariables takes an even number of arguments (key/value pairs)");
}
Multimap<String, String> entryMap = ArrayListMultimap.create();
for (int i = 0; i < entries.length; i += 2) {
entryMap.put(entries[i], entries[i + 1]);
}
CcToolchainVariables.Builder variables = CcToolchainVariables.builder();
for (String name : entryMap.keySet()) {
Collection<String> value = entryMap.get(name);
if (value.size() == 1) {
variables.addStringVariable(name, value.iterator().next());
} else {
variables.addStringSequenceVariable(name, ImmutableList.copyOf(value));
}
}
return variables.build();
}
@NotNull
private static ListMultimap<GenomePosition, StructuralVariant> cnaMap(@NotNull final Collection<StructuralVariant> variants) {
final ListMultimap<GenomePosition, StructuralVariant> result = ArrayListMultimap.create();
for (final StructuralVariant variant : variants) {
final StructuralVariantLeg start = variant.start();
result.put(GenomePositions.create(start.chromosome(), start.cnaPosition()), variant);
@Nullable
final StructuralVariantLeg end = variant.end();
if (end != null) {
result.put(GenomePositions.create(end.chromosome(), end.cnaPosition()), variant);
}
}
return result;
}
@Schedule(600)
public void pollLoot() {
if (!isLoggedIn()) {
return;
}
// Prepare the regex filter if required.
checkFilter();
// Group all loot by tile
Multimap<Tile, Loot> tmpLootMap = ArrayListMultimap.create();
Session.get().loot.find().distance(maximumDistance)
.filter(acceptable -> {
if (acceptable.getName().toLowerCase().matches(compiledFilter)) {
return !hideFiltered;
}
return filter.length() == 0 || hideFiltered;
})
.asList()
.forEach(item -> {
item.getComposite().getPrice();//force price to load
if (item.getComposite().getPrice() >= minimumGePrice) {
tmpLootMap.put(item.getTile(), item);
}
});
lootMap = tmpLootMap;
}
public List<ViewBinding> parse(List<String> modelPathtrings) {
ArrayListMultimap<String, ModelPath> viewBindings = ArrayListMultimap.create();
for (String simpleBinding : modelPathtrings) {
String[] class_pathId_modelPath = toStringArray(simpleBinding, "::");
List<ModelPath> bindings = viewBindings.get(class_pathId_modelPath[0].trim());
try {
bindings.add(buildPath(class_pathId_modelPath[1].trim(), class_pathId_modelPath[2].trim()));
} catch (Throwable t) {
t.printStackTrace(System.out);
}
}
List<ViewBinding> viewBindingsList = Lists.newArrayList();
for (Map.Entry<String, Collection<ModelPath>> entry : viewBindings.asMap().entrySet()) {
viewBindingsList.add(new ViewBinding(entry.getKey(), new ArrayList<>(entry.getValue()), false, true, null));
}
return viewBindingsList;
}
/**
* 获取 所有URL Mapping,返回格式为{"/test":["GET","POST"],"/sys":["GET","DELETE"]}
*
* @return {@link ArrayListMultimap} 格式的 URL Mapping
*/
private Multimap<String, String> allUrlMapping() {
Multimap<String, String> urlMapping = ArrayListMultimap.create();
// 获取url与类和方法的对应信息
Map<RequestMappingInfo, HandlerMethod> handlerMethods = mapping.getHandlerMethods();
handlerMethods.forEach((k, v) -> {
// 获取当前 key 下的获取所有URL
Set<String> url = k.getPatternsCondition()
.getPatterns();
RequestMethodsRequestCondition method = k.getMethodsCondition();
// 为每个URL添加所有的请求方法
url.forEach(s -> urlMapping.putAll(s, method.getMethods()
.stream()
.map(Enum::toString)
.collect(Collectors.toList())));
});
return urlMapping;
}
@VisibleForTesting
public static Multimap<BuildConfiguration, DependencyKey> targetsToDeps(
Collection<TargetAndConfiguration> nodes, ConfiguredRuleClassProvider ruleClassProvider) {
Multimap<BuildConfiguration, DependencyKey> asDeps = ArrayListMultimap.create();
for (TargetAndConfiguration targetAndConfig : nodes) {
ConfigurationTransition transition =
TransitionResolver.evaluateTransition(
targetAndConfig.getConfiguration(),
NoTransition.INSTANCE,
targetAndConfig.getTarget(),
ruleClassProvider.getTrimmingTransitionFactory());
if (targetAndConfig.getConfiguration() != null) {
// TODO(bazel-team): support top-level aspects
asDeps.put(
targetAndConfig.getConfiguration(),
DependencyKey.builder()
.setLabel(targetAndConfig.getLabel())
.setTransition(transition)
.build());
}
}
return asDeps;
}
@Test
public void testLimit() throws Exception {
MetricFunction metricFunction = new MetricFunction(MetricAggFunction.AVG, METRIC.getMetricName(), this.metricId, COLLECTION, null, null);
TimeSpec timeSpec = new TimeSpec(METRIC.getMetricName(), TimeGranularity.fromString("1_SECONDS"), TimeSpec.SINCE_EPOCH_FORMAT);
ThirdEyeRequest request = ThirdEyeRequest.newBuilder()
.setMetricFunctions(Collections.singletonList(metricFunction))
.setStartTimeInclusive(1000)
.setEndTimeExclusive(2000)
.setGroupBy("dimension")
.setLimit(12345)
.build("ref");
String pql = PqlUtils.getPql(request, metricFunction, ArrayListMultimap.<String, String>create(), timeSpec);
Assert.assertEquals(pql, "SELECT AVG(metric) FROM collection WHERE metric >= 1 AND metric < 2 GROUP BY dimension TOP 12345");
}
private ListMultimap<Class, Task> groupTasksByType(List<Task> tasks) {
final Set<Class> taskTypes = new TreeSet<Class>(new Comparator<Class>() {
public int compare(Class o1, Class o2) {
return o1.getSimpleName().compareTo(o2.getSimpleName());
}
});
taskTypes.addAll(collect(tasks, new Transformer<Class, Task>() {
public Class transform(Task original) {
return getDeclaredTaskType(original);
}
}));
ListMultimap<Class, Task> tasksGroupedByType = ArrayListMultimap.create();
for (final Class taskType : taskTypes) {
tasksGroupedByType.putAll(taskType, filter(tasks, new Spec<Task>() {
public boolean isSatisfiedBy(Task element) {
return getDeclaredTaskType(element).equals(taskType);
}
}));
}
return tasksGroupedByType;
}
public Map<DBIdentity, UserDiff> diffState() throws SQLException, MitroServletException {
// get the new state
Multimap<Integer, Integer> newState = ArrayListMultimap.create();
addUserDataToSet(userIdToSecretIds.keySet(), newState);
Map<DBIdentity, UserDiff> rval = Maps.newHashMap();
for (Integer uid : userIdToSecretIds.keySet()) {
Set<Integer> preSecrets = Sets.newHashSet(userIdToSecretIds.get(uid));
Set<Integer> postSecrets = Sets.newHashSet(newState.get(uid));
UserDiff ud = new UserDiff();
ud.removedSecrets = Sets.difference(preSecrets, postSecrets);
ud.newSecrets = Sets.difference(postSecrets, preSecrets);
if (ud.removedSecrets.isEmpty() && ud.newSecrets.isEmpty()) {
continue;
}
// TODO: optimize this to one query instead of n queries.
DBIdentity id = manager.identityDao.queryForId(uid);
ud.userName = id.getName();
rval.put(id, ud);
}
return rval;
}
@Test
void testRemoveUsersFromGroupsNullMembersInResponse() throws Exception {
Multimap<String, String> groupMapping = setupGroupMapping(1, 1);
FreeIpaClient freeIpaClient = mock(FreeIpaClient.class);
Group removeResponseGroup = mock(Group.class, RETURNS_DEEP_STUBS);
RPCResponse<Group> mockRemoveResponse = mock(RPCResponse.class);
when(mockRemoveResponse.getResult()).thenReturn(removeResponseGroup);
// FreeIPA returns null when group is empty
when(removeResponseGroup.getMemberUser()).thenReturn(null);
when(freeIpaClient.groupRemoveMembers(any(), any())).thenReturn(mockRemoveResponse);
Multimap<String, String> warnings = ArrayListMultimap.create();
underTest.removeUsersFromGroups(freeIpaClient, groupMapping, warnings::put);
assertTrue(warnings.isEmpty());
}
@Test void testMetadataColumns() throws Exception {
sql("values 1")
.withConnection(c -> {
try {
final DatabaseMetaData metaData = c.getMetaData();
final ResultSet r =
metaData.getColumns(null, null, "foodmart", null);
Multimap<String, Boolean> map = ArrayListMultimap.create();
while (r.next()) {
map.put(r.getString("TYPE_NAME"), true);
}
if (CalciteSystemProperty.DEBUG.value()) {
System.out.println(map);
}
// 1 timestamp, 2 float measure, 1 int measure, 88 dimensions
assertThat(map.keySet().size(), is(4));
assertThat(map.values().size(), is(92));
assertThat(map.get("TIMESTAMP(0) NOT NULL").size(), is(1));
assertThat(map.get("DOUBLE").size(), is(2));
assertThat(map.get("BIGINT").size(), is(1));
assertThat(map.get(VARCHAR_TYPE).size(), is(88));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
});
}
@Test
public void copyOfEmpty() {
ListMultimap<String, Integer> input = ArrayListMultimap.create();
Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.copyOf(input);
assertThat(input).isEqualTo(multimap);
assertThat(multimap).isEqualTo(input);
}
@Override
public List<Multimap<List<Object>, Object>> defaultAccumulatedValue()
{
List<Multimap<List<Object>, Object>> accu = new ArrayList<>();
for (int i = 0; i < 2; i++) {
Multimap<List<Object>, Object> mMap = ArrayListMultimap.create();
accu.add(mMap);
}
return accu;
}
/**
* Get all Response headers as a map of name to list of values.
* A value may be null.
*
* @return Map, may be empty but not null.
*/
public Multimap<String, String> getResponseHeaders() {
if (this.lastresponse == null)
return ImmutableMultimap.of();
ArrayListMultimap<String, String> multimap = ArrayListMultimap.create();
for (Header header : this.lastresponse.getAllHeaders()) {
for (HeaderElement element : header.getElements()) {
multimap.put(element.getName(), element.getValue());
}
}
return multimap;
}
private ListMultimap<String, OptionDescriptor> groupDescriptorsByName(List<OptionDescriptor> allOptions) {
ListMultimap<String, OptionDescriptor> optionsGroupedByName = ArrayListMultimap.create();
for (final OptionDescriptor option : allOptions) {
optionsGroupedByName.put(option.getName(), option);
}
return optionsGroupedByName;
}
/**
* Generates a mapping for installable Intents to installers.
*
* @param intentData the Intent data which contains installable Intents
* @return the mapping for installable Intents to installers
*/
private ArrayListMultimap<IntentInstaller, Intent> getInstallers(IntentData intentData) {
ArrayListMultimap<IntentInstaller, Intent> intentInstallers = ArrayListMultimap.create();
intentData.installables().forEach(intent -> {
IntentInstaller installer = installerRegistry.getInstaller(intent.getClass());
if (installer != null) {
intentInstallers.put(installer, intent);
} else {
log.warn(INSTALLER_NOT_FOUND, intent);
}
});
return intentInstallers;
}
@NotNull
public static <T extends GenomePosition> ListMultimap<Chromosome, T> fromPositions(@NotNull final Collection<T> regions) {
final ListMultimap<Chromosome, T> result = ArrayListMultimap.create();
for (T region : regions) {
if (HumanChromosome.contains(region.chromosome())) {
result.put(HumanChromosome.fromString(region.chromosome()), region);
}
}
return result;
}
public static Multimap<SkyKey, SkyKey> makePackageKeyToTargetKeyMap(Iterable<SkyKey> keys) {
Multimap<SkyKey, SkyKey> packageKeyToTargetKeyMap = ArrayListMultimap.create();
for (SkyKey key : keys) {
Label label = SKYKEY_TO_LABEL.apply(key);
if (label == null) {
continue;
}
packageKeyToTargetKeyMap.put(PackageValue.key(label.getPackageIdentifier()), key);
}
return packageKeyToTargetKeyMap;
}
private Multimap<String, UnitProxy> buildUnits() {
Multimap<String, UnitProxy> groupedUnits = ArrayListMultimap.create();
List<String> unitFullNames = UnitDiscovery.singleton.queryForNames();
for (String unitFullName : unitFullNames) {
UnitProxy unitProxy = UnitDiscovery.singleton.newestDefinition(unitFullName);
if (unitProxy != null)
groupedUnits.put(unitProxy.getGroup().getName(), unitProxy);
}
return groupedUnits;
}
public ListMultimap<Service, Lease<Instance>> getLeases(Collection<String> serviceIds, LeaseManager<Instance> leaseManager) {
ListMultimap<Service, Lease<Instance>> leases = ArrayListMultimap.create();
for (String serviceId : serviceIds) {
Service service = getApplicationInternal(serviceId);
leases.putAll(service, getLeases(serviceId, leaseManager));
}
return leases;
}
private List<DataDictTreeRes> dictListToTree(List<DataDictTreeRes> dictTreeList) {
Multimap<String, DataDictTreeRes> levelDeptMap = ArrayListMultimap.create();
List<DataDictTreeRes> rootList = Lists.newArrayList();
for (DataDictTreeRes dataDictTreeRes : dictTreeList) {
levelDeptMap.put(dataDictTreeRes.getSysDictCodeLevel(), dataDictTreeRes);
if (LevelUtil.ROOT.equals(dataDictTreeRes.getSysDictCodeLevel())) {
rootList.add(dataDictTreeRes);
}
}
// 按照seq从大到小排序
rootList.sort((o1, o2) -> o2.getSysDictCodeSeq() - o1.getSysDictCodeSeq());
// 递归生成树
transformDictTree(rootList, LevelUtil.ROOT, levelDeptMap);
return rootList;
}
/**
* @param installationParam
*/
public void buildMachineRedisNodeMap(InstallationParam installationParam) {
Multimap<Machine, RedisNode> machineAndRedisNode = ArrayListMultimap.create();
List<Machine> machineList = installationParam.getMachineList();
List<RedisNode> allRedisNodes = installationParam.getRedisNodeList();
for (Machine machine : machineList) {
for (RedisNode redisNode : allRedisNodes) {
if (Objects.equals(machine.getHost(), redisNode.getHost())) {
machineAndRedisNode.put(machine, redisNode);
}
}
}
installationParam.setMachineAndRedisNode(machineAndRedisNode);
}