Java OrPredicate类代码示例

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
private Predicate applyCompositePredicate(final CompositePredicate input) {
    Set<Predicate> appliedPredicates = new HashSet<Predicate>();

    for (Predicate predicate : input.getPredicates()) {
        appliedPredicates.add(applyPredicate(predicate));
    }

    Predicate[] appliedPredicatesArray = Iterables.toArray(appliedPredicates, Predicate.class);

    if (input instanceof AndPredicate) {
        return and(appliedPredicatesArray);
    } else if (input instanceof OrPredicate) {
        return or(appliedPredicatesArray);
    }

    return input;
}
 

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
/**
 * Adds a composite predicate to a criteria.
 *
 * @param p the composite predicate to add.
 * @param parent the parent criteria to add to.
 */
protected void addCompositePredicate(final CompositePredicate p, final C parent) {
    for (Predicate ip : p.getPredicates()) {
        final C inner = createInnerCriteria(parent);
        addPredicate(ip, inner);
        if (p instanceof AndPredicate) {
            addAnd(parent, inner);
        } else if (p instanceof OrPredicate) {
            addOr(parent, inner);
        } else {
            throw new UnsupportedPredicateException(p);
        }
    }
}
 

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
/** adds a composite predicate to a Criteria. */
private void addCompositePredicate(final CompositePredicate p, final Criteria parent,  LookupCustomizer.Transform<Predicate, Predicate> transform) {
    for (Predicate ip : p.getPredicates()) {
        final Criteria inner = new Criteria();
        addPredicate(ip, inner, transform);
        if (p instanceof AndPredicate) {
            parent.addAndCriteria(inner);
        } else if (p instanceof OrPredicate) {
            parent.addOrCriteria(inner);
        } else {
            throw new UnsupportedPredicateException(p);
        }
    }
}
 

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
/**
 * protected for testing
 */
protected boolean matches(T infoObject, Predicate predicate) {
    // no predicate matches everyting
    if (predicate == null) {
        return true;
    }
    if (predicate instanceof OrPredicate) {
        return matchesOr(infoObject, (OrPredicate) predicate);
    }
    if (predicate instanceof AndPredicate) {
        return matchesAnd(infoObject, (AndPredicate) predicate);
    }
    if (predicate instanceof EqualPredicate) {
        return matchesEqual(infoObject, (EqualPredicate) predicate);
    }
    if (predicate instanceof LessThanPredicate) {
        return matchesLessThan(infoObject, (LessThanPredicate) predicate);
    }
    if (predicate instanceof LessThanOrEqualPredicate) {
        return matchesLessThanOrEqual(infoObject, (LessThanOrEqualPredicate) predicate);
    }
    if (predicate instanceof GreaterThanPredicate) {
        return matchesGreaterThan(infoObject, (GreaterThanPredicate) predicate);
    }
    if (predicate instanceof GreaterThanOrEqualPredicate) {
        return matchesGreaterThanOrEqual(infoObject, (GreaterThanOrEqualPredicate) predicate);
    }
    if (predicate instanceof LikePredicate) {
        return matchesLike(infoObject, (LikePredicate) predicate);
    }
    throw new UnsupportedOperationException("predicate type not supported yet in in-memory mathcer" + predicate.getClass().getName());
}
 

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
private boolean matchesOr(T infoObject, OrPredicate predicate) {
    for (Predicate subPred : predicate.getPredicates()) {
        if (matches(infoObject, subPred)) {
            return true;
        }
    }
    return false;
}
 

import org.kuali.rice.core.api.criteria.OrPredicate; //导入依赖的package包/类
/** adds a composite predicate to a Criteria. */
private void addCompositePredicate(final CompositePredicate p, final Criteria parent,  LookupCustomizer.Transform<Predicate, Predicate> transform) {
    for (Predicate ip : p.getPredicates()) {
        final Criteria inner = new Criteria(parent.getEntityName());
        addPredicate(ip, inner, transform);
        if (p instanceof AndPredicate) {
            parent.and(inner);
        } else if (p instanceof OrPredicate) {
            parent.or(inner);
        } else {
            throw new UnsupportedPredicateException(p);
        }
    }
}