protected void collideWithNearbyEntities() { List<Entity> list = this.worldObj.getEntitiesInAABBexcluding(this, this.getEntityBoundingBox().expand(0.20000000298023224D, 0.0D, 0.20000000298023224D), Predicates.<Entity> and (EntitySelectors.NOT_SPECTATING, new Predicate<Entity>() { public boolean apply(Entity p_apply_1_) { return p_apply_1_.canBePushed(); } })); if (!list.isEmpty()) { for (int i = 0; i < list.size(); ++i) { Entity entity = (Entity)list.get(i); this.collideWithEntity(entity); } } }
/** * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles. * That statement compiles only if {@link FluentIterable#concat concat(aIterable, bIterable)} * returns a {@link FluentIterable} of elements of an anonymous type whose supertypes are the * <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.9">intersection</a> * of the supertypes of {@code A} and the supertypes of {@code B}. */ public void testConcatIntersectionType() { Iterable<A> aIterable = ImmutableList.of(); Iterable<B> bIterable = ImmutableList.of(); Predicate<X> xPredicate = Predicates.alwaysTrue(); Predicate<Y> yPredicate = Predicates.alwaysTrue(); FluentIterable<?> unused = FluentIterable.concat(aIterable, bIterable).filter(xPredicate).filter(yPredicate); /* The following fails to compile: * * The method append(Iterable<? extends FluentIterableTest.A>) in the type * FluentIterable<FluentIterableTest.A> is not applicable for the arguments * (Iterable<FluentIterableTest.B>) */ // FluentIterable.from(aIterable).append(bIterable); /* The following fails to compile: * * The method filter(Predicate<? super Object>) in the type FluentIterable<Object> is not * applicable for the arguments (Predicate<FluentIterableTest.X>) */ // FluentIterable.of().append(aIterable).append(bIterable).filter(xPredicate); }
private ResourceLocation findResourceFile(SourceGroup[] resSG, final String value, final String folderName) { FileObject resFile = Iterables.find( Iterables.transform( Arrays.asList(resSG), new Function<SourceGroup, FileObject>() { @Override public FileObject apply(SourceGroup sg) { return sg.getRootFolder().getFileObject(folderName + "/" + value + ".xml"); } }), Predicates.notNull(), null); if (resFile == null) { LOG.log(Level.FINE, "Resource file {0} not found for {0}.", value); return null; } return new ResourceLocation(resFile, -1); }
/** * Returns whether the EntityAIBase should begin execution. */ public boolean shouldExecute() { if (this.targetChance > 0 && this.taskOwner.getRNG().nextInt(this.targetChance) != 0) { return false; } else { double d0 = this.getTargetDistance(); List<T> list = this.taskOwner.worldObj.<T>getEntitiesWithinAABB(this.targetClass, this.taskOwner.getEntityBoundingBox().expand(d0, 4.0D, d0), Predicates.<T> and (this.targetEntitySelector, EntitySelectors.NOT_SPECTATING)); Collections.sort(list, this.theNearestAttackableTargetSorter); if (list.isEmpty()) { return false; } else { this.targetEntity = (EntityLivingBase)list.get(0); return true; } } }
@Override public Ordering<Element> enclosedBy(Element element) { if (element instanceof ElementImpl && Iterables.all(element.getEnclosedElements(), Predicates.instanceOf(ElementImpl.class))) { ElementImpl implementation = (ElementImpl) element; if (implementation._binding instanceof SourceTypeBinding) { SourceTypeBinding sourceBinding = (SourceTypeBinding) implementation._binding; return Ordering.natural().onResultOf( Functions.compose(bindingsToSourceOrder(sourceBinding), this)); } } return DEFAULT_PROVIDER.enclosedBy(element); }
@Override public Iterator<FragmentExecutor> iterator() { return Iterators.unmodifiableIterator( FluentIterable .from(handlers.asMap().values()) .transform(new Function<FragmentHandler, FragmentExecutor>() { @Nullable @Override public FragmentExecutor apply(FragmentHandler input) { return input.getExecutor(); } }) .filter(Predicates.<FragmentExecutor>notNull()) .iterator() ); }
public PostProcessor[] scan(final Object instance) { return FluentIterable .from(ReflectionUtils.getDeclaredFields(instance.getClass(), true)) .filter(new Predicate<Field>() { @Override public boolean apply(Field input) { return input.isAnnotationPresent(Random.PostProcessor.class) && PostProcessor.class.isAssignableFrom(input.getType()); } }) .transform(new Function<Field, PostProcessor>() { @Override public PostProcessor apply(Field field) { try { if (!ReflectionUtils.makeFieldAccessible(field)) { return null; } return (PostProcessor) field.get(instance); } catch (IllegalAccessException e) { throw new RandomitoException(e); } } }) .filter(Predicates.<PostProcessor>notNull()) .toArray(PostProcessor.class); }
@SuppressWarnings("unchecked") public SimpleHelpMap(CraftServer server) { this.helpTopics = new TreeMap<String, HelpTopic>(HelpTopicComparator.topicNameComparatorInstance()); // Using a TreeMap for its explicit sorting on key this.topicFactoryMap = new HashMap<Class, HelpTopicFactory<Command>>(); this.server = server; this.yaml = new HelpYamlReader(server); Predicate indexFilter = Predicates.not(Predicates.instanceOf(CommandAliasHelpTopic.class)); if (!yaml.commandTopicsInMasterIndex()) { indexFilter = Predicates.and(indexFilter, Predicates.not(new IsCommandTopicPredicate())); } this.defaultTopic = new IndexHelpTopic("Index", null, null, Collections2.filter(helpTopics.values(), indexFilter), "Use /help [n] to get page n of help."); registerHelpTopicFactory(MultipleCommandAlias.class, new MultipleCommandAliasHelpTopicFactory()); }
/** * Warns about CAS offsets for Responses being inconsistent with actual document text for non-TIME * roles */ private void warnOnMissingOffsets(final File systemOutputStoreFile, final Symbol docID, final ImmutableSet<Response> responses, final Map<Symbol, File> docIDMap) throws IOException { final String text = Files.asCharSource(docIDMap.get(docID), Charsets.UTF_8).read(); for (final Response r : FluentIterable.from(responses) .filter(Predicates.compose(not(equalTo(TIME)), ResponseFunctions.role()))) { final KBPString cas = r.canonicalArgument(); final String casTextInRaw = resolveCharOffsets(cas.charOffsetSpan(), docID, text).replaceAll("\\s+", " "); // allow whitespace if (!casTextInRaw.contains(cas.string())) { log.warn("Warning for {} - response {} CAS does not match text span of {} ", systemOutputStoreFile.getAbsolutePath(), renderResponse(r, text), casTextInRaw); } } }
public Iterable<Class<? extends RuleSource>> getDeclaredSources(Class<?> container) { try { return FluentIterable.from(cache.get(container)) .transform(new Function<Reference<Class<? extends RuleSource>>, Class<? extends RuleSource>>() { @Override public Class<? extends RuleSource> apply(Reference<Class<? extends RuleSource>> input) { return input.get(); } }) .filter(Predicates.notNull()); } catch (ExecutionException e) { throw UncheckedException.throwAsUncheckedException(e); } }
public Iterable<String> getManifestThemeNames(InputStream is) { return Iterables.filter( Iterables.transform( getAttrNames(is, manifestXpathExp), new Function<String, String>() { @Override public String apply(String name) { return name.startsWith("@style/") ? name.substring("@style/".length()) : null; } }), Predicates.notNull()); }
/** * Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when * filtering a filtered navigable map. */ @GwtIncompatible // NavigableMap private static <K, V> NavigableMap<K, V> filterFiltered( FilteredEntryNavigableMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) { Predicate<Entry<K, V>> predicate = Predicates.<Entry<K, V>>and(map.entryPredicate, entryPredicate); return new FilteredEntryNavigableMap<K, V>(map.unfiltered, predicate); }
private List<String> resolveFileResourceNames(ObjectListing objectListing) { List<S3ObjectSummary> objectSummaries = objectListing.getObjectSummaries(); if (null != objectSummaries) { return ImmutableList.copyOf(Iterables.filter( Iterables.transform(objectSummaries, EXTRACT_FILE_NAME), Predicates.notNull() )); } return Collections.emptyList(); }
public void testFirstMatch() { FluentIterable<String> iterable = FluentIterable.from(Lists.newArrayList("cool", "pants")); assertThat(iterable.firstMatch(Predicates.equalTo("cool"))).hasValue("cool"); assertThat(iterable.firstMatch(Predicates.equalTo("pants"))).hasValue("pants"); assertThat(iterable.firstMatch(Predicates.alwaysFalse())).isAbsent(); assertThat(iterable.firstMatch(Predicates.alwaysTrue())).hasValue("cool"); }
@Nullable TypeSpec generate( String generatedCodePackageName, @Nullable TypeSpec requestOptions, TypeSpec requestBuilder, Set<String> glideExtensions) { generatedRequestBuilderClassName = ClassName.get(generatedCodePackageName, requestBuilder.name); return TypeSpec.classBuilder(GENERATED_REQUEST_MANAGER_SIMPLE_NAME) .superclass(requestManagerClassName) .addJavadoc("Includes all additions from methods in {@link $T}s\n" + "annotated with {@link $T}\n" + "\n" + "<p>Generated code, do not modify\n", GlideExtension.class, GlideType.class) .addAnnotation( AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "deprecation") .build()) .addModifiers(Modifier.PUBLIC) .addMethod(generateAsMethod(generatedCodePackageName, requestBuilder)) .addMethod(generateCallSuperConstructor()) .addMethods(generateExtensionRequestManagerMethods(glideExtensions)) .addMethods(generateRequestManagerRequestManagerMethodOverrides(generatedCodePackageName)) .addMethods(generateRequestManagerRequestBuilderMethodOverrides()) .addMethods( FluentIterable.from( Collections.singletonList( generateOverrideSetRequestOptions(generatedCodePackageName, requestOptions))) .filter(Predicates.<MethodSpec>notNull())) .build(); }
public void testFilteredEntriesObjectPredicate() { Map<String, Integer> unfiltered = createUnfiltered(); unfiltered.put("cat", 3); unfiltered.put("dog", 2); unfiltered.put("horse", 5); Predicate<Object> predicate = Predicates.alwaysFalse(); Map<String, Integer> filtered = Maps.filterEntries(unfiltered, predicate); assertTrue(filtered.isEmpty()); }
public void testFromArrayAndIteratorRemove() { FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values()); try { Iterables.removeIf(units, Predicates.equalTo(TimeUnit.SECONDS)); fail("Expected an UnsupportedOperationException to be thrown but it wasn't."); } catch (UnsupportedOperationException expected) { } }
@Override public Result findSourceRoots2(final URL binaryRoot) { Result r = findAarLibraryRoots(binaryRoot); if (r != null) { return r; } if (project == null) { return null; } final File binRootDir = FileUtil.archiveOrDirForURL(binaryRoot); if (binRootDir == null) { return null; } Variant variant = Iterables.find( project.getVariants(), new Predicate<Variant>() { @Override public boolean apply(Variant input) { return binRootDir.equals(input.getMainArtifact().getClassesFolder()); } }, null); if (variant != null) { Iterable<FileObject> srcRoots = Iterables.filter( Iterables.transform( sourceRootsForVariant(variant), new Function<File, FileObject>() { @Override public FileObject apply(File f) { return FileUtil.toFileObject(f); } }), Predicates.notNull()); return new GradleSourceResult(srcRoots); } return null; }
public void testFind_withDefault_notPresent() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("woot", Iterators.find(iterator, Predicates.alwaysFalse(), "woot")); assertFalse(iterator.hasNext()); }
public CraftiniumForgeTileEntity() { this.input = new ItemStackHandler(1); this.output = new SelectiveItemStackHandler(1, Predicates.alwaysFalse()); this.fuel = new SelectiveItemStackHandler(1, TileEntityFurnace::isItemFuel); this.furnaceBurnTime = 0; this.currentItemBurnTime = 0; this.cookTime = 0; this.totalCookTime = 0; this.divisor = 1; this.brokenByCreative = false; }
public void testTryFind() { Iterable<String> list = newArrayList("cool", "pants"); assertThat(Iterables.tryFind(list, Predicates.equalTo("cool"))).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.equalTo("pants"))).hasValue("pants"); assertThat(Iterables.tryFind(list, Predicates.alwaysTrue())).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.alwaysFalse())).isAbsent(); assertCanIterateAgain(list); }
/** * Set the registered client information resolvers. * * @param newResolvers the client information resolvers to use * * @throws ResolverException thrown if there is a problem adding the client information resolvers */ public void setResolvers(@Nonnull @NonnullElements final List<? extends ClientInformationResolver> newResolvers) throws ResolverException { ComponentSupport.ifInitializedThrowUnmodifiabledComponentException(this); ComponentSupport.ifDestroyedThrowDestroyedComponentException(this); if (newResolvers == null || newResolvers.isEmpty()) { resolvers = Collections.emptyList(); return; } resolvers = new ArrayList<>(Collections2.filter(newResolvers, Predicates.notNull())); }
/** * Set the default authentication contexts to use, expressed as custom principals. * * @param contexts default authentication contexts to use */ public void setDefaultAuthenticationMethods( @Nonnull @NonnullElements final List<Principal> contexts) { Constraint.isNotNull(contexts, "List of contexts cannot be null"); defaultAuthenticationContexts = new ArrayList<>(Collections2.filter(contexts, Predicates.notNull())); }
private Predicate<RequestHandler> apis(Swagger2Properties swagger2Properties) { List<Predicate<RequestHandler>> basePackages = new LinkedList<>(); if (swagger2Properties.getBasePackage().isEmpty()) { basePackages.add(RequestHandlerSelectors.any()); } for (String basePackage : swagger2Properties.getBasePackage()) { basePackages.add(RequestHandlerSelectors.basePackage(basePackage)); } return Predicates.or(basePackages); }
public void testTryFind_alwaysFalse_orDefault() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertEquals("woot", Iterators.tryFind(iterator, Predicates.alwaysFalse()).or("woot")); assertFalse(iterator.hasNext()); }
public void testAny() { List<String> list = Lists.newArrayList(); Predicate<String> predicate = Predicates.equalTo("pants"); assertFalse(Iterators.any(list.iterator(), predicate)); list.add("cool"); assertFalse(Iterators.any(list.iterator(), predicate)); list.add("pants"); assertTrue(Iterators.any(list.iterator(), predicate)); }
@Bean public Docket api() { return new Docket(DocumentationType.SWAGGER_2) .useDefaultResponseMessages(false) .select() .apis(RequestHandlerSelectors.any()) .paths(Predicates.not(PathSelectors.regex("/error.*"))) .build(); }
public void testAll() { List<String> list = Lists.newArrayList(); Predicate<String> predicate = Predicates.equalTo("cool"); assertTrue(Iterators.all(list.iterator(), predicate)); list.add("cool"); assertTrue(Iterators.all(list.iterator(), predicate)); list.add("pants"); assertFalse(Iterators.all(list.iterator(), predicate)); }
@Bean public Docket createRestApi() { // @formatter:off return new Docket(DocumentationType.SWAGGER_2) .securitySchemes(this.oAuth()) .apiInfo(apiInfo()) .select() .paths(postPaths()) .apis(Predicates.not(RequestHandlerSelectors.basePackage("org.springframework.boot"))) .paths(springBootActuatorJmxPaths()) //.apis(RequestHandlerSelectors.basePackage("com.piggymetrics.account.controller")) .paths(PathSelectors.any()) .build(); // @formatter:on }
public void testFind_withDefault_notPresent_nullReturn() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertNull( Iterators.find(iterator, Predicates.alwaysFalse(), null)); assertFalse(iterator.hasNext()); }
/** * Support removal operations when filtering a filtered multimap. Since a filtered multimap has * iterators that don't support remove, passing one to the FilteredEntryMultimap constructor would * lead to a multimap whose removal operations would fail. This method combines the predicates to * avoid that problem. */ private static <K, V> SetMultimap<K, V> filterFiltered( FilteredSetMultimap<K, V> multimap, Predicate<? super Entry<K, V>> entryPredicate) { Predicate<Entry<K, V>> predicate = Predicates.<Entry<K, V>>and(multimap.entryPredicate(), entryPredicate); return new FilteredEntrySetMultimap<K, V>(multimap.unfiltered(), predicate); }
/** @see #mayHaveKeys(String...) */ public QueryClassifierBuilder mayHaveKeys(Predicate<? super String> p) { if (mayClassifier == null) { mayClassifier = p; } else { mayClassifier = Predicates.<String>or(mayClassifier, p); } return this; }
public void testAllMatch() { List<String> list = Lists.newArrayList(); FluentIterable<String> iterable = FluentIterable.<String>from(list); Predicate<String> predicate = Predicates.equalTo("cool"); assertTrue(iterable.allMatch(predicate)); list.add("cool"); assertTrue(iterable.allMatch(predicate)); list.add("pants"); assertFalse(iterable.allMatch(predicate)); }
public static <T extends Entity> Predicate<T> getTeamCollisionPredicate(final Entity entityIn) { final Team team = entityIn.getTeam(); final Team.CollisionRule team$collisionrule = team == null ? Team.CollisionRule.ALWAYS : team.getCollisionRule(); Predicate<?> ret = team$collisionrule == Team.CollisionRule.NEVER ? Predicates.alwaysFalse() : Predicates.and(NOT_SPECTATING, new Predicate<Entity>() { public boolean apply(@Nullable Entity p_apply_1_) { if (!p_apply_1_.canBePushed()) { return false; } else if (!entityIn.worldObj.isRemote || p_apply_1_ instanceof EntityPlayer && ((EntityPlayer)p_apply_1_).isUser()) { Team team1 = p_apply_1_.getTeam(); Team.CollisionRule team$collisionrule1 = team1 == null ? Team.CollisionRule.ALWAYS : team1.getCollisionRule(); if (team$collisionrule1 == Team.CollisionRule.NEVER) { return false; } else { boolean flag = team != null && team.isSameTeam(team1); return (team$collisionrule == Team.CollisionRule.HIDE_FOR_OWN_TEAM || team$collisionrule1 == Team.CollisionRule.HIDE_FOR_OWN_TEAM) && flag ? false : team$collisionrule != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS && team$collisionrule1 != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS || flag; } } else { return false; } } }); return (Predicate<T>)ret; }
public Predicate<IBlockState> getPredicate(final BlockStateContainer blockState) { return Predicates.and(Iterables.transform(this.conditions, new Function<ICondition, Predicate<IBlockState>>() { @Nullable public Predicate<IBlockState> apply(@Nullable ICondition p_apply_1_) { return p_apply_1_ == null ? null : p_apply_1_.getPredicate(blockState); } })); }
@Bean public Docket api() { return new Docket(DocumentationType.SWAGGER_2) .useDefaultResponseMessages(false) .apiInfo(apiInfo()) .select() .apis(RequestHandlerSelectors.any()) .paths(Predicates.not(PathSelectors.regex("/error.*"))) .build(); }
public EntityMedic(World par1World) { super(par1World); this.targetTasks.taskEntries.clear(); this.targetTasks.addTask(1, this.findplayer = new EntityAINearestChecked(this, EntityLivingBase.class, true, false, Predicates.and(this::isValidTarget, target -> { return target.getHealth()<target.getMaxHealth(); }), false)); this.targetTasks.addTask(2, new EntityAINearestChecked(this, EntityLivingBase.class, true, false, this::isValidTarget, true)); this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true)); this.targetTasks.addTask(4, new EntityAINearestChecked(this, EntityLivingBase.class, true, false, super::isValidTarget, true)); this.unlimitedAmmo = true; //this.ammoLeft = 1; this.experienceValue = 15; this.rotation = 15; this.tasks.removeTask(attack); if (par1World != null) { this.tasks.addTask(4, useMedigun); //attack.setRange(7f); this.setCombatTask(true); this.friendly = true; } // this.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, // ItemUsable.getNewStack("Minigun")); }