@Override public boolean tryReserveMemory(String allocationTag, long delta) { return tryReserveMemoryFunction.test(allocationTag, delta); } }
@Override public boolean tryReserveMemory(String allocationTag, long delta) { return tryReserveMemoryFunction.test(allocationTag, delta); } }
protected boolean bypass(Message msg, boolean up) { List<BiPredicate<Message,Boolean>> tmp=bypassers; if(tmp == null) return false; for(BiPredicate<Message,Boolean> pred: tmp) { if(pred.test(msg, up)) return true; } return false; }
private void assertEquivalent(@Nullable R expected, @Nullable R actual) { assertTrue( "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence, equivalence.test(expected, actual)); } }
public static String table(BiPredicate<Boolean, Boolean> f) { List<String> resultBuilder = new ArrayList<>(); resultBuilder.add("A B result"); for (boolean a : Arrays.asList(true, false)) { for (boolean b : Arrays.asList(true, false)) { resultBuilder.add(String.format("%-10s %-10s %s", a, b, f.test(a, b))); } } return resultBuilder.stream().collect(Collectors.joining("\n")); }
@Override public M filter(BiPredicate<? super K, ? super V> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return filter(t -> predicate.test(t._1, t._2)); }
private void configureExternalObjects(InjectionManager injectionManager) { componentBag.getInstances(model -> ComponentBag.EXTERNAL_ONLY.test(model, injectionManager)) .forEach(injectionManager::register); componentBag.getClasses(model -> ComponentBag.EXTERNAL_ONLY.test(model, injectionManager)) .forEach(injectionManager::register); }
private void configureExternalObjects(InjectionManager injectionManager) { componentBag.getInstances(model -> ComponentBag.EXTERNAL_ONLY.test(model, injectionManager)) .forEach(injectionManager::register); componentBag.getClasses(model -> ComponentBag.EXTERNAL_ONLY.test(model, injectionManager)) .forEach(injectionManager::register); }
@Override public M reject(BiPredicate<? super K, ? super V> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return reject(t -> predicate.test(t._1, t._2)); }
static <K, V, M extends Map<K, V>> M filter(M map, OfEntries<K, V, M> ofEntries, BiPredicate<? super K, ? super V> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return filter(map, ofEntries, t -> predicate.test(t._1, t._2)); }
/** * Create a realm mapper that matches when the given predicate matches. * * @param matchRule the match rule (must not be {@code null}) * @param realmName the realm name to return, or {@code null} to return the default realm * @return the realm mapper (not {@code null}) */ static RealmMapper matching(BiPredicate<? super Principal, ? super Evidence> matchRule, String realmName) { Assert.checkNotNullParam("matchRule", matchRule); return (p, e) -> matchRule.test(p, e) ? realmName : null; }
@Override public void innerClose(boolean isLeft, LeftRightEndSubscriber index) { queueBiOffer.test(isLeft ? LEFT_CLOSE : RIGHT_CLOSE, index); drain(); }
@Override public void innerValue(boolean isLeft, Object o) { queueBiOffer.test(isLeft ? LEFT_VALUE : RIGHT_VALUE, o); drain(); }
@Override public void innerValue(boolean isLeft, Object o) { queueBiOffer.test(isLeft ? LEFT_VALUE : RIGHT_VALUE, o); drain(); }
@Override public void innerClose(boolean isLeft, LeftRightEndSubscriber index) { queueBiOffer.test(isLeft ? LEFT_CLOSE : RIGHT_CLOSE, index); drain(); }
boolean removeIf(BiPredicate<? super K, ? super V> filter) { checkNotNull(filter); boolean changed = false; for (K key : keySet()) { while (true) { V value = get(key); if (value == null || !filter.test(key, value)) { break; } else if (LocalCache.this.remove(key, value)) { changed = true; break; } } } return changed; }
public <T, U> boolean runAsBiPredicate(BiPredicate<T, U> action, T param1, U param2) { final Supplier<SecurityIdentity> old = securityDomain.getAndSetCurrentSecurityIdentity(this); try { return action.test(param1, param2); } finally { securityDomain.setCurrentSecurityIdentity(old); } }
boolean removeIf(BiPredicate<? super K, ? super V> filter) { checkNotNull(filter); boolean changed = false; for (K key : keySet()) { while (true) { V value = get(key); if (value == null || !filter.test(key, value)) { break; } else if (LocalCache.this.remove(key, value)) { changed = true; break; } } } return changed; }
@Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { PathAddress address = context.getCurrentAddress(); Resource parentResource = context.readResourceFromRoot(address.getParent(), false); if (!this.present.test(parentResource, address.getLastElement())) { context.getResourceRegistration().getOperationHandler(PathAddress.EMPTY_ADDRESS, ModelDescriptionConstants.ADD).execute(context, operation); } } }
/** * Evaluate the {@code Predicate} on the method parameter type if it has the * given annotation, nesting within {@link java.util.Optional} if necessary, * but raise an {@code IllegalStateException} if the same matches the generic * type within a reactive type wrapper. */ protected <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapper( MethodParameter parameter, Class<A> annotationType, BiPredicate<A, Class<?>> typePredicate) { A annotation = parameter.getParameterAnnotation(annotationType); if (annotation == null) { return false; } parameter = parameter.nestedIfOptional(); Class<?> type = parameter.getNestedParameterType(); ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type); if (adapter != null) { assertHasValues(adapter, parameter); parameter = parameter.nested(); type = parameter.getNestedParameterType(); } if (typePredicate.test(annotation, type)) { if (adapter == null) { return true; } throw buildReactiveWrapperException(parameter); } return false; }