Example usage for com.google.common.collect ListMultimap get

List of usage examples for com.google.common.collect ListMultimap get

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. ListMultimap
  6. get

Introduction

In this page you can find the example usage for com.google.common.collect ListMultimap get.

Prototype

@Override
List<V> get(@Nullable K key);

Source Link

Document

Because the values for a given key may have duplicates and follow the insertion ordering, this method returns a List , instead of the java.util.Collection specified in the Multimap interface.

Usage

From source file:com.google.gerrit.server.change.GetBlame.java

private List<BlameInfo> blame(ObjectId id, String path, Repository repository, RevWalk revWalk)
        throws IOException {
    ListMultimap<BlameInfo, RangeInfo> ranges = MultimapBuilder.hashKeys().arrayListValues().build();
    List<BlameInfo> result = new ArrayList<>();
    if (blameCache.findLastCommit(repository, id, path) == null) {
        return result;
    }// w ww  . jav  a2  s  .c  o  m

    List<Region> blameRegions = blameCache.get(repository, id, path);
    int from = 1;
    for (Region region : blameRegions) {
        RevCommit commit = revWalk.parseCommit(region.getSourceCommit());
        BlameInfo blameInfo = toBlameInfo(commit, region.getSourceAuthor());
        ranges.put(blameInfo, new RangeInfo(from, from + region.getCount() - 1));
        from += region.getCount();
    }

    for (BlameInfo key : ranges.keySet()) {
        key.ranges = ranges.get(key);
        result.add(key);
    }
    return result;
}

From source file:eu.trentorise.game.managers.DroolsEngine.java

private List<LevelInstance> newGainedLevels(Game game, PlayerState state, List<PlayerLevel> levels) {

    List<PlayerLevel> oldLevels = state.getLevels();
    ListMultimap<String, String> levelProgression = ArrayListMultimap.create();

    List<LevelInstance> levelsGainedInGameAction = new ArrayList<>();
    oldLevels.forEach(level -> levelProgression.put(level.getLevelName(), level.getLevelValue()));
    levels.forEach(level -> levelProgression.put(level.getLevelName(), level.getLevelValue()));

    levelProgression.keySet().forEach(levelName -> {
        List<String> instanceProgression = levelProgression.get(levelName);
        // same level after game action
        if (instanceProgression.get(0).equals(instanceProgression.get(1))) {
            // do nothing
        } else {/*from   w ww. ja  v a  2s.co  m*/
            List<LevelInstance> levelInstances = gainedLevels(
                    new LevelInstance(levelName, instanceProgression.get(1)), game);
            int indexOfNewLevel = levelInstances.size() - 1;
            int indexOfPreviousLevel = levelInstances
                    .indexOf(new LevelInstance(levelName, instanceProgression.get(0))) + 1;
            for (int i = indexOfPreviousLevel; i <= indexOfNewLevel; i++) {
                levelsGainedInGameAction.add(levelInstances.get(i));
            }
        }
    });

    return levelsGainedInGameAction;
}

From source file:com.querydsl.jpa.sql.AbstractJPASQLQuery.java

private Query createQuery(boolean forCount) {
    NativeSQLSerializer serializer = (NativeSQLSerializer) serialize(forCount);
    String queryString = serializer.toString();
    logQuery(queryString, serializer.getConstantToLabel());
    Expression<?> projection = queryMixin.getMetadata().getProjection();
    Query query;/*from  w  w w . ja  v a 2  s  .co m*/

    if (!FactoryExpression.class.isAssignableFrom(projection.getClass()) && isEntityExpression(projection)) {
        if (queryHandler.createNativeQueryTyped()) {
            query = entityManager.createNativeQuery(queryString, projection.getType());
        } else {
            query = entityManager.createNativeQuery(queryString);
        }

    } else {
        query = entityManager.createNativeQuery(queryString);
    }
    if (!forCount) {
        ListMultimap<Expression<?>, String> aliases = serializer.getAliases();
        Set<String> used = Sets.newHashSet();
        if (projection instanceof FactoryExpression) {
            for (Expression<?> expr : ((FactoryExpression<?>) projection).getArgs()) {
                if (isEntityExpression(expr)) {
                    queryHandler.addEntity(query, extractEntityExpression(expr).toString(), expr.getType());
                } else if (aliases.containsKey(expr)) {
                    for (String scalar : aliases.get(expr)) {
                        if (!used.contains(scalar)) {
                            queryHandler.addScalar(query, scalar, expr.getType());
                            used.add(scalar);
                            break;
                        }

                    }
                }
            }
        } else if (isEntityExpression(projection)) {
            queryHandler.addEntity(query, extractEntityExpression(projection).toString(), projection.getType());
        } else if (aliases.containsKey(projection)) {
            for (String scalar : aliases.get(projection)) {
                if (!used.contains(scalar)) {
                    queryHandler.addScalar(query, scalar, projection.getType());
                    used.add(scalar);
                    break;
                }
            }
        }
    }

    if (lockMode != null) {
        query.setLockMode(lockMode);
    }
    if (flushMode != null) {
        query.setFlushMode(flushMode);
    }

    for (Map.Entry<String, Object> entry : hints.entries()) {
        query.setHint(entry.getKey(), entry.getValue());
    }

    // set constants
    JPAUtil.setConstants(query, serializer.getConstantToLabel(), queryMixin.getMetadata().getParams());
    this.projection = null; // necessary when query is reused

    if (projection instanceof FactoryExpression) {
        if (!queryHandler.transform(query, (FactoryExpression<?>) projection)) {
            this.projection = (FactoryExpression<?>) projection;
        }
    }

    return query;
}

From source file:eu.esdihumboldt.cst.functions.core.merge.IndexMergeHandler.java

private IndexMergeConfig createMergeConfiguration(ListMultimap<String, ParameterValue> transformationParameters)
        throws TransformationException {
    if (transformationParameters == null) {
        throw new TransformationException("Transformation parameters invalid");
    }/*from  ww w.  j a v  a 2 s .c o m*/

    List<List<QName>> properties = MergeUtil.getProperties(transformationParameters, PARAMETER_PROPERTY);

    List<List<QName>> additionalProperties = MergeUtil.getProperties(transformationParameters,
            PARAMETER_ADDITIONAL_PROPERTY);

    boolean autoDetect;
    if (transformationParameters.get(PARAMETER_AUTO_DETECT).isEmpty()) {
        // default to false (original behavior)
        autoDetect = false;
    } else {
        autoDetect = Boolean
                .parseBoolean(transformationParameters.get(PARAMETER_AUTO_DETECT).get(0).as(String.class));
    }

    return new IndexMergeConfig(properties, additionalProperties, autoDetect);
}

From source file:eu.esdihumboldt.cst.functions.geometric.NetworkExpansion.java

/**
 * @see AbstractSingleTargetScriptedPropertyTransformation#evaluate(String,
 *      TransformationEngine, ListMultimap, String,
 *      PropertyEntityDefinition, Map, TransformationLog)
 */// w w  w . jav a  2  s.  c om
@Override
protected Object evaluate(String transformationIdentifier, TransformationEngine engine,
        ListMultimap<String, PropertyValue> variables, String resultName,
        PropertyEntityDefinition resultProperty, Map<String, String> executionParameters, TransformationLog log)
        throws TransformationException, NoResultException {
    // get the buffer width parameter
    String bufferWidthString = getTransformedParameterChecked(PARAMETER_BUFFER_WIDTH).as(String.class);

    double bufferWidth;
    try {
        bufferWidth = Double.parseDouble(bufferWidthString);
    } catch (NumberFormatException e) {
        // For backwards compatibility try to run the string as script.
        MathScript mathScript = new MathScript();
        try {
            Object result = mathScript.evaluate(bufferWidthString, variables.get(ENTITY_VARIABLE),
                    getExecutionContext());
            bufferWidth = ConversionUtil.getAs(result, Double.class);
        } catch (ScriptException e1) {
            throw new TransformationException("Failed to evaluate buffer width expression.", e1);
        } catch (ConversionException e2) {
            throw new TransformationException("Failed to convert buffer width expression result to double.",
                    e2);
        }
    }

    // get input geometry
    PropertyValue input = variables.get(null).get(0);
    Object inputValue = input.getValue();
    if (inputValue instanceof Instance) {
        inputValue = ((Instance) inputValue).getValue();
    }

    GeometryProperty<Geometry> result = calculateBuffer(inputValue, bufferWidth, log);

    // try to yield a result compatible to the target
    if (result != null) {
        TypeDefinition targetType = resultProperty.getDefinition().getPropertyType();
        // TODO check element type?
        Class<?> binding = targetType.getConstraint(Binding.class).getBinding();
        if (Geometry.class.isAssignableFrom(binding)
                && binding.isAssignableFrom(result.getGeometry().getClass())) {
            return result.getGeometry();
        } else {
            return result;
        }
    }

    throw new TransformationException("Geometry for network expansion could not be retrieved.");
}

From source file:eu.esdihumboldt.hale.common.align.model.functions.explanations.ClassificationMappingExplanation.java

@Override
public String getExplanationAsHtml(Cell cell, ServiceProvider provider, Locale locale) {
    Entity target = CellUtil.getFirstEntity(cell.getTarget());
    Entity source = CellUtil.getFirstEntity(cell.getSource());

    LookupTable lookup = ClassificationMappingUtil.getClassificationLookup(cell.getTransformationParameters(),
            provider);/*from  w w w  .j a v  a  2 s.com*/
    ListMultimap<Value, Value> revLookup = lookup.reverse();
    String notClassifiedAction = CellUtil.getFirstParameter(cell, PARAMETER_NOT_CLASSIFIED_ACTION)
            .as(String.class);

    if (target != null && source != null) {
        StringBuilder mappingString = new StringBuilder();
        mappingString.append("<table border=\"1\"><tr><th>");
        mappingString.append(getMessage("captionSource", locale));
        mappingString.append("</th><th>");
        mappingString.append(getMessage("captionTarget", locale));
        mappingString.append("</th></tr>");
        for (Value targetValue : revLookup.keySet()) {
            mappingString.append("<tr><td>");

            int i = 1;
            for (Value sourceValue : revLookup.get(targetValue)) {
                if (i != 1) {
                    mappingString.append(", ");
                }
                mappingString.append(quoteText(sourceValue.as(String.class), true));
                i++;
            }
            mappingString.append("</td><td>");

            mappingString.append(quoteText(targetValue.as(String.class), true));

            mappingString.append("</td></tr>");
        }
        mappingString.append("</table>");
        String notClassifiedResult = "null";
        if (USE_SOURCE_ACTION.equals(notClassifiedAction))
            notClassifiedResult = getMessage("useSource", locale);
        else if (notClassifiedAction != null && notClassifiedAction.startsWith(USE_FIXED_VALUE_ACTION_PREFIX))
            notClassifiedResult = quoteText(notClassifiedAction.substring(notClassifiedAction.indexOf(':') + 1),
                    true);
        // otherwise it's null or USE_NULL_ACTION

        return MessageFormat
                .format(getMessage("main", locale), formatEntity(target, true, true, locale),
                        formatEntity(source, true, true, locale), mappingString.toString(), notClassifiedResult)
                .replaceAll("\n", "<br />");
    }

    return null;
}

From source file:org.terasology.engine.ComponentSystemManager.java

public void loadSystems(ModuleEnvironment environment, NetworkMode netMode) {
    DisplayDevice displayDevice = CoreRegistry.get(DisplayDevice.class);
    boolean isHeadless = displayDevice.isHeadless();

    ListMultimap<Name, Class<?>> systemsByModule = ArrayListMultimap.create();
    for (Class<?> type : environment.getTypesAnnotatedWith(RegisterSystem.class)) {
        if (!ComponentSystem.class.isAssignableFrom(type)) {
            logger.error("Cannot load {}, must be a subclass of ComponentSystem", type.getSimpleName());
            continue;
        }// w ww  . j a va  2s . c  o m
        Name moduleId = environment.getModuleProviding(type);
        RegisterSystem registerInfo = type.getAnnotation(RegisterSystem.class);
        if (registerInfo.value().isValidFor(netMode, isHeadless)) {
            systemsByModule.put(moduleId, type);
        }
    }

    for (Module module : environment.getModulesOrderedByDependencies()) {
        for (Class<?> system : systemsByModule.get(module.getId())) {
            String id = module.getId() + ":" + system.getSimpleName();
            logger.debug("Registering system {}", id);
            try {
                ComponentSystem newSystem = (ComponentSystem) system.newInstance();
                InjectionHelper.share(newSystem);
                register(newSystem, id);
                logger.debug("Loaded system {}", id);
            } catch (InstantiationException | IllegalAccessException e) {
                logger.error("Failed to load system {}", id, e);
            }
        }
    }
}

From source file:fi.aluesarjat.prototype.SearchServiceImpl.java

private SearchResults getAvailableDatasetValues(ListMultimap<UID, UID> facetRestrictions, RDFConnection conn) {
    SearchResults result = new SearchResults();

    List<Predicate> filters = new ArrayList<Predicate>();

    filters.add(dataset.has(STAT.datasetDimension, dimension));

    Set<UID> excludedDimensionTypes = Sets.newLinkedHashSet();
    Set<UID> includedDimensions = Sets.newLinkedHashSet();

    int dimensionRestrictionCount = 0;
    for (UID facet : facetRestrictions.keySet()) {
        List<UID> values = facetRestrictions.get(facet);
        if (facet.equals(SCV.Dataset)) {
            filters.add(dataset.in(values));
        } else {//from ww  w  .ja v a  2s .  co  m
            excludedDimensionTypes.add(facet);
            includedDimensions.addAll(values);
            filters.addAll(equalsIn(dataset, STAT.datasetDimension, values, "dimensionRestriction",
                    ++dimensionRestrictionCount));
        }
    }

    if (!excludedDimensionTypes.isEmpty()) {
        filters.add(dimension.a(dimensionType));
        filters.add(dimensionType.notIn(excludedDimensionTypes).or(dimension.in(includedDimensions)));
    }

    // DIMENSIONS
    RDFQuery query = new RDFQueryImpl(conn).where(filters.toArray(new Predicate[filters.size()])).distinct();

    CloseableIterator<Map<String, NODE>> iter = query.select(dimension);
    try {
        Map<String, NODE> row;
        while (iter.hasNext()) {
            row = iter.next();
            result.addAvailableValue((UID) row.get(dimension.getName()));
        }
    } finally {
        iter.close();
    }

    // DATASETS
    query = new RDFQueryImpl(conn).where(filters.toArray(new Predicate[filters.size()])).distinct();

    iter = query.select(dataset);
    try {
        Map<String, NODE> row;
        while (iter.hasNext()) {
            row = iter.next();
            result.addAvailableValue((UID) row.get(dataset.getName()));
        }
    } finally {
        iter.close();
    }

    return result;
}

From source file:com.querydsl.jpa.hibernate.sql.AbstractHibernateSQLQuery.java

private Query createQuery(boolean forCount) {
    NativeSQLSerializer serializer = (NativeSQLSerializer) serialize(forCount);
    String queryString = serializer.toString();
    logQuery(queryString, serializer.getConstantToLabel());
    org.hibernate.SQLQuery query = session.createSQLQuery(queryString);
    // set constants
    HibernateUtil.setConstants(query, serializer.getConstantToLabel(), queryMixin.getMetadata().getParams());

    if (!forCount) {
        ListMultimap<Expression<?>, String> aliases = serializer.getAliases();
        Set<String> used = Sets.newHashSet();
        // set entity paths
        Expression<?> projection = queryMixin.getMetadata().getProjection();
        if (projection instanceof FactoryExpression) {
            for (Expression<?> expr : ((FactoryExpression<?>) projection).getArgs()) {
                if (isEntityExpression(expr)) {
                    query.addEntity(extractEntityExpression(expr).toString(), expr.getType());
                } else if (aliases.containsKey(expr)) {
                    for (String scalar : aliases.get(expr)) {
                        if (!used.contains(scalar)) {
                            query.addScalar(scalar);
                            used.add(scalar);
                            break;
                        }//from   www .  j  a va  2 s .  c o m
                    }
                }
            }
        } else if (isEntityExpression(projection)) {
            query.addEntity(extractEntityExpression(projection).toString(), projection.getType());
        } else if (aliases.containsKey(projection)) {
            for (String scalar : aliases.get(projection)) {
                if (!used.contains(scalar)) {
                    query.addScalar(scalar);
                    used.add(scalar);
                    break;
                }
            }
        }

        // set result transformer, if projection is a FactoryExpression instance
        if (projection instanceof FactoryExpression) {
            query.setResultTransformer(new FactoryExpressionTransformer((FactoryExpression<?>) projection));
        }
    }

    if (fetchSize > 0) {
        query.setFetchSize(fetchSize);
    }
    if (timeout > 0) {
        query.setTimeout(timeout);
    }
    if (cacheable != null) {
        query.setCacheable(cacheable);
    }
    if (cacheRegion != null) {
        query.setCacheRegion(cacheRegion);
    }
    if (readOnly != null) {
        query.setReadOnly(readOnly);
    }
    return query;
}

From source file:org.sonar.server.dashboard.ws.DashboardsShowAction.java

@Override
public void handle(Request request, Response response) throws Exception {
    DbSession dbSession = dbClient.openSession(false);
    try {//from  w  w w.  jav a 2  s.com
        Integer userId = UserSession.get().userId();
        DashboardDto dashboard = dbClient.dashboardDao().getAllowedByKey(dbSession,
                request.mandatoryParamAsLong(PARAM_KEY), userId != null ? userId.longValue() : null);
        if (dashboard == null) {
            throw new NotFoundException();
        }

        JsonWriter json = response.newJsonWriter();
        json.beginObject();
        json.prop("key", dashboard.getKey());
        json.prop("name", dashboard.getName());
        json.prop("layout", dashboard.getColumnLayout());
        json.prop("desc", dashboard.getDescription());
        json.prop("global", dashboard.getGlobal());
        json.prop("shared", dashboard.getShared());
        if (dashboard.getUserId() != null) {
            UserDto user = dbClient.userDao().getUser(dashboard.getUserId());
            if (user != null) {
                json.name("owner").beginObject();
                // TODO to be shared and extracted from here
                json.prop("login", user.getLogin());
                json.prop("name", user.getName());
                json.endObject();
            }
        }
        // load widgets and related properties
        json.name("widgets").beginArray();
        Collection<WidgetDto> widgets = dbClient.widgetDao().findByDashboard(dbSession, dashboard.getKey());
        ListMultimap<Long, WidgetPropertyDto> propertiesByWidget = WidgetPropertyDto
                .groupByWidgetId(dbClient.widgetPropertyDao().findByDashboard(dbSession, dashboard.getKey()));
        for (WidgetDto widget : widgets) {
            json.beginObject();
            json.prop("id", widget.getId());
            json.prop("key", widget.getWidgetKey());
            json.prop("name", widget.getName());
            json.prop("desc", widget.getDescription());
            json.prop("col", widget.getColumnIndex());
            json.prop("row", widget.getRowIndex());
            json.prop("configured", widget.getConfigured());
            json.prop("componentId", widget.getResourceId());
            json.name("props").beginArray();
            for (WidgetPropertyDto prop : propertiesByWidget.get(widget.getKey())) {
                json.beginObject();
                json.prop("key", prop.getPropertyKey());
                json.prop("val", prop.getTextValue());
                json.endObject();
            }
            json.endArray().endObject();
        }

        json.endArray();
        json.endObject();
        json.close();
    } finally {
        dbSession.close();
    }
}