Example usage for com.google.common.collect ImmutableMap 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:org.apache.gobblin.dataset.HiveToHdfsDatasetResolver.java

@Override
public DatasetDescriptor resolve(DatasetDescriptor raw, State state) {
    ImmutableMap<String, String> metadata = raw.getMetadata();
    Preconditions.checkArgument(metadata.containsKey(DatasetConstants.FS_SCHEME),
            String.format("Hive Dataset Descriptor must contain metadata %s to create Hdfs Dataset Descriptor",
                    DatasetConstants.FS_SCHEME));
    Preconditions.checkArgument(metadata.containsKey(DatasetConstants.FS_SCHEME),
            String.format("Hive Dataset Descriptor must contain metadata %s to create Hdfs Dataset Descriptor",
                    DatasetConstants.FS_LOCATION));
    DatasetDescriptor datasetDescriptor = new DatasetDescriptor(metadata.get(DatasetConstants.FS_SCHEME),
            metadata.get(DatasetConstants.FS_LOCATION));
    datasetDescriptor.addMetadata(HIVE_TABLE, raw.getName());
    return datasetDescriptor;
}

---

From source file:com.facebook.buck.cxx.AbstractElfRewriteDynStrSectionStep.java

/** @return a processor for the GNU version definition section. */
private Optional<SectionUsingDynamicStrings> getVerdefProcessor(Elf elf) {
    return elf.getSectionByName(VERDEF).map(ElfSectionLookupResult::getSection)
            .map(verdefSection -> new SectionUsingDynamicStrings() {

                private final ElfVerDef verdef = ElfVerDef.parse(elf.header.ei_class, verdefSection.body);

                @Override/*from  ww w .j  av a2  s  .c  om*/
                public ImmutableList<Long> getStringReferences() {
                    return RichStream.from(verdef.entries).flatMap(vd -> vd.getSecond().stream())
                            .map(vdx -> vdx.vda_name).toImmutableList();
                }

                @Override
                public void processNewStringReferences(long newSize,
                        ImmutableMap<Long, Long> newStringIndices) {
                    ElfVerDef fixedVerdef = new ElfVerDef(
                            RichStream.from(verdef.entries)
                                    .map(e -> new Pair<>(e.getFirst(), RichStream.from(e.getSecond())
                                            .map(ve -> new ElfVerDef.Verdaux(
                                                    Objects.requireNonNull(newStringIndices.get(ve.vda_name)),
                                                    ve.vda_next))
                                            .toImmutableList()))
                                    .toImmutableList());
                    verdefSection.body.rewind();
                    fixedVerdef.write(elf.header.ei_class, verdefSection.body);
                }
            });
}

---

From source file:org.killbill.billing.plugin.bitcoin.osgi.http.PaymentRequestServlet.java

private String createURL(HttpServletRequest req, String path, ImmutableMap<String, String> params) {
    final StringBuilder queryParamsBuilder = new StringBuilder("?");
    for (final String key : params.keySet()) {
        queryParamsBuilder.append(key).append("=").append(params.get(key)).append("&");
    }//ww w . j  a  v  a  2s  . c o  m

    return req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort() + path
            + queryParamsBuilder.toString();
}

---

From source file:com.lyndir.lhunath.snaplog.model.service.impl.AWSSourceServiceImpl.java

@Override
public void loadMedia(final SSecurityToken token, final S3Source source) throws PermissionDeniedException {

    checkNotNull(source, "Given source must not be null.");
    securityService.assertAccess(Permission.ADMINISTER, token, source);

    // Fetch objects at all qualities from S3
    Map<String, Map<Quality, S3Object>> mediaObjects = Maps.newHashMap();
    for (final Quality quality : Quality.values()) {

        for (final S3Object s3Object : awsService.listObjects(getObjectKey(source, quality))) {

            if (!s3Object.getKey().endsWith(".jpg"))
                // Ignore files that don't have a valid media name.
                continue;

            String mediaName = Iterables.getLast(Splitter.on('/').split(s3Object.getKey()));
            if (mediaName.startsWith("."))
                // Ignore hidden files.
                continue;

            Map<Quality, S3Object> qualityObjects = mediaObjects.get(mediaName);
            if (qualityObjects == null)
                mediaObjects.put(mediaName, qualityObjects = Maps.newHashMap());
            qualityObjects.put(quality, s3Object);
        }/* w w w .  j av  a  2  s . c  o  m*/
    }

    // Find all existing media that is not contained in the set of media fetched from S3
    // These are media that have been removed from S3 since the last sync; purge them.
    logger.dbg("Looking for media to purge...");
    ImmutableMap.Builder<String, Media> existingMediaBuilder = ImmutableMap.builder();
    for (final Media media : mediaDAO.listMedia(source, true))
        existingMediaBuilder.put(media.getName(), media);
    ImmutableMap<String, Media> existingMedia = existingMediaBuilder.build();
    Set<Media> purgeMedia = Sets.newHashSet(existingMedia.values());
    for (final String mediaName : mediaObjects.keySet()) {
        Media media = existingMedia.get(mediaName);
        if (media != null)
            // This media was found in S3's list of current media data; don't purge it.
            purgeMedia.remove(media);
    }
    logger.dbg("Purging %d / %d media from db", purgeMedia.size(), existingMedia.size());
    mediaDAO.delete(purgeMedia);

    int o = 0;
    for (final Map.Entry<String, Map<Quality, S3Object>> mediaObjectsEntry : mediaObjects.entrySet()) {
        if (o++ % 100 == 0)
            logger.dbg("Loading media %d / %d", ++o, mediaObjects.size());

        String mediaName = mediaObjectsEntry.getKey();
        Map<Quality, S3Object> qualityObjects = mediaObjectsEntry.getValue();

        S3Media media = mediaDAO.findMedia(source, mediaName);
        if (media == null)
            media = new S3Media(source, mediaName);

        // Create/update mediaData for the object.
        for (final Map.Entry<Quality, S3Object> qualityObjectsEntry : qualityObjects.entrySet()) {
            Quality quality = qualityObjectsEntry.getKey();
            S3Object mediaObject = qualityObjectsEntry.getValue();

            setMediaData(media, quality, mediaObject);
        }
    }
}

---

From source file:com.facebook.buck.rage.UserInput.java

public boolean confirm(String question) throws IOException {
    ImmutableMap<String, Boolean> supportedResponses = ImmutableMap.of("", true, "y", true, "n", false);
    for (;;) {/*from  w w  w  .ja  v a  2 s  .  c o m*/
        output.println();
        output.println(question + " (Y/n)?");
        output.flush();

        String line = reader.readLine();
        // Stdin was closed.
        if (line == null) {
            return false;
        }
        String response = line.trim().toLowerCase();
        if (supportedResponses.containsKey(response)) {
            return supportedResponses.get(response);
        } else {
            output.println("Please answer 'y' or 'n'.");
        }
    }
}

---

From source file:com.isotrol.impe3.pms.core.obj.ConfigurationObject.java

Configuration get(ImpeIAModel model) {
    checkState(!isError(), "Invalid configuration state");
    final ConfigurationBuilder<?> cb = definition.builder();
    final ImmutableMap<String, Item> parameters = definition.getParameters();
    for (Entry<String, Object> ecv : values.entrySet()) {
        final String name = ecv.getKey();
        final Class<?> type = parameters.get(name).getType();
        final Object value = ecv.getValue();
        try {/*from ww w .  j a  v a 2s.co  m*/
            if (Category.class == type) {
                cb.set(name, checkNotNull(model.getCategories().get((UUID) value)));
            } else if (ContentType.class == type) {
                cb.set(name, checkNotNull(model.getContentTypes().get((UUID) value)));
            } else {
                cb.set(name, value);
            }
        } catch (RuntimeException e) {
            Loggers.pms().error(LOG_PREFIX + "Error setting parameter [{}]", logArgs(name));
            throw e;
        }
    }
    try {
        return cb.get();
    } catch (RuntimeException e) {
        Loggers.pms().error(LOG_PREFIX + "Unable to build configuration", logArgs(null));
        throw e;
    }
}

---

From source file:org.gradle.internal.component.external.model.ivy.RealisedIvyModuleResolveMetadataSerializationHelper.java

private Map<String, ConfigurationMetadata> readIvyConfigurations(Decoder decoder,
        DefaultIvyModuleResolveMetadata metadata) throws IOException {
    Map<Artifact, ModuleComponentArtifactMetadata> artifacts = new IdentityHashMap<Artifact, ModuleComponentArtifactMetadata>();
    IvyConfigurationHelper configurationHelper = new IvyConfigurationHelper(metadata.getArtifactDefinitions(),
            artifacts, metadata.getExcludes(), metadata.getDependencies(), metadata.getId());

    ImmutableMap<String, Configuration> configurationDefinitions = metadata.getConfigurationDefinitions();

    int configurationsCount = decoder.readSmallInt();
    Map<String, ConfigurationMetadata> configurations = Maps.newHashMapWithExpectedSize(configurationsCount);
    for (int i = 0; i < configurationsCount; i++) {
        String configurationName = decoder.readString();
        Configuration configuration = configurationDefinitions.get(configurationName);
        assert configuration != null;
        ImmutableSet<String> hierarchy = LazyToRealisedModuleComponentResolveMetadataHelper
                .constructHierarchy(configuration, configurationDefinitions);
        ImmutableAttributes attributes = getAttributeContainerSerializer().read(decoder);
        ImmutableCapabilities capabilities = readCapabilities(decoder);

        RealisedConfigurationMetadata configurationMetadata = new RealisedConfigurationMetadata(
                metadata.getId(), configurationName, configuration.isTransitive(), configuration.isVisible(),
                hierarchy, configurationHelper.filterArtifacts(configurationName, hierarchy),
                configurationHelper.filterExcludes(hierarchy), attributes, capabilities);

        ImmutableList.Builder<ModuleDependencyMetadata> builder = ImmutableList.builder();
        int dependenciesCount = decoder.readSmallInt();
        for (int j = 0; j < dependenciesCount; j++) {
            byte dependencyType = decoder.readByte();
            switch (dependencyType) {
            case GRADLE_DEPENDENCY_METADATA:
                builder.add(readDependencyMetadata(decoder));
                break;
            case IVY_DEPENDENCY_METADATA:
                IvyDependencyDescriptor ivyDependency = readIvyDependency(decoder);
                ModuleDependencyMetadata dependencyMetadata = configurationHelper
                        .contextualize(configurationMetadata, metadata.getId(), ivyDependency);
                builder.add(dependencyMetadata.withReason(decoder.readNullableString()));
                break;
            case MAVEN_DEPENDENCY_METADATA:
                throw new IllegalStateException("Unexpected Maven dependency for Ivy module");
            default:
                throw new IllegalStateException("Unknown dependency type " + dependencyType);
            }/*w  ww  .  j a v a2 s .  c o m*/
        }
        ImmutableList<ModuleDependencyMetadata> dependencies = builder.build();
        configurationMetadata.setDependencies(dependencies);

        configurations.put(configurationName, configurationMetadata);
    }
    return configurations;
}

---

From source file:edu.mit.streamjit.impl.distributed.StreamJitAppManager.java

public boolean reconfigure() {
    reset();/*w w  w. j  av  a2s  .com*/
    Configuration.Builder builder = Configuration.builder(cfgManager.getDynamicConfiguration());

    Map<Token, Map.Entry<Integer, Integer>> tokenMachineMap = new HashMap<>();
    Map<Token, Integer> portIdMap = new HashMap<>();

    conInfoMap = controller.buildConInfoMap(app.partitionsMachineMap, app.source, app.sink);

    builder.putExtraData(GlobalConstants.TOKEN_MACHINE_MAP, tokenMachineMap)
            .putExtraData(GlobalConstants.PORTID_MAP, portIdMap);

    builder.putExtraData(GlobalConstants.CONINFOMAP, conInfoMap);

    Configuration cfg = builder.build();
    String jsonStirng = cfg.toJson();

    ImmutableMap<Integer, DrainData> drainDataMap = app.getDrainData();

    for (int nodeID : controller.getAllNodeIDs()) {
        ConfigurationString json = new ConfigurationString(jsonStirng, ConfigType.DYNAMIC,
                drainDataMap.get(nodeID));
        controller.send(nodeID, json);
    }

    setupHeadTail(conInfoMap, app.bufferMap, Token.createOverallInputToken(app.source),
            Token.createOverallOutputToken(app.sink));

    boolean isCompiled = apStsPro.waitForCompilation();

    if (isCompiled) {
        start();
        isRunning = true;
    } else {
        isRunning = false;
    }

    return isRunning;
}

---

From source file:paperparcel.PaperParcelWriter.java

private CodeBlock setFields(FieldSpec model, ImmutableMap<String, FieldSpec> fieldMap) {
    CodeBlock.Builder block = CodeBlock.builder();

    // Write directly
    for (FieldDescriptor field : descriptor.writableFields()) {
        if (field.isVisible()) {
            block.addStatement("$N.$N = $N", model.name, field.name(), fieldMap.get(field.name()));
        } else {/*from w w w  .j  a v  a  2  s  .  co  m*/
            // Field isn't visible, write via reflection
            TypeName enclosingClass = rawTypeFrom(field.element().getEnclosingElement().asType());
            block.addStatement("$T.writeField($N, $T.class, $N, $S)", UTILS, fieldMap.get(field.name()),
                    enclosingClass, model.name, field.name());
        }
    }

    // Write via setters
    ImmutableSet<Map.Entry<FieldDescriptor, ExecutableElement>> fieldSetterEntries = descriptor
            .setterMethodMap().entrySet();
    for (Map.Entry<FieldDescriptor, ExecutableElement> fieldSetterEntry : fieldSetterEntries) {
        Name setterName = fieldSetterEntry.getValue().getSimpleName();
        FieldDescriptor field = fieldSetterEntry.getKey();
        block.addStatement("$N.$N($N)", model.name, setterName, fieldMap.get(field.name()));
    }

    return block.build();
}

---

From source file:com.google.devtools.build.lib.skyframe.PostConfiguredTargetFunction.java

@Nullable
@Override/*from   ww  w .  j  av  a  2  s.co  m*/
public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException, InterruptedException {
    ImmutableMap<ActionAnalysisMetadata, ConflictException> badActions = PrecomputedValue.BAD_ACTIONS.get(env);
    ConfiguredTargetValue ctValue = (ConfiguredTargetValue) env
            .getValue(ConfiguredTargetValue.key((ConfiguredTargetKey) skyKey.argument()));
    if (env.valuesMissing()) {
        return null;
    }

    for (ActionAnalysisMetadata action : ctValue.getActions()) {
        if (badActions.containsKey(action)) {
            throw new ActionConflictFunctionException(badActions.get(action));
        }
    }

    ConfiguredTarget ct = ctValue.getConfiguredTarget();
    TargetAndConfiguration ctgValue = new TargetAndConfiguration(ct.getTarget(), ct.getConfiguration());

    ImmutableMap<Label, ConfigMatchingProvider> configConditions = getConfigurableAttributeConditions(ctgValue,
            env);
    if (configConditions == null) {
        return null;
    }

    OrderedSetMultimap<Attribute, Dependency> deps;
    try {
        BuildConfiguration hostConfiguration = buildViewProvider.getSkyframeBuildView()
                .getHostConfiguration(ct.getConfiguration());
        SkyframeDependencyResolver resolver = buildViewProvider.getSkyframeBuildView()
                .createDependencyResolver(env);
        // We don't track root causes here - this function is only invoked for successfully analyzed
        // targets - as long as we redo the exact same steps here as in ConfiguredTargetFunction, this
        // can never fail.
        deps = resolver.dependentNodeMap(ctgValue, hostConfiguration, /*aspect=*/ null, configConditions);
        if (ct.getConfiguration() != null && ct.getConfiguration().useDynamicConfigurations()) {
            deps = ConfiguredTargetFunction.getDynamicConfigurations(env, ctgValue, deps, hostConfiguration,
                    ruleClassProvider);
        }
    } catch (EvalException e) {
        throw new PostConfiguredTargetFunctionException(e);
    } catch (ConfiguredTargetFunction.DependencyEvaluationException e) {
        throw new PostConfiguredTargetFunctionException(e);
    } catch (InvalidConfigurationException e) {
        throw new PostConfiguredTargetFunctionException(e);
    }

    env.getValues(Iterables.transform(deps.values(), TO_KEYS));
    if (env.valuesMissing()) {
        return null;
    }

    return new PostConfiguredTargetValue(ct);
}

---

• «
• 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
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »