@Override public boolean isValidPackageVersion(final Namespace namespace, final StructuredVersion version) { return validPageVersions.containsEntry(namespace, version); }
/** * {@inheritDoc} */ @Override public boolean containsListener(Listener listener, Enum<?> eventType) { return listeners.containsEntry(eventType, listener); }
@Override public boolean isValidPackageVersion(final Namespace namespace, final StructuredVersion version) { return validPageVersions.containsEntry(namespace, version); }
/** * Returns true iff the given sentence is in this set of sentences. */ public boolean containsSentence(SentenceForm form, GdlSentence sentence) { return sentences.containsEntry(form, sentence); }
/** * {@inheritDoc} */ @Override public boolean containsListener(Listener listener, Enum<?> eventType) { return listeners.containsEntry(eventType, listener); }
public static <K, V> SetMultimap<K, V> listToSetMultimap(List<Pair<K, V>> list) { SetMultimap<K, V> result = HashMultimap.create(); for (Pair<K, V> p : list) { Preconditions.checkArgument(!result.containsEntry(p.lhSide, p.rhSide)); result.put(p.lhSide, p.rhSide); } return result; }
public boolean addMessageBundle(ClassLoader classLoader, String bundleName, Locale locale) { SetMultimap<String, Locale> classLoadersLocales = this.loadedBundles.getOrDefault(classLoader, HashMultimap.create()); if(!classLoadersLocales.containsEntry(bundleName, locale)) { if(this.localeManager.addMessageBundle(classLoader, bundleName, locale)) { classLoadersLocales.put(bundleName, locale); this.loadedBundles.put(classLoader, classLoadersLocales); return true; } } return false; }
public boolean containsEntry(K key, V value) { if(guavaMultiMap != null) return guavaMultiMap.containsEntry(key, value); return hcMultiMap.containsEntry(key, value); }
@Override protected boolean isAdjustedBeforeReview(Details object) { if (object.isCheckPermissions && permissionsOverrides.containsEntry(object.subject.getClass().getName(), object.subject.getId())) { object.isCheckPermissions = false; if (LOGGER.isDebugEnabled()) { LOGGER.debug("preserving previous setting, making " + object); } return true; } else { return false; } } };
/** * Checks whether the specified node is occupied by the specified * {@link MovingRoadUser}. * @param node The node to check for occupancy. * @param user The user to check if it is occupying that location. * @return <code>true</code> if the specified node is occupied by the * specified user, <code>false</code> otherwise. * @throws IllegalArgumentException If road user is not known by this model. */ @Override public boolean isOccupiedBy(Point node, MovingRoadUser user) { checkExists(user); return occupiedNodes.containsEntry(user, node); }
@Nullable @Override public String findMatchingMethod(@NonNull String klass, @NonNull String method) { // Common case: if (mMembers.containsEntry(klass, method)) { return method; } String methodToLookFor = klass + "." + getMemberId(method); if (mMembers.containsEntry(klass, methodToLookFor)) { return methodToLookFor; } else { return null; } }
@Override public boolean evaluate(StructureLevelData object) { return bottomLevels.containsEntry(object.getHierarchy(), object.getLevel()); }
@Override public void beforeNode(Object obj, DescriptorPath path) { Preconditions.checkState(!refsStack.containsKey(path)); SetMultimap<ReferenceType, String> refs = getRelatedPaths(obj, path); SetMultimap<ReferenceType, String> newRefs = LinkedHashMultimap.create(); for (Map.Entry<ReferenceType, Collection<String>> entry : refs.asMap().entrySet()) { ReferenceType type = entry.getKey(); for (String reference : entry.getValue()) { if (!allowedRefs.containsEntry(type, reference)) { newRefs.put(type, reference); allowedRefs.put(type, reference); } } } // consolidate into the singleton if it's empty newRefs = newRefs.size() == 0 ? ImmutableSetMultimap .<ReferenceType, String> of() : newRefs; refsStack.put(path, newRefs); callReferenceConstraints(obj, path); }
@Override public void checkDependencies(ShrinkerLogger shrinkerLogger) { Map<String, Dependency<String>> invalidDeps = Maps.newHashMap(); for (Map.Entry<String, Dependency<String>> entry : mDependencies.entries()) { String source = entry.getKey(); Dependency<String> dep = entry.getValue(); String target = dep.target; if (!target.contains(".")) { if (!mClasses.containsKey(target)) { // We don't warn about by-name references in strings. if (dep.type != DependencyType.REQUIRED_CODE_REFERENCE_REFLECTION) { shrinkerLogger.invalidClassReference(source, target); invalidDeps.put(source, entry.getValue()); } } } else { if (!mMembers.containsEntry(getOwnerClass(target), target)) { shrinkerLogger.invalidMemberReference(source, target); invalidDeps.put(source, entry.getValue()); } } } for (Map.Entry<String, Dependency<String>> entry : invalidDeps.entrySet()) { mDependencies.remove(entry.getKey(), entry.getValue()); } }
if (listeners.containsEntry(eventType, listener)) { removeListener(listener, eventType);
if (listeners.containsEntry(eventType, listener)) { removeListener(listener, eventType);
if (!stopWatch.isRunning() && !servicesByState.containsEntry(NEW, service) && !(service instanceof NoOpService)) { loadTimes.add(Maps.immutableEntry(service, stopWatch.elapsed(MILLISECONDS)));
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) { RelDataTypeFamily castFrom = call.getOperandType(0).getFamily(); RelDataTypeFamily castTo = call.getOperandType(1).getFamily(); if (castFrom instanceof SqlTypeFamily && castTo instanceof SqlTypeFamily && nonMonotonicCasts.containsEntry(castFrom, castTo)) { return SqlMonotonicity.NOT_MONOTONIC; } else { return call.getOperandMonotonicity(0); } } }
@Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) { RelDataTypeFamily castFrom = call.getOperandType(0).getFamily(); RelDataTypeFamily castTo = call.getOperandType(1).getFamily(); if (castFrom instanceof SqlTypeFamily && castTo instanceof SqlTypeFamily && nonMonotonicCasts.containsEntry(castFrom, castTo)) { return SqlMonotonicity.NOT_MONOTONIC; } else { return call.getOperandMonotonicity(0); } } }
@Test public void removeTest() { final EventDispatcher disp = new EventDispatcher(EventTypes.values()); final EventAPI eventAPI = disp.getPublicEventAPI(); assertTrue(disp.listeners.isEmpty()); eventAPI.addListener(l1, EVENT1, EVENT2, EVENT3); assertEquals(3, disp.listeners.size()); assertTrue(disp.listeners.containsEntry(EVENT1, l1)); assertTrue(eventAPI.containsListener(l1, EVENT1)); assertTrue(eventAPI.containsListener(l1, EVENT2)); assertTrue(eventAPI.containsListener(l1, EVENT3)); eventAPI.removeListener(l1); assertTrue(disp.listeners.isEmpty()); assertFalse(eventAPI.containsListener(l1, EVENT1)); assertFalse(eventAPI.containsListener(l1, EVENT2)); assertFalse(eventAPI.containsListener(l1, EVENT3)); }