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

List of usage examples for com.google.common.collect Multimaps index

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Multimaps
  6. 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.siemens.sw360.datahandler.common.SW360Utils.java

private static ImmutableMap<Integer, Collection<ReleaseLink>> getDepthMap(List<ReleaseLink> linkedReleases) {
    return Multimaps.index(linkedReleases, new Function<ReleaseLink, Integer>() {
        @Override//  ww w. j  a v a2 s.  c o  m
        public Integer apply(ReleaseLink input) {
            return input.getDepth();
        }
    }).asMap();
}

From source file:com.esri.android.ecologicalmarineunitexplorer.data.DataManager.java

/**
 * Process the listenable future by creating a WaterColumn for
 * any returned data./*from ww  w .j a  va2 s .  c o m*/
 * @param envelope - an Envelope representing the search area
 * @param futureResult - a ListenableFuture<FeatureQueryResult> to process
 * @param callback  - a SummaryCallback called when query processing is complete
 * @return - a WaterColumn representing returned features.
 */
private void processQueryForEMuAtLocation(final Envelope envelope,
        final ListenableFuture<FeatureQueryResult> futureResult, final ServiceApi.SummaryCallback callback) {

    futureResult.addDoneListener(new Runnable() {
        @Override
        public void run() {
            try {
                Log.i("ProcessQuery", "Query done...");
                FeatureQueryResult fqr = futureResult.get();

                Map<Geometry, WaterColumn> pointWaterColumnMap = new HashMap<Geometry, WaterColumn>();

                if (fqr != null) {
                    Log.i("ProcessQuery", "Processing features...");

                    List<EMUObservation> emuObservations = new ArrayList<EMUObservation>();
                    final Iterator<Feature> iterator = fqr.iterator();
                    while (iterator.hasNext()) {
                        Feature feature = iterator.next();
                        Geometry geometry = feature.getGeometry();
                        Map<String, Object> map = feature.getAttributes();
                        EMUObservation observation = createEMUObservation(map);
                        emuObservations.add(createEMUObservation(map));
                    }
                    // Now we have a list with zero or more EMUObservations
                    // 1.  Create a map of WaterColumn keyed on location
                    // 2.  Determine the closest WaterColumn to the envelope.

                    ImmutableSet<EMUObservation> immutableSet = ImmutableSet.copyOf(emuObservations);
                    Function<EMUObservation, Point> locationFunction = new Function<EMUObservation, Point>() {
                        @Nullable
                        @Override
                        public Point apply(EMUObservation observation) {
                            return observation.getLocation();
                        }
                    };
                    ImmutableListMultimap<Point, EMUObservation> observationsByLocation = Multimaps
                            .index(immutableSet, locationFunction);
                    ImmutableMap<Point, Collection<EMUObservation>> map = observationsByLocation.asMap();
                    Set<Point> keys = map.keySet();
                    Iterator<Point> pointIterator = keys.iterator();
                    while (pointIterator.hasNext()) {
                        Point p = pointIterator.next();
                        WaterColumn waterColumn = new WaterColumn();
                        waterColumn.setLocation(p);
                        ;
                        Collection<EMUObservation> observations = map.get(p);
                        for (EMUObservation o : observations) {
                            waterColumn.addObservation(o);
                        }
                        pointWaterColumnMap.put(p, waterColumn);
                    }
                }

                // If there is more than one water column, we only care about the
                // one closest to the point clicked in the map.
                WaterColumn closestWaterColumn = findClosestWaterColumn(envelope, pointWaterColumnMap);

                // Processing is complete, notify the callback
                callback.onWaterColumnsLoaded(closestWaterColumn);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

From source file:io.druid.indexing.common.TaskToolbox.java

public void pushSegments(Iterable<DataSegment> segments) throws IOException {
    // Request segment pushes for each set
    final Multimap<Interval, DataSegment> segmentMultimap = Multimaps.index(segments,
            new Function<DataSegment, Interval>() {
                @Override// ww  w.  j  a v a 2  s .com
                public Interval apply(DataSegment segment) {
                    return segment.getInterval();
                }
            });
    for (final Collection<DataSegment> segmentCollection : segmentMultimap.asMap().values()) {
        getTaskActionClient().submit(new SegmentInsertAction(ImmutableSet.copyOf(segmentCollection)));
    }

}

From source file:org.onos.yangtools.yang.model.util.FilteringSchemaContextProxy.java

private Multimap<String, Module> getStringModuleMap(SchemaContext delegate) {
    return Multimaps.index(delegate.getModules(), new Function<Module, String>() {
        @Override/* w ww .j a  v  a2 s.c om*/
        public String apply(Module input) {
            return input.getName();
        }
    });
}

From source file:com.b2international.snowowl.snomed.importer.rf2.refset.SnomedLanguageRefSetImporter.java

@Override
protected void attach(Collection<SnomedLanguageRefSetMember> componentsToAttach) {
    final Multimap<String, SnomedLanguageRefSetMember> membersByReferencedComponent = Multimaps
            .index(componentsToAttach, SnomedRefSetMember::getReferencedComponentId);
    final Collection<Component> components = getComponents(membersByReferencedComponent.keySet());
    for (Component component : components) {
        if (component instanceof Description) {
            final Collection<SnomedLanguageRefSetMember> newDescriptionMembers = membersByReferencedComponent
                    .get(component.getId());
            ((Description) component).getLanguageRefSetMembers().addAll(newDescriptionMembers);
        }/*from ww  w  .j  a  v  a2s .co m*/
    }
}

From source file:dagger.internal.codegen.MapMultibindingValidator.java

private static ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding> indexByMapKeyAnnotationType(
        ImmutableSet<ContributionBinding> contributions) {
    return ImmutableSetMultimap.copyOf(Multimaps.index(contributions, mapBinding -> MoreTypes.equivalence()
            .wrap(mapBinding.mapKeyAnnotation().get().getAnnotationType())));
}

From source file:com.facebook.presto.raptor.storage.organization.ShardOrganizerUtil.java

public static Collection<Collection<ShardIndexInfo>> getShardsByDaysBuckets(Table tableInfo,
        Collection<ShardIndexInfo> shards) {
    // Neither bucketed nor temporal, no partitioning required
    if (!tableInfo.getBucketCount().isPresent() && !tableInfo.getTemporalColumnId().isPresent()) {
        return ImmutableList.of(shards);
    }//  w ww .  j  a  v  a 2s . c o m

    // if only bucketed, partition by bucket number
    if (tableInfo.getBucketCount().isPresent() && !tableInfo.getTemporalColumnId().isPresent()) {
        return Multimaps.index(shards, shard -> shard.getBucketNumber().getAsInt()).asMap().values();
    }

    // if temporal, partition into days first
    ImmutableMultimap.Builder<Long, ShardIndexInfo> shardsByDaysBuilder = ImmutableMultimap.builder();
    shards.stream().filter(shard -> shard.getTemporalRange().isPresent()).forEach(shard -> {
        long day = determineDay(shard.getTemporalRange().get());
        shardsByDaysBuilder.put(day, shard);
    });

    Collection<Collection<ShardIndexInfo>> byDays = shardsByDaysBuilder.build().asMap().values();

    // if table is bucketed further partition by bucket number
    if (!tableInfo.getBucketCount().isPresent()) {
        return byDays;
    }

    ImmutableList.Builder<Collection<ShardIndexInfo>> sets = ImmutableList.builder();
    for (Collection<ShardIndexInfo> s : byDays) {
        sets.addAll(Multimaps.index(s, ShardIndexInfo::getBucketNumber).asMap().values());
    }
    return sets.build();
}

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

FactoryMethodDescriptor generateDescriptorForConstructor(final AutoFactoryDeclaration declaration,
        ExecutableElement constructor) {
    checkNotNull(constructor);/*from   www .j av a 2s  .  co m*/
    checkArgument(constructor.getKind() == ElementKind.CONSTRUCTOR);
    Element classElement = constructor.getEnclosingElement();
    Name returnType = classElement.accept(new ElementKindVisitor6<Name, Void>() {
        @Override
        protected Name defaultAction(Element e, Void p) {
            throw new AssertionError();
        }

        @Override
        public Name visitTypeAsClass(TypeElement e, Void p) {
            if (!e.getTypeParameters().isEmpty()) {
                messager.printMessage(ERROR, "AutoFactory does not support generic types", e);
            }
            return e.getQualifiedName();
        }
    }, null);
    ImmutableListMultimap<Boolean, ? extends VariableElement> parameterMap = Multimaps
            .index(constructor.getParameters(), Functions.forPredicate(new Predicate<VariableElement>() {
                @Override
                public boolean apply(VariableElement parameter) {
                    return parameter.getAnnotation(Provided.class) != null;
                }
            }));
    ImmutableSet<Parameter> providedParameters = Parameter.forParameterList(parameterMap.get(true));
    ImmutableSet<Parameter> passedParameters = Parameter.forParameterList(parameterMap.get(false));
    return new FactoryMethodDescriptor.Builder(declaration)
            .factoryName(declaration.getFactoryName(elements.getPackageOf(constructor).getQualifiedName(),
                    classElement.getSimpleName()))
            .name("create").returnType(returnType.toString())
            .publicMethod(constructor.getEnclosingElement().getModifiers().contains(PUBLIC))
            .providedParameters(providedParameters).passedParameters(passedParameters)
            .creationParameters(Parameter.forParameterList(constructor.getParameters())).build();
}

From source file:edu.cmu.cs.lti.ark.fn.evaluation.PrepareFullAnnotationJson.java

/**
 * Given predicted frame instances, including their frame elements, create a SemaforParseResult ready to be serialized to
 * JSON//  w  ww . j  av a 2 s. c  o  m
 *
 * @param rankedScoredRoleAssignments Lines encoding predicted frames & FEs in the same format as the .sentences.frame.elements files
 */
public static SemaforParseResult getSemaforParse(
        Collection<RankedScoredRoleAssignment> rankedScoredRoleAssignments, List<String> tokens) {
    final ArrayList<Frame> frames = Lists.newArrayList();
    // group by target span (assumes only one predicted frame per target span)
    final ImmutableListMultimap<Range0Based, RankedScoredRoleAssignment> predictionsByFrame = Multimaps
            .index(rankedScoredRoleAssignments, getTargetSpan);
    for (Range0Based targetSpan : predictionsByFrame.keySet()) {
        final List<RankedScoredRoleAssignment> predictionsForFrame = predictionsByFrame.get(targetSpan);
        final RankedScoredRoleAssignment first = predictionsForFrame.get(0);
        final NamedSpanSet target = makeSpan(first.targetSpan.start, first.targetSpan.end + 1, first.frame,
                tokens);
        final List<Frame.ScoredRoleAssignment> scoredRoleAssignments = Lists.newArrayList();
        for (RankedScoredRoleAssignment ra : predictionsForFrame) {
            // extract frame elements
            final List<FrameElementAndSpan> frameElementsAndSpans = ra.fesAndSpans;
            final List<NamedSpanSet> frameElements = Lists.newArrayList();
            for (FrameElementAndSpan frameElementAndSpan : frameElementsAndSpans) {
                final Range0Based range = frameElementAndSpan.span;
                frameElements.add(makeSpan(range.start, range.end + 1, frameElementAndSpan.name, tokens));
            }
            scoredRoleAssignments.add(new Frame.ScoredRoleAssignment(ra.rank, ra.score, frameElements));
        }
        frames.add(new Frame(target, scoredRoleAssignments));
    }
    return new SemaforParseResult(frames, tokens);
}

From source file:io.prestosql.plugin.raptor.legacy.storage.organization.ShardCompactionManager.java

private void discoverShards() {
    log.info("Discovering shards that need compaction...");
    Set<ShardMetadata> allShards = shardManager.getNodeShards(currentNodeIdentifier);
    ListMultimap<Long, ShardMetadata> tableShards = Multimaps.index(allShards, ShardMetadata::getTableId);

    for (Entry<Long, List<ShardMetadata>> entry : Multimaps.asMap(tableShards).entrySet()) {
        long tableId = entry.getKey();
        if (!metadataDao.isCompactionEligible(tableId)) {
            continue;
        }//from  w  ww  .j a v a  2s .  co m
        List<ShardMetadata> shards = entry.getValue();
        Collection<OrganizationSet> organizationSets = filterAndCreateCompactionSets(tableId, shards);
        log.info("Created %s organization set(s) for table ID %s", organizationSets.size(), tableId);

        for (OrganizationSet set : organizationSets) {
            organizer.enqueue(set);
        }
    }
}