Example usage for com.google.common.collect Multimaps index

Introduction

In this page you can find the example usage for com.google.common.collect Multimaps index.

Prototype

public static <K, V> ImmutableListMultimap<K, V> index(Iterator<V> values, Function<? super V, K> keyFunction) 

Source Link

Document

Creates an index ImmutableListMultimap that contains the results of applying a specified function to each item in an Iterator of values.

Usage

From source file:com.feedzai.commons.sql.abstraction.engine.testconfig.DatabaseConfigurationUtil.java

/**
 * Groups the configuration by vendor.//  www  .  j  ava  2s. c o m
 *
 * @param config The configuration.
 * @return Configuration grouped by vendor.
 */
private Map<String, Collection<String>> groupByVendor(Map<String, String> config) {
    return Multimaps.index(config.keySet(), new Function<String, String>() {
        @Override
        public String apply(String input) {
            return input.split("\\.")[0];
        }
    }).asMap();
}

---

From source file:com.b2international.snowowl.snomed.validation.detail.SnomedValidationIssueDetailExtension.java

private void extendIssueDetails(BranchContext context, Collection<ValidationIssue> issues) {
    final RevisionSearcher searcher = context.service(RevisionSearcher.class);

    final Multimap<String, ValidationIssue> issuesByComponentId = Multimaps.index(issues,
            issue -> issue.getAffectedComponent().getComponentId());

    final Multimap<ComponentCategory, String> issueComponentIdsByComponentCategory = HashMultimap.create();
    issues.stream().forEach(issue -> {
        final ComponentCategory componentCategory = getComponentCategory(
                issue.getAffectedComponent().getTerminologyComponentId());
        issueComponentIdsByComponentCategory.put(componentCategory,
                issue.getAffectedComponent().getComponentId());
    });//from  ww w .  j  a va  2s  . c  o  m

    final Multimap<String, String> issueIdsByConceptIds = HashMultimap.create();
    final Set<String> alreadyFetchedConceptIds = Sets.newHashSet();
    for (ComponentCategory category : issueComponentIdsByComponentCategory.keySet()) {
        final Query<String[]> query = buildQuery(category, issueComponentIdsByComponentCategory.get(category));

        for (Hits<String[]> hits : searcher.scroll(query)) {
            for (String[] hit : hits) {
                String id = hit[0];
                String status = hit[1];
                String moduleId = hit[2];
                issuesByComponentId.get(id).forEach(validationIssue -> {
                    validationIssue.setDetails(COMPONENT_STATUS, status);
                    validationIssue.setDetails(COMPONENT_MODULE_ID, moduleId);
                    if (CONCEPT == category) {
                        validationIssue.setDetails(CONCEPT_STATUS, status);
                        validationIssue.setDetails(SnomedDocument.Fields.EFFECTIVE_TIME,
                                Long.parseLong(hit[3]));
                        alreadyFetchedConceptIds.add(id);
                    } else if (DESCRIPTION == category || RELATIONSHIP == category) {
                        validationIssue.setDetails(SnomedDocument.Fields.EFFECTIVE_TIME,
                                Long.parseLong(hit[3]));
                        final String containerConceptId = hit[4];
                        if (!Strings.isNullOrEmpty(containerConceptId)
                                && (!issueIdsByConceptIds.containsKey(containerConceptId)
                                        || !alreadyFetchedConceptIds.contains(containerConceptId))) {
                            issueIdsByConceptIds.put(containerConceptId, id);
                        }
                        // in case of description just add the already fetched term as label to the issue, concepts and relationship will get their 
                        if (DESCRIPTION == category) {
                            validationIssue.setAffectedComponentLabels(Collections.singletonList(hit[5]));
                        }
                    }
                });
            }
        }
    }

    if (!issueIdsByConceptIds.isEmpty()) {
        final Query<String[]> conceptStatusQuery = Query.select(String[].class)
                .from(SnomedConceptDocument.class)
                .fields(SnomedConceptDocument.Fields.ID, SnomedConceptDocument.Fields.ACTIVE)
                .where(SnomedConceptDocument.Expressions.ids(issueIdsByConceptIds.keySet())).limit(SCROLL_SIZE)
                .build();

        for (Hits<String[]> hits : searcher.scroll(conceptStatusQuery)) {
            for (String[] hit : hits) {
                Collection<String> issueIds = issueIdsByConceptIds.get(hit[0]);
                issueIds.stream().forEach(id -> {
                    issuesByComponentId.get(id)
                            .forEach(validationIssue -> validationIssue.setDetails(CONCEPT_STATUS, hit[1]));
                });
            }
        }
    }
}

---

From source file:com.arpnetworking.tsdcore.sinks.MonitordSink.java

private Multimap<String, Condition> prepareConditions(final Collection<Condition> conditions) {
    // Transform conditions
    return Multimaps.index(conditions, input -> {
        // NOTE: It is assumed as part of serialization that
        // that period is part of the unique metric name.
        return input.getFQDSN().getService() + "_" + input.getFQDSN().getMetric() + "_"
                + input.getFQDSN().getCluster() + "_" + input.getFQDSN().getStatistic();
    });/*from  ww w  . ja  v a  2 s . c  om*/
}

---

From source file:com.b2international.snowowl.snomed.core.ecl.EclExpression.java

public Promise<Multimap<String, Integer>> resolveToConceptsWithGroups(final BranchContext context) {
    if (conceptsWithGroups == null) {
        final Set<String> characteristicTypes = isInferred()
                ? SnomedEclRefinementEvaluator.INFERRED_CHARACTERISTIC_TYPES
                : SnomedEclRefinementEvaluator.STATED_CHARACTERISTIC_TYPES;
        conceptsWithGroups = SnomedRequests.prepareSearchRelationship().all().filterByActive(true)
                .filterByCharacteristicTypes(characteristicTypes).filterBySource(ecl)
                .filterByGroup(1, Integer.MAX_VALUE).setEclExpressionForm(expressionForm)
                .setFields(SnomedRelationshipIndexEntry.Fields.ID,
                        SnomedRelationshipIndexEntry.Fields.SOURCE_ID,
                        SnomedRelationshipIndexEntry.Fields.GROUP)
                .build(context.id(), context.branchPath()).execute(context.service(IEventBus.class))
                .then(new Function<SnomedRelationships, Multimap<String, Integer>>() {
                    @Override/*w w w  .  ja v a2 s.c  o  m*/
                    public Multimap<String, Integer> apply(SnomedRelationships input) {
                        final Multimap<String, SnomedRelationship> relationshipsBySource = Multimaps
                                .index(input, SnomedRelationship::getSourceId);
                        final Multimap<String, Integer> groupsByRelationshipId = Multimaps
                                .transformValues(relationshipsBySource, SnomedRelationship::getGroup);
                        return ImmutableSetMultimap.copyOf(groupsByRelationshipId);
                    }
                });
    }
    return conceptsWithGroups;
}

---

From source file:com.facebook.buck.rules.Manifest.java

/**
 * @return the {@link RuleKey} of the entry that matches the on disk hashes provided by
 *     {@code fileHashCache}.//from www  .j  ava 2  s.co m
 */
public Optional<RuleKey> lookup(FileHashCache fileHashCache, SourcePathResolver resolver,
        ImmutableSet<SourcePath> universe) throws IOException {
    ImmutableListMultimap<String, SourcePath> mappedUniverse = Multimaps.index(universe,
            sourcePathToManifestHeaderFunction(resolver));
    for (Pair<RuleKey, int[]> entry : entries) {
        if (hashesMatch(fileHashCache, resolver, mappedUniverse, entry.getSecond())) {
            return Optional.of(entry.getFirst());
        }
    }
    return Optional.empty();
}

---

From source file:com.google.auto.factory.processor.AutoFactoryProcessor.java

private void doProcess(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    for (Element element : roundEnv.getElementsAnnotatedWith(Provided.class)) {
        providedChecker.checkProvidedParameter(element);
    }//w  w w .  j av  a2s.co  m

    ImmutableListMultimap.Builder<String, FactoryMethodDescriptor> indexedMethods = ImmutableListMultimap
            .builder();
    ImmutableSet.Builder<ImplemetationMethodDescriptor> implemetationMethodDescriptors = ImmutableSet.builder();
    for (Element element : roundEnv.getElementsAnnotatedWith(AutoFactory.class)) {
        Optional<AutoFactoryDeclaration> declaration = declarationFactory.createIfValid(element);
        if (declaration.isPresent()) {
            TypeElement extendingType = declaration.get().extendingType();
            List<ExecutableElement> supertypeMethods = ElementFilter
                    .methodsIn(elements.getAllMembers(extendingType));
            for (ExecutableElement supertypeMethod : supertypeMethods) {
                if (supertypeMethod.getModifiers().contains(Modifier.ABSTRACT)) {
                    ExecutableType methodType = Elements2.getExecutableElementAsMemberOf(types, supertypeMethod,
                            extendingType);
                    implemetationMethodDescriptors
                            .add(new ImplemetationMethodDescriptor.Builder()
                                    .name(supertypeMethod.getSimpleName().toString())
                                    .returnType(getAnnotatedType(element).getQualifiedName().toString())
                                    .publicMethod()
                                    .passedParameters(Parameter.forParameterList(
                                            supertypeMethod.getParameters(), methodType.getParameterTypes()))
                                    .build());
                }
            }
            for (TypeElement implementingType : declaration.get().implementingTypes()) {
                List<ExecutableElement> interfaceMethods = ElementFilter
                        .methodsIn(elements.getAllMembers(implementingType));
                for (ExecutableElement interfaceMethod : interfaceMethods) {
                    if (interfaceMethod.getModifiers().contains(Modifier.ABSTRACT)) {
                        ExecutableType methodType = Elements2.getExecutableElementAsMemberOf(types,
                                interfaceMethod, implementingType);
                        implemetationMethodDescriptors.add(new ImplemetationMethodDescriptor.Builder()
                                .name(interfaceMethod.getSimpleName().toString())
                                .returnType(getAnnotatedType(element).getQualifiedName().toString())
                                .publicMethod()
                                .passedParameters(Parameter.forParameterList(interfaceMethod.getParameters(),
                                        methodType.getParameterTypes()))
                                .build());
                    }
                }
            }
        }

        ImmutableSet<FactoryMethodDescriptor> descriptors = factoryDescriptorGenerator
                .generateDescriptor(element);
        indexedMethods.putAll(Multimaps.index(descriptors, new Function<FactoryMethodDescriptor, String>() {
            @Override
            public String apply(FactoryMethodDescriptor descriptor) {
                return descriptor.factoryName();
            }
        }));
    }

    for (Entry<String, Collection<FactoryMethodDescriptor>> entry : indexedMethods.build().asMap().entrySet()) {
        ImmutableSet.Builder<String> extending = ImmutableSet.builder();
        ImmutableSortedSet.Builder<String> implementing = ImmutableSortedSet.naturalOrder();
        boolean publicType = false;
        for (FactoryMethodDescriptor methodDescriptor : entry.getValue()) {
            extending.add(methodDescriptor.declaration().extendingType().getQualifiedName().toString());
            for (TypeElement implementingType : methodDescriptor.declaration().implementingTypes()) {
                implementing.add(implementingType.getQualifiedName().toString());
            }
            publicType |= methodDescriptor.publicMethod();
        }
        try {
            factoryWriter.writeFactory(
                    new FactoryDescriptor(entry.getKey(), Iterables.getOnlyElement(extending.build()),
                            implementing.build(), publicType, ImmutableSet.copyOf(entry.getValue()),
                            // TODO(gak): this needs to be indexed too
                            implemetationMethodDescriptors.build()));
        } catch (IOException e) {
            messager.printMessage(Kind.ERROR, "failed");
        }
    }
}

---

From source file:edu.harvard.med.screensaver.service.libraries.PlateUpdater.java

private void updatePrimaryPlateStatus(Copy copy) {
    Map<PlateStatus, Integer> statusCounts = Maps.transformValues(
            Multimaps.index(copy.getPlates().values(), Plate.ToStatus).asMap(), CollectionSize);
    PlateStatus primaryPlateStatus = Collections.max(statusCounts.entrySet(), plateStatusFrequencyComparator)
            .getKey();/*ww  w  . j a  va 2s . c o  m*/
    copy.setPrimaryPlateStatus(primaryPlateStatus);
    copy.setPlatesAvailable(statusCounts.get(PlateStatus.AVAILABLE));
}

---

From source file:org.obiba.opal.web.gwt.app.client.magma.view.SummaryTabView.java

private void renderCategoricalSummary(SummaryStatisticsDto dto) {
    CategoricalSummaryDto categorical = dto
            .getExtension(CategoricalSummaryDto.SummaryStatisticsDtoExtensions.categorical).cast();

    final double[] totals = { 0d, 0d };
    ImmutableListMultimap<Boolean, FrequencyDto> categoriesByMissing = Multimaps.index(
            JsArrays.toIterable(categorical.getFrequenciesArray()), new Function<FrequencyDto, Boolean>() {
                @Nullable/*from  w ww  .  j a  va  2  s. c o  m*/
                @Override
                public Boolean apply(@Nullable FrequencyDto input) {
                    // when boolean, is missing is not set
                    if (input != null && !input.getMissing()) {
                        totals[0] += input.getFreq();
                        return false;
                    }

                    totals[1] += input == null ? 0 : input.getFreq();
                    return true;
                }
            });

    summary.add(new CategoricalSummaryView(dto.getResource(), categorical, categoriesByMissing.get(false),
            categoriesByMissing.get(true), totals[0], totals[1], categorical.getOtherFrequency()));
}

---

From source file:com.arpnetworking.tsdcore.sinks.KMonDSink.java

private Multimap<String, Condition> prepareConditions(final Collection<Condition> conditions) {
    // Transform conditions
    return Multimaps.index(conditions, input -> {
        // NOTE: It is assumed as part of serialization that
        // that period is part of the unique metric name.
        if (input == null) {
            return null;
        }/*from  ww w. jav  a 2 s .  co m*/
        return input.getFQDSN().getService() + "_" + input.getFQDSN().getMetric() + "_"
                + input.getFQDSN().getCluster() + "_" + input.getFQDSN().getStatistic();
    });
}

---

From source file:org.apache.james.jmap.model.MessageFactory.java

private ImmutableMap<String, String> toMap(List<Field> fields) {
    Function<Entry<String, Collection<Field>>, String> bodyConcatenator = fieldListEntry -> fieldListEntry
            .getValue().stream().map(Field::getBody).collect(Collectors.toList()).stream()
            .collect(Collectors.joining(","));
    return Multimaps.index(fields, Field::getName).asMap().entrySet().stream()
            .collect(Guavate.toImmutableMap(Map.Entry::getKey, bodyConcatenator));
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• »