Example usage for com.google.common.collect HashMultimap create

List of usage examples for com.google.common.collect HashMultimap create

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. HashMultimap
  6. create

Introduction

In this page you can find the example usage for com.google.common.collect HashMultimap create.

Prototype

public static <K, V> HashMultimap<K, V> create()

Source Link

Document

Creates a new, empty HashMultimap with the default initial capacities.

Usage

From source file:com.b2international.snowowl.snomed.datastore.index.change.ReferringMemberChangeProcessor.java

public Multimap<String, RefSetMemberChange> process(ICDOCommitChangeSet commitChangeSet,
        RevisionSearcher searcher) throws IOException {
    final Multimap<String, RefSetMemberChange> memberChanges = HashMultimap.create();

    // process new members
    filterRefSetMembers(commitChangeSet.getNewComponents(), referencedComponentType).forEach((newMember) -> {
        addChange(memberChanges, newMember, MemberChangeKind.ADDED);
    });/*from w  w w. j a va  2  s.co  m*/

    // process dirty members
    filterRefSetMembers(commitChangeSet.getDirtyComponents(), referencedComponentType)
            .forEach((dirtyMember) -> {
                final CDORevisionDelta revisionDelta = commitChangeSet.getRevisionDeltas()
                        .get(dirtyMember.cdoID());
                if (revisionDelta != null) {
                    final CDOFeatureDelta changeStatusDelta = revisionDelta
                            .getFeatureDelta(SnomedRefSetPackage.Literals.SNOMED_REF_SET_MEMBER__ACTIVE);
                    if (changeStatusDelta instanceof CDOSetFeatureDelta) {
                        CDOSetFeatureDelta delta = (CDOSetFeatureDelta) changeStatusDelta;
                        final boolean oldValue;
                        if (delta.getOldValue() instanceof Boolean) {
                            oldValue = (boolean) delta.getOldValue();
                        } else if (CDOSetFeatureDelta.UNSPECIFIED == delta.getOldValue()) {
                            oldValue = false;
                        } else {
                            throw new RuntimeException("Unknown old value type: " + delta.getOldValue());
                        }
                        final boolean newValue = (boolean) delta.getValue();
                        if (oldValue != newValue) {
                            addChange(memberChanges, dirtyMember, MemberChangeKind.CHANGED);
                        }
                    }
                }
            });

    // process detached members
    final Iterable<CDOID> detachedComponents = commitChangeSet
            .getDetachedComponents(SnomedRefSetPackage.Literals.SNOMED_REF_SET_MEMBER);
    final Iterable<Long> detachedMemberStorageKeys = CDOIDUtils.createCdoIdToLong(detachedComponents);
    final Iterable<SnomedRefSetMemberIndexEntry> detachedMembers = searcher
            .get(SnomedRefSetMemberIndexEntry.class, detachedMemberStorageKeys);

    StreamSupport.stream(detachedMembers.spliterator(), false)
            .filter(doc -> referencedComponentType == doc.getReferencedComponentType()).forEach(doc -> {
                final String uuid = doc.getId();
                final String referencedComponentId = doc.getReferencedComponentId();
                final String refSetId = doc.getReferenceSetId();
                memberChanges.put(referencedComponentId,
                        new RefSetMemberChange(uuid, refSetId, MemberChangeKind.REMOVED, doc.isActive()));
            });

    return memberChanges;
}

From source file:cuchaz.enigma.analysis.JarIndex.java

public JarIndex(ReferencedEntryPool entryPool) {
    this.entryPool = entryPool;
    this.obfClassEntries = Sets.newHashSet();
    this.translationIndex = new TranslationIndex(entryPool);
    this.access = Maps.newHashMap();
    this.fields = HashMultimap.create();
    this.methods = HashMultimap.create();
    this.methodImplementations = HashMultimap.create();
    this.methodsReferencing = HashMultimap.create();
    this.methodReferences = HashMultimap.create();
    this.fieldReferences = HashMultimap.create();
    this.innerClassesByOuter = HashMultimap.create();
    this.outerClassesByInner = Maps.newHashMap();
    this.bridgedMethods = Maps.newHashMap();
    this.syntheticMethods = Sets.newHashSet();
}

From source file:nl.tue.gale.ae.processor.XMLProcessor.java

public Map<List<String>, Module> getModuleTable() {
    Map<List<String>, Module> result = new HashMap<List<String>, Module>();
    Multimap<Module, String> buildMap = HashMultimap.create();
    for (Map.Entry<String, Module> entry : moduleTable.entrySet())
        buildMap.put(entry.getValue(), entry.getKey());
    for (Map.Entry<Module, Collection<String>> entry : buildMap.asMap().entrySet())
        result.put(new ArrayList<String>(entry.getValue()), entry.getKey());
    return result;
}

From source file:com.publictransitanalytics.scoregenerator.datalayer.directories.GTFSReadingServiceTypeCalendar.java

public GTFSReadingServiceTypeCalendar(final Store<DateKey, ServiceSet> serviceTypesStore,
        final Reader calendarReader, final Reader calendarDatesReader)
        throws IOException, InterruptedException {

    this.serviceTypesStore = serviceTypesStore;
    try {//from  w  ww . j  a va 2  s.c o  m
        if (serviceTypesStore.isEmpty()) {
            final SetMultimap<LocalDate, String> serviceTypesMap = HashMultimap.create();
            parseCalendarFile(calendarReader, serviceTypesMap);
            parseCalendarDatesFile(calendarDatesReader, serviceTypesMap);

            for (Map.Entry<LocalDate, Collection<String>> entry : serviceTypesMap.asMap().entrySet()) {
                serviceTypesStore.put(new DateKey(entry.getKey()),
                        new ServiceSet(ImmutableSet.copyOf(entry.getValue())));
            }
        }
    } catch (final BitvantageStoreException e) {
        throw new ScoreGeneratorFatalException(e);
    }
}

From source file:edu.umn.msi.tropix.client.directory.impl.LocalPersonSupplierImpl.java

public Multimap<String, Person> get() {
    Iterable<Person> persons = Lists.transform(Arrays.asList(userService.getUsers()), USER_TO_PERSON_FUNCTION);
    final Multimap<String, Person> personMap = HashMultimap.create();
    personMap.putAll(institution, persons);
    return personMap;
}

From source file:com.enonic.cms.store.dao.ResourceUsageDao.java

public Multimap<ResourceKey, ResourceReferencer> getUsedBy(ResourceKey resourceKey) {

    Multimap usedBy = HashMultimap.create();

    for (PortletEntity obj : contentObjectDao.findByStyle(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.CONTENT_OBJECT_STYLE));
    }//from w w w .j a  v a  2 s  . c  om
    for (PortletEntity obj : contentObjectDao.findByBorder(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.CONTENT_OBJECT_BORDER));
    }
    for (ContentTypeEntity obj : contentTypeDao.findByCSS(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.CONTENT_TYPE_CSS));
    }
    for (PageTemplateEntity obj : pageTemplateDao.findByStyle(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.PAGE_TEMPLATE_STYLE));
    }
    for (PageTemplateEntity obj : pageTemplateDao.findByCSS(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.PAGE_TEMPLATE_CSS));
    }
    for (SiteEntity obj : siteDao.findByDefaultCss(resourceKey)) {
        usedBy.put(resourceKey, new ResourceReferencer(obj, ResourceReferencerType.SITE_DEFAULT_CSS));
    }
    return usedBy;
}

From source file:com.data2semantics.yasgui.client.tab.optionbar.ParametersListGrid.java

public void setArgsInSettings() {
    saveAllEdits();//  www.  j  av a 2s  .  c om
    HashMultimap<String, String> args = HashMultimap.create();
    getTotalRows();

    Record[] gridRecords = getRecords();
    for (Record record : gridRecords) {
        if (record != null && record.getAttribute(KEY_KEY) != null && record.getAttribute(KEY_VALUE) != null) {
            args.put(record.getAttribute(KEY_KEY), record.getAttribute(KEY_VALUE));
        }
    }
    view.getSelectedTabSettings().resetAndaddCustomQueryArgs(args);
    LocalStorageHelper.storeSettings(view.getSettings());
}

From source file:de.unisb.cs.st.javalanche.mutation.analyze.AnalyzeUtil.java

/**
 * Returns a multimap that contains a mapping between the tests and the
 * mutations that are detected by the test.
 * //from  w w  w  .  jav  a 2s .  co m
 * @param mutations
 *            the mutations to check.
 * @return the multimap between the tests and mutations.
 */
public static Multimap<String, Mutation> getDetectedByTest(Iterable<Mutation> mutations) {
    Multimap<String, Mutation> mm = HashMultimap.create();
    for (Mutation mutation : mutations) {
        if (mutation.isKilled()) {
            MutationTestResult mutationResult = mutation.getMutationResult();
            Collection<TestMessage> errors = mutationResult.getErrors();
            Collection<TestMessage> failures = mutationResult.getFailures();
            Set<TestMessage> all = new HashSet<TestMessage>(errors);
            all.addAll(failures);
            for (TestMessage testMessage : all) {
                String testCaseName = testMessage.getTestCaseName();
                mm.put(testCaseName, mutation);
            }
        }
    }
    return mm;
}

From source file:de.unisb.cs.st.javalanche.mutation.analyze.DetectedByAssertAnalyzer.java

@Override
public String analyze(Iterable<Mutation> mutations, HtmlReport report) {
    HashMultimap<String, Long> mutationPerAssert = HashMultimap.create();
    int totalMutations = 0;
    for (Mutation m : mutations) {
        totalMutations++;//from  w  ww .j  ava 2s .  c  o  m
        MutationTestResult mutationResult = m.getMutationResult();
        mutationPerAssert.put("non.existing.location-1", m.getId());
        if (mutationResult != null) {
            Collection<TestMessage> failures = mutationResult.getFailures();
            boolean foundByAssert = false;
            for (TestMessage tm : failures) {
                String message = tm.getMessage();
                List<Location> locations = parseLocation(message);
                for (Location loc : locations) {
                    if (loc == null) {
                        logger.warn("No location found for failing test " + tm);
                    } else {
                        mutationPerAssert.put(loc.toString(), m.getId());
                        foundByAssert = true;
                    }
                }
            }
            if (!foundByAssert && m.isDetected()) {
                mutationPerAssert.put("implicit", m.getId());
            }
        }

    }
    String message = "Assert locations: " + mutationPerAssert.keySet().size();
    message += "\nTotal mappings: " + mutationPerAssert.size();
    message += "\nTotal mutations: " + totalMutations;
    try {
        SerializationUtils.serialize(mutationPerAssert,
                new FileOutputStream(new File("mutationPerAssert.ser")));
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    }
    return message;
}

From source file:org.apache.beam.runners.core.construction.graph.OutputDeduplicator.java

/**
 * Ensure that no {@link PCollection} output by any of the {@code stages} or {@code
 * unfusedTransforms} is produced by more than one of those stages or transforms.
 *
 * <p>For each {@link PCollection} output by multiple stages and/or transforms, each producer is
 * rewritten to produce a partial {@link PCollection}, which are then flattened together via an
 * introduced Flatten node which produces the original output.
 *///from w  w w  .ja  v  a 2s  . com
static DeduplicationResult ensureSingleProducer(QueryablePipeline pipeline, Collection<ExecutableStage> stages,
        Collection<PTransformNode> unfusedTransforms) {
    RunnerApi.Components.Builder unzippedComponents = pipeline.getComponents().toBuilder();

    Multimap<PCollectionNode, StageOrTransform> pcollectionProducers = getProducers(pipeline, stages,
            unfusedTransforms);
    Multimap<StageOrTransform, PCollectionNode> requiresNewOutput = HashMultimap.create();
    // Create a synthetic PCollection for each of these nodes. The transforms in the runner
    // portion of the graph that creates them should be replaced in the result components. The
    // ExecutableStage must also be rewritten to have updated outputs and transforms.
    for (Map.Entry<PCollectionNode, Collection<StageOrTransform>> collectionProducer : pcollectionProducers
            .asMap().entrySet()) {
        if (collectionProducer.getValue().size() > 1) {
            for (StageOrTransform producer : collectionProducer.getValue()) {
                requiresNewOutput.put(producer, collectionProducer.getKey());
            }
        }
    }

    Map<ExecutableStage, ExecutableStage> updatedStages = new LinkedHashMap<>();
    Map<String, PTransformNode> updatedTransforms = new LinkedHashMap<>();
    Multimap<String, PCollectionNode> originalToPartial = HashMultimap.create();
    for (Map.Entry<StageOrTransform, Collection<PCollectionNode>> deduplicationTargets : requiresNewOutput
            .asMap().entrySet()) {
        if (deduplicationTargets.getKey().getStage() != null) {
            StageDeduplication deduplication = deduplicatePCollections(deduplicationTargets.getKey().getStage(),
                    deduplicationTargets.getValue(), unzippedComponents::containsPcollections);
            for (Entry<String, PCollectionNode> originalToPartialReplacement : deduplication
                    .getOriginalToPartialPCollections().entrySet()) {
                originalToPartial.put(originalToPartialReplacement.getKey(),
                        originalToPartialReplacement.getValue());
                unzippedComponents.putPcollections(originalToPartialReplacement.getValue().getId(),
                        originalToPartialReplacement.getValue().getPCollection());
            }
            updatedStages.put(deduplicationTargets.getKey().getStage(), deduplication.getUpdatedStage());
        } else if (deduplicationTargets.getKey().getTransform() != null) {
            PTransformDeduplication deduplication = deduplicatePCollections(
                    deduplicationTargets.getKey().getTransform(), deduplicationTargets.getValue(),
                    unzippedComponents::containsPcollections);
            for (Entry<String, PCollectionNode> originalToPartialReplacement : deduplication
                    .getOriginalToPartialPCollections().entrySet()) {
                originalToPartial.put(originalToPartialReplacement.getKey(),
                        originalToPartialReplacement.getValue());
                unzippedComponents.putPcollections(originalToPartialReplacement.getValue().getId(),
                        originalToPartialReplacement.getValue().getPCollection());
            }
            updatedTransforms.put(deduplicationTargets.getKey().getTransform().getId(),
                    deduplication.getUpdatedTransform());
        } else {
            throw new IllegalStateException(
                    String.format("%s with no %s or %s", StageOrTransform.class.getSimpleName(),
                            ExecutableStage.class.getSimpleName(), PTransformNode.class.getSimpleName()));
        }
    }

    Set<PTransformNode> introducedFlattens = new LinkedHashSet<>();
    for (Map.Entry<String, Collection<PCollectionNode>> partialFlattenTargets : originalToPartial.asMap()
            .entrySet()) {
        String flattenId = SyntheticComponents.uniqueId("unzipped_flatten",
                unzippedComponents::containsTransforms);
        PTransform flattenPartialPCollections = createFlattenOfPartials(flattenId,
                partialFlattenTargets.getKey(), partialFlattenTargets.getValue());
        unzippedComponents.putTransforms(flattenId, flattenPartialPCollections);
        introducedFlattens.add(PipelineNode.pTransform(flattenId, flattenPartialPCollections));
    }

    Components components = unzippedComponents.build();
    return DeduplicationResult.of(components, introducedFlattens, updatedStages, updatedTransforms);
}