Java Code Examples for com.google.common.collect.SetMultimap#containsKey()

/** Builds ConditionalEdges from given graph. */
public ConditionalEdges(Digraph<Target> graph) {
  this.map = new HashMap<>();

  for (Node<Target> node : graph.getNodes()) {
    Rule rule = node.getLabel().getAssociatedRule();
    if (rule == null) {
      // rule is null for source files and package groups. Skip them.
      continue;
    }

    SetMultimap<Label, Label> conditions = getAllConditions(rule, RawAttributeMapper.of(rule));
    if (conditions.isEmpty()) {
      // bail early for most common case of no conditions in the rule.
      continue;
    }

    Label nodeLabel = node.getLabel().getLabel();
    for (Node<Target> succ : node.getSuccessors()) {
      Label successorLabel = succ.getLabel().getLabel();
      if (conditions.containsKey(successorLabel)) {
        insert(nodeLabel, successorLabel, conditions.get(successorLabel));
      }
    }
  }
}
 

/**
 * Removes an entity listener for a entity of the given class
 *
 * @param entityListener entity listener for a entity
 * @return boolean
 */
public boolean removeEntityListener(String repoFullName, EntityListener entityListener) {
  lock.writeLock().lock();
  try {
    verifyRepoRegistered(repoFullName);
    SetMultimap<Object, EntityListener> entityListeners =
        this.entityListenersByRepo.get(repoFullName);
    if (entityListeners.containsKey(entityListener.getEntityId())) {
      entityListeners.remove(entityListener.getEntityId(), entityListener);
      return true;
    }
    return false;
  } finally {
    lock.writeLock().unlock();
  }
}
 

private Set<QConfigServer> serversInPriority(String room, SetMultimap<String, QConfigServer> roomServerMap) {
    if (roomServerMap.containsKey(room)) {
        return roomServerMap.get(room);
    } else if (roomServerMap.containsKey(serverStore.defaultRoom())) {
        return roomServerMap.get(serverStore.defaultRoom());
    } else {
        return ImmutableSet.copyOf(roomServerMap.asMap().entrySet().iterator().next().getValue());
    }
}
 

@Override
public AndroidManifest merge(SetMultimap<BundleModuleName, AndroidManifest> manifests) {
  if (!manifests.containsKey(BASE_MODULE_NAME)) {
    throw CommandExecutionException.builder()
        .withInternalMessage("Expected to have base module.")
        .build();
  }
  return merge(ensureOneManifestPerModule(manifests));
}
 

private static void buildPluginNames(SetMultimap<String, Class<?>> info, Properties properties) {

    for (String name : properties.stringPropertyNames()) {

      List<Class<?>> classList = classList(name, properties.getProperty(name));
      if (info.containsKey(name)) {

        throw new GenerationException("duplicate name in plugins: " + name);
      }
      info.putAll(name, classList);
    }
  }
 

private static boolean satisfiesRequirement(
    SetMultimap<String, String> provisions, String requirement, String value) {
  if (requirement.equals("min-cores")) {
    if (!provisions.containsKey("cores")) {
      return false;
    }
    int mincores = Integer.parseInt(value);
    int cores = Integer.parseInt(Iterables.getOnlyElement(provisions.get("cores")));
    return cores >= mincores;
  }
  if (requirement.equals("max-cores")) {
    return true;
  }
  return provisions.containsEntry(requirement, value);
}
 

private void updatePositions(Node anchored) {
	SetMultimap<Node, AnchorKey> keys = getKeysByNode();
	if (keys.containsKey(anchored)) {
		Set<AnchorKey> keysCopy = new HashSet<>(keys.get(anchored));
		for (AnchorKey key : keysCopy) {
			updatePosition(key);
		}
	}
}
 

/** Does this baggage contain anything for the specified key?
 * 
 * @param namespace The namespace the key resides in
 * @param key The key to look up
 * @return true if the baggage has one or more value for this namespace and key */
public boolean contains(ByteString namespace, ByteString key) {
    if (namespace != null && key != null) {
        SetMultimap<ByteString, ByteString> namespaceData = contents.get(namespace);
        return namespaceData != null && namespaceData.containsKey(key);
    }
    return false;
}
 

public boolean tryPushdownClosedVar(Logger logger, Block top,
    ExecContext topContext, StackLite<Continuation> ancestors, Block curr,
    ExecContext currContext, SetMultimap<Var, InstOrCont> waitMap,
    ArrayList<Continuation> pushedDown, ListIterator<Statement> it,
    Var v) {
  boolean changed = false;
  if (waitMap.containsKey(v)) {
    Pair<Boolean, Set<Continuation>> pdRes =
        relocateDependentInstructions(logger, top, topContext, ancestors,
                                  curr, currContext, it,  waitMap, v);
    changed = pdRes.val1;
    pushedDown.addAll(pdRes.val2);
  }
  return changed;
}
 

@Override
public boolean containsKey(Object key) {
	final SetMultimap<K, V> setMultimap = get();
	return (setMultimap == null) ? EMPTY_SETMULTIMAP.containsKey(key)
			: setMultimap.containsKey(key);
}