Java ImmutableMap.containsKey方法代码示例

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
private ImmutableMap<String, String> extractLdpathNamespaces(Swagger swagger) {
  Map<String, Object> extensions = swagger.getVendorExtensions();
  ImmutableMap<String, Object> vendorExtensions =
      extensions == null ? ImmutableMap.of() : ImmutableMap.copyOf(extensions);
  if (vendorExtensions.containsKey(OpenApiSpecificationExtensions.LDPATH_NAMESPACES)) {
    Object ldPathNamespaces =
        vendorExtensions.get(OpenApiSpecificationExtensions.LDPATH_NAMESPACES);
    try {
      return ImmutableMap.copyOf((Map<String, String>) ldPathNamespaces);
    } catch (ClassCastException cce) {
      throw new LdPathExecutorRuntimeException(String.format(
          "Vendor extension '%s' should contain a map of namespaces (eg. "
              + "{ \"rdfs\": \"http://www.w3.org/2000/01/rdf-schema#\", "
              + "\"rdf\": \"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"})",
          OpenApiSpecificationExtensions.LDPATH_NAMESPACES), cce);
    }
  }
  return ImmutableMap.of();
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
ResponsesAndLinking fromResponses(final ImmutableSet<Response> originalResponses,
    final ImmutableMap<Response, DocLevelEventArg> responseToDocLevelEventArg,
    final ResponseLinking responseLinking) {
  final DocLevelArgLinking.Builder linkingBuilder = new DocLevelArgLinking.Builder()
      .docID(responseLinking.docID());
  for (final ResponseSet rs : responseLinking.responseSets()) {
    final ScoringEventFrame.Builder eventFrameBuilder = new ScoringEventFrame.Builder();
    boolean addedArg = false;
    for (final Response response : rs) {
      if (responseToDocLevelEventArg.containsKey(response)) {
        eventFrameBuilder.addArguments(responseToDocLevelEventArg.get(response));
        addedArg = true;
      }
    }
    if (addedArg) {
      linkingBuilder.addEventFrames(eventFrameBuilder.build());
    }
  }
  return ResponsesAndLinking.of(responseToDocLevelEventArg.values(), linkingBuilder.build());
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
/**
 * Perform the merging and return the result.
 *
 * @return an instance of {@link com.android.manifmerger.MergingReport} that will give
 * access to all the logging and merging records.
 *
 * This method can be invoked several time and will re-do the file merges.
 *
 * @throws MergeFailureException if the merging
 * cannot be completed successfully.
 */
public MergingReport merge() throws MergeFailureException {

    // provide some free placeholders values.
    ImmutableMap<SystemProperty, Object> systemProperties = mSystemProperties.build();
    if (systemProperties.containsKey(SystemProperty.PACKAGE)) {
        mPlaceholders.put(PACKAGE_NAME, systemProperties.get(SystemProperty.PACKAGE));
        mPlaceholders.put(APPLICATION_ID, systemProperties.get(SystemProperty.PACKAGE));
    }

    ManifestMerger2 manifestMerger =
            new ManifestMerger2(
                    mLogger,
                    mMainManifestFile,
                    mLibraryFilesBuilder.build(),
                    mFlavorsAndBuildTypeFiles.build(),
                    mFeaturesBuilder.build(),
                    mPlaceholders.build(),
                    new MapBasedKeyBasedValueResolver<SystemProperty>(systemProperties),
                    mMergeType,
                    Optional.fromNullable(mReportFile));
    return manifestMerger.merge();
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
public static RecipeSource routed(final ImmutableMap<Identifier, RecipeSource> routes, final RecipeSource otherwise) {
    Preconditions.checkNotNull(routes);
    Preconditions.checkNotNull(otherwise);
    return new RecipeSource() {

        public Process<Event, Recipe> fetch (final RecipeIdentifier identifier) {
            if (identifier.source.isPresent()) {
                if (routes.containsKey(identifier.source.get())) {
                    return routes.get(identifier.source.get()).fetch(identifier);
                }
                return Process.error(new DependencyResolutionException(
                    "Could not fetch " + identifier.encode() + " because " + identifier.source.get() + " is not routed. "));
            }
            return otherwise.fetch(identifier);
        }

        public Iterable<RecipeIdentifier> findCandidates(PartialRecipeIdentifier partial) {
            if (partial.source.isPresent()) {
                if (routes.containsKey(partial.source.get())) {
                    return routes.get(partial.source.get()).findCandidates(partial);
                }
            }
            return otherwise.findCandidates(partial);
        }
    };
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
/**
 * Sets the liquid in the model.
 * fluid - Name of the fluid in the FluidRegistry
 * flipGas - If "true" the model will be flipped upside down if the liquid is a gas. If "false" it wont
 * <p/>
 * If the fluid can't be found, water is used
 */
@Override
public ModelDynBucket process(ImmutableMap<String, String> customData)
{
    String fluidName = customData.get("fluid");
    Fluid fluid = FluidRegistry.getFluid(fluidName);

    if (fluid == null) fluid = this.fluid;

    boolean flip = flipGas;
    if (customData.containsKey("flipGas"))
    {
        String flipStr = customData.get("flipGas");
        if (flipStr.equals("true")) flip = true;
        else if (flipStr.equals("false")) flip = false;
        else
            throw new IllegalArgumentException(String.format("DynBucket custom data \"flipGas\" must have value \'true\' or \'false\' (was \'%s\')", flipStr));
    }

    // create new model with correct liquid
    return new ModelDynBucket(baseLocation, liquidLocation, coverLocation, fluid, flip);
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
public MultiLayerBakedModel(ImmutableMap<Optional<BlockRenderLayer>, IBakedModel> models, IBakedModel missing, ImmutableMap<TransformType, TRSRTransformation> cameraTransforms)
{
    this.models = models;
    this.cameraTransforms = cameraTransforms;
    this.missing = missing;
    if(models.containsKey(Optional.absent()))
    {
        base = models.get(Optional.absent());
    }
    else
    {
        base = missing;
    }
    ImmutableMap.Builder<Optional<EnumFacing>, ImmutableList<BakedQuad>> quadBuilder = ImmutableMap.builder();
    quadBuilder.put(Optional.<EnumFacing>absent(), buildQuads(models, Optional.<EnumFacing>absent()));
    for(EnumFacing side: EnumFacing.values())
    {
        quadBuilder.put(Optional.of(side), buildQuads(models, Optional.of(side)));
    }
    quads = quadBuilder.build();
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
public ItemLayerModel retexture(ImmutableMap<String, String> textures)
{
    ImmutableList.Builder<ResourceLocation> builder = ImmutableList.builder();
    for(int i = 0; i < textures.size() + this.textures.size(); i++)
    {
        if(textures.containsKey("layer" + i))
        {
            builder.add(new ResourceLocation(textures.get("layer" + i)));
        }
        else if(i < this.textures.size())
        {
            builder.add(this.textures.get(i));
        }
    }
    return new ItemLayerModel(builder.build(), overrides);
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
@Override
public ModelWrapper retexture(ImmutableMap<String, String> textures)
{
    ImmutableMap.Builder<String, ResourceLocation> builder = ImmutableMap.builder();
    for(Map.Entry<String, ResourceLocation> e : this.textures.entrySet())
    {
        String path = e.getKey();
        String loc = getLocation(path);
        if(textures.containsKey(loc))
        {
            String newLoc = textures.get(loc);
            if(newLoc == null) newLoc = getLocation(path);
            builder.put(e.getKey(), new ResourceLocation(newLoc));
        }
        else
        {
            builder.put(e);
        }
    }
    return new ModelWrapper(modelLocation, model, meshes, smooth, gui3d, defaultKey, builder.build());
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
/**
 * Takes this AnswerKey as ground truth, and takes unannotated or assessed Responses in fallback
 * and adds them to the AnswerKey.
 *
 * If the CAS for an AssessedResponse is known, prefer that CAS to the CAS in fallback.
 *
 * Does not handle the case where the fallback AnswerKey has an Assessment that this AnswerKey
 * does not.
 */
public AnswerKey copyFallingBackTo(AnswerKey fallback) {
  final Builder ret = modifiedCopyBuilder();

  final ImmutableMap<String, Response> unannotatedHere = Maps.uniqueIndex(unannotatedResponses(),
      ResponseFunctions.uniqueIdentifier());
  final ImmutableMap<String, AssessedResponse> idToAssessedHere =
      Maps.uniqueIndex(annotatedResponses(),
          Functions.compose(ResponseFunctions.uniqueIdentifier(),
              AssessedResponseFunctions.response()));
  final Set<String> idsHere = Sets.union(unannotatedHere.keySet(), idToAssessedHere.keySet());

  final ImmutableMap<String, Response> unannotatedThere = Maps.uniqueIndex(
      fallback.unannotatedResponses(), ResponseFunctions.uniqueIdentifier());
  final ImmutableMap<String, AssessedResponse> idToAssessedThere =
      Maps.uniqueIndex(fallback.annotatedResponses(),
          Functions.compose(ResponseFunctions.uniqueIdentifier(),
              AssessedResponseFunctions.response()));
  final Set<String> idsThere = Sets.union(unannotatedThere.keySet(), idToAssessedThere.keySet());

  final Set<String> idsOnlyInFallback = Sets.difference(idsThere, idsHere);
  for (final String id : idsOnlyInFallback) {
    if (unannotatedThere.containsKey(id)) {
      ret.addUnannotated(unannotatedThere.get(id));
    }
    if (idToAssessedThere.containsKey(id)) {
      final AssessedResponse r = idToAssessedThere.get(id);
      final int CASGroup;
      if (corefAnnotation().CASesToIDs().containsKey(r.response().canonicalArgument())) {
        CASGroup = corefAnnotation().CASesToIDs().get(r.response().canonicalArgument());
      } else {
        CASGroup = fallback.corefAnnotation().CASesToIDs().get(r.response().canonicalArgument());
      }
      ret.addAnnotated(r, CASGroup);
    }
  }
  return ret.build();
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
static void immutableMapStuff() {
  ImmutableMap m = ImmutableMap.of();
  Object res = m.get(new Object());
  // BUG: Diagnostic contains: dereferenced expression
  res.toString();
  Object x = new Object();
  if (m.containsKey(x)) {
    m.get(x).toString();
  }
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
@Override
public ModelFluid process(ImmutableMap<String, String> customData)
{
    if(!customData.containsKey("fluid")) return this;

    String fluidStr = customData.get("fluid");
    JsonElement e = new JsonParser().parse(fluidStr);
    String fluid = e.getAsString();
    if(!FluidRegistry.isFluidRegistered(fluid))
    {
        FMLLog.severe("fluid '%s' not found", fluid);
        return WATER;
    }
    return new ModelFluid(FluidRegistry.getFluid(fluid));
}
 

import com.google.common.collect.ImmutableMap; //导入方法依赖的package包/类
private MethodSpec generateConstructorFromParcel(
            ProcessingEnvironment env,
            ImmutableList<Property> properties,
            ImmutableMap<TypeMirror, FieldSpec> typeAdapters) {

        // Create the PRIVATE constructor from Parcel
        MethodSpec.Builder builder = MethodSpec.constructorBuilder()
                .addModifiers(PRIVATE)      // private
                .addParameter(ClassName.bestGuess("android.os.Parcel"), "in"); // input param

        // get a code block builder
        CodeBlock.Builder block = CodeBlock.builder();

//        // First thing is reading the Parcelable object version
//        block.add("this.version = in.readInt();\n");

        // Now, iterate all properties, check the version initialize them
        for (Property p : properties) {

//            // get the property version
//            int pVersion = p.version();
//            if (pVersion > 0) {
//                block.beginControlFlow("if (this.version >= $L)", pVersion);
//            }

            block.add("this.$N = ", p.fieldName);

            if (p.typeAdapter != null && typeAdapters.containsKey(p.typeAdapter)) {
                Parcelables.readValueWithTypeAdapter(block, p, typeAdapters.get(p.typeAdapter));
            } else {
                TypeName parcelableType = Parcelables.getTypeNameFromProperty(p, env.getTypeUtils());
                if (parcelableType == null) {
                    mErrorReporter.abortWithError("could not create parcelable for type " + p.typeName, p.element);
                }
                Parcelables.readValue(block, p, parcelableType);
            }

            block.add(";\n");

//            if (pVersion > 0) {
//                block.endControlFlow();
//            }
        }

        builder.addCode(block.build());

        return builder.build();
    }