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

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

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

Introduction

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

Prototype

V get(Object key);

Source Link

Document

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

Usage

From source file:com.isotrol.impe3.pms.core.impl.PortalConfigurationManagerImpl.java

private void setValues(ConfigurationDefinition<?> cd, ConfigurationEntity entity,
        Collection<ConfigurationItemDTO> configuration) throws PMSException {
    checkNotNull(configuration);//from   ww w.  j  av  a2  s  .c  o  m
    checkArgument(!configuration.isEmpty() || cd.getMBPParameters().isEmpty());
    final Map<String, ConfigurationValue> values = entity.getValues();
    values.clear();
    final ImmutableMap<String, Item> parameters = cd.getParameters();
    for (final ConfigurationItemDTO itemDTO : configuration) {
        final String name = itemDTO.getKey();
        checkNotNull(name);
        checkArgument(!values.containsKey(name));
        checkArgument(parameters.containsKey(name));
        final Item item = parameters.get(name);
        final String value = itemDTO.getCurrentValue();
        if (value == null) {
            if (item.isMVP()) {
                logger.error("Configuration [{}] type [{}]: Required item [{}].",
                        new Object[] { entity.getId().toString(), cd.getType().getName(), name });
                throw new IllegalArgumentException(); // TODO
            }
            continue;
        }
        final ConfigurationValue configValue = new ConfigurationValue();
        final Class<?> type = item.getType();
        if (item.isEnum()) {
            configValue.setStringValue(((Enum<?>) item.fromString(value)).name());
        } else if (String.class == type) {
            configValue.setStringValue(value);
        } else if (Integer.class == type) {
            configValue.setIntegerValue(Integer.valueOf(value));
        } else if (FileId.class == type) {
            FileEntity file = load(FileEntity.class, value, NotFoundProviders.FILE);
            if (file.getPurpose() == FilePurpose.UNKNOWN) {
                file.setPurpose(FilePurpose.CONFIG);
            }
            NotFoundProviders.FILE.checkCondition(file.getPurpose() == FilePurpose.CONFIG, value);
            if (item.isCompressed()) {
                file.compress();
            }
            file.setBundle(item.isBundle());
            file.setDownloadable(item.isDownloadable());
            configValue.setFileValue(file);
        } else if (Category.class == type) {
            configValue.setCategoryValue(load(CategoryEntity.class, value, NotFoundProviders.CATEGORY));
        } else if (ContentType.class == type) {
            configValue
                    .setContentTypeValue(load(ContentTypeEntity.class, value, NotFoundProviders.CONTENT_TYPE));
        } else if (Boolean.class == type) {
            configValue.setBooleanValue(Boolean.valueOf(value));
        } else {
            logger.error("Configuration [{}] type [{}] item [{}] Invalid type.",
                    new Object[] { entity.getId().toString(), cd.getType().getName(), name });
            // TODO: other types.
            throw new IllegalStateException();
        }
        values.put(name, configValue);
    }
    for (final Item item : parameters.values()) {
        checkState(!item.isMVP() || values.containsKey(item.getParameter()));
    }
}

From source file:com.isotrol.impe3.pms.core.impl.ConfigurationManagerImpl.java

private void setValues(PortalConfigurationDefinition<?> cd, ConfigurationEntity entity,
        Collection<ConfigurationItemDTO> configuration) throws PMSException {
    checkNotNull(configuration);//from   ww w.  j  a va 2s  . c  o m
    checkArgument(!configuration.isEmpty() || cd.getMBPParameters().isEmpty());
    final Map<String, ConfigurationValue> values = entity.getValues();
    values.clear();
    final ImmutableMap<String, Item> parameters = cd.getParameters();
    for (final ConfigurationItemDTO itemDTO : configuration) {
        final String name = itemDTO.getKey();
        checkNotNull(name);
        checkArgument(!values.containsKey(name));
        checkArgument(parameters.containsKey(name));
        final Item item = parameters.get(name);
        final String value = itemDTO.getCurrentValue();
        if (value == null) {
            if (item.isMVP()) {
                logger.error("Configuration [{}] type [{}]: Required item [{}].",
                        new Object[] { entity.getId().toString(), cd.getType().getName(), name });
                throw new IllegalArgumentException(); // TODO
            }
            continue;
        }
        final ConfigurationValue configValue = new ConfigurationValue();
        final Class<?> type = item.getType();
        if (item.isEnum()) {
            configValue.setStringValue(((Enum<?>) item.fromString(value)).name());
        } else if (String.class == type) {
            configValue.setStringValue(value);
        } else if (Integer.class == type) {
            configValue.setIntegerValue(Integer.valueOf(value));
        } else if (FileId.class == type) {
            FileEntity file = load(FileEntity.class, value, NotFoundProviders.FILE);
            if (file.getPurpose() == FilePurpose.UNKNOWN) {
                file.setPurpose(FilePurpose.CONFIG);
            }
            NotFoundProviders.FILE.checkCondition(file.getPurpose() == FilePurpose.CONFIG, value);
            if (item.isCompressed()) {
                file.compress();
            }
            file.setBundle(item.isBundle());
            file.setDownloadable(item.isDownloadable());
            configValue.setFileValue(file);
        } else if (Category.class == type) {
            configValue.setCategoryValue(load(CategoryEntity.class, value, NotFoundProviders.CATEGORY));
        } else if (ContentType.class == type) {
            configValue
                    .setContentTypeValue(load(ContentTypeEntity.class, value, NotFoundProviders.CONTENT_TYPE));
        } else if (Boolean.class == type) {
            configValue.setBooleanValue(Boolean.valueOf(value));
        } else {
            logger.error("Configuration [{}] type [{}] item [{}] Invalid type.",
                    new Object[] { entity.getId().toString(), cd.getType().getName(), name });
            // TODO: other types.
            throw new IllegalStateException();
        }
        values.put(name, configValue);
    }
    for (final Item item : parameters.values()) {
        checkState(!item.isMVP() || values.containsKey(item.getParameter()));
    }
}

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

@Override
Optional<TypeSpec.Builder> write(ClassName generatedTypeName, ProductionBinding binding) {
    checkArgument(binding.bindingElement().isPresent());

    TypeName providedTypeName = TypeName.get(binding.contributedType());
    TypeName futureTypeName = listenableFutureOf(providedTypeName);

    TypeSpec.Builder factoryBuilder = classBuilder(generatedTypeName).addModifiers(PUBLIC, FINAL)
            .superclass(abstractProducerOf(providedTypeName));

    UniqueNameSet uniqueFieldNames = new UniqueNameSet();
    ImmutableMap.Builder<BindingKey, FieldSpec> fieldsBuilder = ImmutableMap.builder();

    MethodSpec.Builder constructorBuilder = constructorBuilder().addModifiers(PUBLIC);

    Optional<FieldSpec> moduleField = binding.requiresModuleInstance()
            ? Optional.of(addFieldAndConstructorParameter(factoryBuilder, constructorBuilder,
                    uniqueFieldNames.getUniqueName("module"),
                    TypeName.get(binding.bindingTypeElement().get().asType())))
            : Optional.empty();/*from www .ja v  a2s . c  om*/

    for (Map.Entry<BindingKey, FrameworkField> entry : generateBindingFieldsForDependencies(binding)
            .entrySet()) {
        BindingKey bindingKey = entry.getKey();
        FrameworkField bindingField = entry.getValue();
        FieldSpec field = addFieldAndConstructorParameter(factoryBuilder, constructorBuilder,
                uniqueFieldNames.getUniqueName(bindingField.name()), bindingField.type());
        fieldsBuilder.put(bindingKey, field);
    }
    ImmutableMap<BindingKey, FieldSpec> fields = fieldsBuilder.build();

    constructorBuilder.addStatement("super($N, $L)", fields.get(binding.monitorRequest().get().bindingKey()),
            producerTokenConstruction(generatedTypeName, binding));

    if (binding.requiresModuleInstance()) {
        assignField(constructorBuilder, moduleField.get());
    }

    for (FieldSpec field : fields.values()) {
        assignField(constructorBuilder, field);
    }

    MethodSpec.Builder computeMethodBuilder = methodBuilder("compute").returns(futureTypeName)
            .addAnnotation(Override.class).addModifiers(PROTECTED);

    ImmutableList<DependencyRequest> asyncDependencies = asyncDependencies(binding);
    for (DependencyRequest dependency : asyncDependencies) {
        TypeName futureType = listenableFutureOf(asyncDependencyType(dependency));
        CodeBlock futureAccess = CodeBlock.of("$N.get()", fields.get(dependency.bindingKey()));
        computeMethodBuilder.addStatement("$T $L = $L", futureType, dependencyFutureName(dependency),
                dependency.kind().equals(DependencyRequest.Kind.PRODUCED)
                        ? CodeBlock.of("$T.createFutureProduced($L)", PRODUCERS, futureAccess)
                        : futureAccess);
    }
    FutureTransform futureTransform = FutureTransform.create(fields, binding, asyncDependencies);

    computeMethodBuilder.addStatement("return $T.transformAsync($L, this, this)", FUTURES,
            futureTransform.futureCodeBlock());

    factoryBuilder
            .addSuperinterface(
                    ParameterizedTypeName.get(ASYNC_FUNCTION, futureTransform.applyArgType(), providedTypeName))
            .addSuperinterface(EXECUTOR);

    MethodSpec.Builder applyMethodBuilder = methodBuilder("apply").returns(futureTypeName)
            .addJavadoc("@deprecated this may only be called from the internal {@link #compute()}")
            .addAnnotation(Deprecated.class).addAnnotation(Override.class).addModifiers(PUBLIC)
            .addParameter(futureTransform.applyArgType(), futureTransform.applyArgName())
            .addExceptions(getThrownTypeNames(binding.thrownTypes()))
            .addStatement("assert monitor != null : $S",
                    "apply() may only be called internally from compute(); "
                            + "if it's called explicitly, the monitor might be null")
            .addCode(getInvocationCodeBlock(generatedTypeName, binding, providedTypeName,
                    futureTransform.parameterCodeBlocks()));
    if (futureTransform.hasUncheckedCast()) {
        applyMethodBuilder.addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED));
    }

    MethodSpec.Builder executeMethodBuilder = methodBuilder("execute").addModifiers(PUBLIC)
            .addJavadoc("@deprecated this may only be called from the internal {@link #compute()}")
            .addAnnotation(Deprecated.class).addAnnotation(Override.class).addParameter(RUNNABLE, "runnable")
            .addStatement("assert monitor != null : $S",
                    "execute() may only be called internally from compute(); "
                            + "if it's called explicitly, the monitor might be null")
            .addStatement("monitor.ready()").addStatement("executorProvider.get().execute(runnable)");

    factoryBuilder.addMethod(constructorBuilder.build());
    factoryBuilder.addMethod(computeMethodBuilder.build());
    factoryBuilder.addMethod(applyMethodBuilder.build());
    factoryBuilder.addMethod(executeMethodBuilder.build());

    gwtIncompatibleAnnotation(binding).ifPresent(factoryBuilder::addAnnotation);

    // TODO(gak): write a sensible toString
    return Optional.of(factoryBuilder);
}

From source file:com.facebook.buck.maven.Pom.java

private void updateModel(Artifact mavenCoordinates, Iterable<Artifact> deps) {
    model.setGroupId(mavenCoordinates.getGroupId());
    model.setArtifactId(mavenCoordinates.getArtifactId());
    model.setVersion(mavenCoordinates.getVersion());
    if (Strings.isNullOrEmpty(model.getName())) {
        model.setName(mavenCoordinates.getArtifactId()); // better than nothing
    }//from w  w  w  .ja v a  2  s  .c o  m

    // Dependencies
    ImmutableMap<DepKey, Dependency> depIndex = Maps.uniqueIndex(getModel().getDependencies(), DepKey::new);
    for (Artifact artifactDep : deps) {
        DepKey key = new DepKey(artifactDep);
        Dependency dependency = depIndex.get(key);
        if (dependency == null) {
            dependency = key.createDependency();
            getModel().addDependency(dependency);
        }
        updateDependency(dependency, artifactDep);
    }
}

From source file:com.srotya.flume.kinesis.sink.KinesisSink.java

@Override
public void configure(Context ctx) {
    ImmutableMap<String, String> props = ctx.getSubProperties(Constants.SETTINGS);
    if (!props.containsKey(Constants.ACCESS_KEY) || !props.containsKey(Constants.ACCESS_SECRET)) {
        Throwables.propagate(//from w ww  .ja v a2s  .c  o  m
                new InvalidArgumentException("Must provide AWS credentials i.e. accessKey and accessSecret"));
    }
    awsCredentials = new BasicAWSCredentials(props.get(Constants.ACCESS_KEY),
            props.get(Constants.ACCESS_SECRET));
    clientConfig = new ClientConfiguration();
    if (props.containsKey(Constants.PROXY_HOST)) {
        clientConfig.setProxyHost(props.get(Constants.PROXY_HOST));
        clientConfig.setProxyPort(Integer.parseInt(props.getOrDefault(Constants.PROXY_PORT, "80")));
        clientConfig.setProtocol(Protocol.valueOf(props.getOrDefault(Constants.PROTOCOL, "HTTPS")));
    }
    if (!props.containsKey(Constants.STREAM_NAME)) {
        Throwables.propagate(new InvalidArgumentException("Must provide Kinesis stream name"));
    }
    streamName = props.get(Constants.STREAM_NAME);
    putSize = Integer.parseInt(props.getOrDefault(Constants.PUT_SIZE, "100"));
    if (putSize > 500) {
        Throwables.propagate(
                new InvalidArgumentException("AWS Kinesis doesn't allow more than 500 put requests"));
    }
    endpoint = props.getOrDefault(Constants.ENDPOINT, Constants.DEFAULT_ENDPOINT);
    String serializerClass = props.getOrDefault(Constants.SERIALIZER, GsonSerializer.class.getName());
    try {
        serializer = (KinesisSerializer) Class.forName(serializerClass).newInstance();
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
        Throwables.propagate(e);
    }
    serializer.configure(props);
}

From source file:com.facebook.buck.java.intellij.IjModuleGraph.java

public ImmutableMap<IjModule, DependencyType> getDependentModulesFor(IjModule source) {
    final ImmutableMap<IjProjectElement, DependencyType> deps = getDepsFor(source);
    return FluentIterable.from(deps.keySet()).filter(IjModule.class)
            .toMap(new Function<IjModule, DependencyType>() {
                @Override//from  w w  w .j a  v a 2  s.co m
                public DependencyType apply(IjModule input) {
                    return Preconditions.checkNotNull(deps.get(input));
                }
            });
}

From source file:com.facebook.buck.java.intellij.IjModuleGraph.java

public ImmutableMap<IjLibrary, DependencyType> getDependentLibrariesFor(IjModule source) {
    final ImmutableMap<IjProjectElement, DependencyType> deps = getDepsFor(source);
    return FluentIterable.from(deps.keySet()).filter(IjLibrary.class)
            .toMap(new Function<IjLibrary, DependencyType>() {
                @Override//  ww w. ja  v a  2 s .c om
                public DependencyType apply(IjLibrary input) {
                    return Preconditions.checkNotNull(deps.get(input));
                }
            });
}

From source file:com.sk89q.worldguard.domains.DefaultDomain.java

private Component toPlayersComponent(ProfileCache cache) {
    List<String> uuids = Lists.newArrayList();
    Map<String, UUID> profileMap = Maps.newHashMap();

    for (String name : playerDomain.getPlayers()) {
        profileMap.put(name, null);/*from w w w  . j av a  2s .  com*/
    }

    if (cache != null) {
        ImmutableMap<UUID, Profile> results = cache.getAllPresent(playerDomain.getUniqueIds());
        for (UUID uuid : playerDomain.getUniqueIds()) {
            Profile profile = results.get(uuid);
            if (profile != null) {
                profileMap.put(profile.getName(), uuid);
            } else {
                uuids.add(uuid.toString());
            }
        }
    } else {
        for (UUID uuid : playerDomain.getUniqueIds()) {
            uuids.add(uuid.toString());
        }
    }

    final TextComponent.Builder builder = TextComponent.builder("");
    final Iterator<TextComponent> profiles = profileMap.keySet().stream().sorted().map(name -> {
        final UUID uuid = profileMap.get(name);
        final TextComponent component = TextComponent.of(name, TextColor.YELLOW)
                .hoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
                        uuid == null ? TextComponent.of("Name only", TextColor.GRAY)
                                : TextComponent.of("Last known name of uuid: ", TextColor.GRAY)
                                        .append(TextComponent.of(uuid.toString(), TextColor.WHITE))));
        if (uuid == null) {
            return component;
        }
        return component.clickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, uuid.toString()));
    }).iterator();
    while (profiles.hasNext()) {
        builder.append(profiles.next());
        if (profiles.hasNext() || !uuids.isEmpty()) {
            builder.append(TextComponent.of(", "));
        }
    }

    if (!uuids.isEmpty()) {
        builder.append(TextComponent
                .of(uuids.size() + " unknown uuid" + (uuids.size() == 1 ? "" : "s"), TextColor.GRAY)
                .hoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
                        TextComponent.of(String.join("\n", uuids))
                                .append(Component.newline().append(TextComponent.of("Click to select")))))
                .clickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, String.join(",", uuids))));
    }

    return builder.build();
}

From source file:springfox.documentation.builders.OperationBuilder.java

private Set<ResponseMessage> mergeResponseMessages(Set<ResponseMessage> responseMessages) {
    //Add logic to consolidate the response messages
    ImmutableMap<Integer, ResponseMessage> responsesByCode = Maps.uniqueIndex(this.responseMessages,
            byStatusCode());/*from  ww  w  .j  a  va2s .  com*/
    Set<ResponseMessage> merged = newHashSet(this.responseMessages);
    for (ResponseMessage each : responseMessages) {
        if (responsesByCode.containsKey(each.getCode())) {
            ResponseMessage responseMessage = responsesByCode.get(each.getCode());
            String message = defaultIfAbsent(emptyToNull(each.getMessage()), responseMessage.getMessage());
            ModelReference responseWithModel = defaultIfAbsent(each.getResponseModel(),
                    responseMessage.getResponseModel());
            merged.remove(responseMessage);
            merged.add(new ResponseMessageBuilder().code(each.getCode()).message(message)
                    .responseModel(responseWithModel).headersWithDescription(each.getHeaders()).build());
        } else {
            merged.add(each);
        }
    }
    return merged;
}

From source file:de.metas.ui.web.view.SqlViewFactory.java

private SqlViewCustomizer getSqlViewCustomizer(@NonNull final WindowId windowId,
        final ViewProfileId profileId) {
    if (ViewProfileId.isNull(profileId)) {
        return null;
    }//w w  w .  ja  v  a  2s .c om

    final ImmutableMap<ViewProfileId, SqlViewCustomizer> viewCustomizersByProfileId = viewCustomizers
            .get(windowId);
    if (viewCustomizersByProfileId == null) {
        return null;
    }

    return viewCustomizersByProfileId.get(profileId);
}