Java Predicate.eval方法代码示例

import org.aikodi.rejuse.predicate.Predicate; //导入方法依赖的package包/类
public static <T,E extends Exception> T findFirst(Collection<T> collection, Predicate<? super T,E> predicate) throws E {
  Iterator<T> iterator = collection.iterator();
  while(iterator.hasNext()) {
    T t = iterator.next();
    if(predicate.eval(t)) {
      return t;
    }
  }
  return null;
}
 

import org.aikodi.rejuse.predicate.Predicate; //导入方法依赖的package包/类
public <E extends Exception> void filter(Predicate<? super Edge<V>,E> predicate) throws E {
	for(Edge<V> edge: edges()) {
		if(! predicate.eval(edge)) {
			edge.terminate();
		}
	}
}
 

import org.aikodi.rejuse.predicate.Predicate; //导入方法依赖的package包/类
public List<TypeParameter> involvedTypeParameters(JavaTypeReference tref) throws LookupException {
	Predicate<BasicJavaTypeReference, LookupException> predicate = 
	    object ->  parent().typeParameters().contains(object.getDeclarator());
	List<BasicJavaTypeReference> list = tref.descendants(BasicJavaTypeReference.class, predicate);
	if((tref instanceof BasicJavaTypeReference) && predicate.eval((BasicJavaTypeReference) tref)) {
		list.add((BasicJavaTypeReference) tref);
	}
	List<TypeParameter> parameters = new ArrayList<TypeParameter>();
	for(BasicJavaTypeReference cref: list) {
		parameters.add((TypeParameter) cref.getDeclarator());
	}
	return parameters;
}
 

import org.aikodi.rejuse.predicate.Predicate; //导入方法依赖的package包/类
/**
	 * Replace all references to 'declarator' in 'in' with copies of 'replacement'.
	 * @param replacement
	 * @param declarator
	 * @param in
	 * @param kind
	 * @return
	 * @throws LookupException
	 */
	public static <E extends Element> E replace(TypeReference replacement, final Declaration declarator, E in, Class<E> kind) throws LookupException {
		ObjectOrientedLanguage lang = in.language(ObjectOrientedLanguage.class);
		E result = in;
		Predicate<BasicTypeReference, LookupException> predicate = object -> object.getDeclarator().sameAs(declarator);
		List<BasicTypeReference> crefs = in.descendants(BasicTypeReference.class, 
				predicate);
		if(in instanceof BasicTypeReference) {
			BasicTypeReference in2 = (BasicTypeReference) in;
			if(predicate.eval(in2)) {
				crefs.add(in2);
			}
		}
		for(BasicTypeReference cref: crefs) {
			TypeReference substitute;
			Element oldParent = replacement.parent();
			if(replacement.isDerived()) {
//				replacement.setUniParent(null);
			  substitute = lang.createNonLocalTypeReference(Util.clone(replacement),oldParent);
			  substitute.setOrigin(replacement);
			} else {
			  substitute = lang.createNonLocalTypeReference(Util.clone(replacement),oldParent);
			}
			if(! cref.isDerived()) {
				SingleAssociation crefParentLink = cref.parentLink();
				crefParentLink.getOtherRelation().replace(crefParentLink, substitute.parentLink());
			} else {
				substitute.setUniParent(in.parent());
			}
			if(cref == in) {
				if(kind.isInstance(substitute)) {
				  result = (E) substitute;
				} else {
					throw new ChameleonProgrammerException("The type reference passed to replace must be replaced as a whole, but the kind that was given is more specific than the newly created type reference.");
				}
			}
		}
		return result;
	}
 

import org.aikodi.rejuse.predicate.Predicate; //导入方法依赖的package包/类
default <X extends T, E extends Exception> X nearestIncluding(Class<X> kind, Predicate<X, E> predicate, T el) throws E {
	while ((el != null) && ((! kind.isInstance(el)) || (! predicate.eval((X)el)))) {
     el = tree(el).parent();
   }
   return (X) el;
}