| /******************************************************************************* |
| * Copyright (c) 2013, 2015 Oracle. All rights reserved. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License 2.0, which accompanies this distribution |
| * and is available at https://www.eclipse.org/legal/epl-2.0/. |
| * |
| * Contributors: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.common.utility.internal.predicate.int_; |
| |
| import java.util.Iterator; |
| import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; |
| import org.eclipse.jpt.common.utility.predicate.CompoundIntPredicate; |
| import org.eclipse.jpt.common.utility.predicate.IntPredicate; |
| |
| /** |
| * {@link IntPredicate} utility methods. |
| */ |
| public class IntPredicateTools { |
| |
| |
| // ********** simple ********** |
| |
| /** |
| * Return a predicate that will always evaluate to <code>true</code>. |
| */ |
| public static IntPredicate true_() { |
| return True.instance(); |
| } |
| |
| /** |
| * Return a predicate that will always evaluate to <code>false</code>. |
| */ |
| public static IntPredicate false_() { |
| return False.instance(); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * if the variable is even. |
| */ |
| public static IntPredicate isEven() { |
| return IsEven.instance(); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * if the variable is odd. |
| */ |
| public static IntPredicate isOdd() { |
| return IsOdd.instance(); |
| } |
| |
| /** |
| * Return a predicate that will throw an exception when it is |
| * evaluated. |
| */ |
| public static IntPredicate disabledIntPredicate() { |
| return DisabledIntPredicate.instance(); |
| } |
| |
| |
| // ********** criterion ********** |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable equal to the specified |
| * criterion. |
| */ |
| public static IntPredicate isEqual(int criterion) { |
| return new Equals(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable not equal to the specified |
| * criterion. |
| */ |
| public static IntPredicate notEqual(int criterion) { |
| return new NotEqual(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable greater than the specified criterion. |
| */ |
| public static IntPredicate isGreaterThan(int criterion) { |
| return new IsGreaterThan(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable greater than or equal to the specified criterion. |
| */ |
| public static IntPredicate isGreaterThanOrEqual(int criterion) { |
| return new IsGreaterThanOrEqual(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable less than the specified criterion. |
| */ |
| public static IntPredicate isLessThan(int criterion) { |
| return new IsLessThan(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable less than or equal to the specified criterion. |
| */ |
| public static IntPredicate isLessThanOrEqual(int criterion) { |
| return new IsLessThanOrEqual(criterion); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has set the specified flag. |
| */ |
| public static IntPredicate flagIsSet(int flag) { |
| return new FlagIsSet(flag); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has cleared the specified flag. |
| */ |
| public static IntPredicate flagIsOff(int flag) { |
| return new FlagIsOff(flag); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has set <em>only</em> the specified flag. |
| */ |
| public static IntPredicate onlyFlagIsSet(int flag) { |
| return new OnlyFlagIsSet(flag); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has cleared <em>only</em> the specified flag. |
| */ |
| public static IntPredicate onlyFlagIsOff(int flag) { |
| return new OnlyFlagIsOff(flag); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has set <em>any</em> of the specified flags. |
| */ |
| public static IntPredicate anyFlagsAreSet(int flags) { |
| return new AnyFlagsAreSet(flags); |
| } |
| |
| /** |
| * Return a predicate that will evaluate to <code>true</code> |
| * for any variable that has cleared <em>any</em> of the specified flags. |
| */ |
| public static IntPredicate anyFlagsAreOff(int flags) { |
| return new AnyFlagsAreOff(flags); |
| } |
| |
| |
| // ********** AND ********** |
| |
| /** |
| * Return a predicate that will AND the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate and(Iterable<IntPredicate> predicates) { |
| return and(predicates.iterator()); |
| } |
| |
| /** |
| * Return a predicate that will AND the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate and(Iterator<IntPredicate> predicates) { |
| return and(IteratorTools.toArray(predicates, EMPTY_ARRAY)); |
| } |
| |
| /** |
| * Return a predicate that will AND the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate and(IntPredicate... predicates) { |
| return new AND(predicates); |
| } |
| |
| |
| // ********** OR ********** |
| |
| /** |
| * Return a predicate that will OR the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate or(Iterable<IntPredicate> predicates) { |
| return or(predicates.iterator()); |
| } |
| |
| /** |
| * Return a predicate that will OR the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate or(Iterator<IntPredicate> predicates) { |
| return or(IteratorTools.toArray(predicates, EMPTY_ARRAY)); |
| } |
| |
| /** |
| * Return a predicate that will OR the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate or(IntPredicate... predicates) { |
| return new OR(predicates); |
| } |
| |
| |
| // ********** XOR ********** |
| |
| /** |
| * Return a predicate that will XOR the results of the specified predicates. |
| */ |
| public static CompoundIntPredicate xor(IntPredicate predicate1, IntPredicate predicate2) { |
| return new XOR(predicate1, predicate2); |
| } |
| |
| |
| // ********** NAND ********** |
| |
| /** |
| * Return a predicate that will NAND the results of the specified predicates. |
| */ |
| public static IntPredicate nand(Iterable<IntPredicate> predicates) { |
| return nand(predicates.iterator()); |
| } |
| |
| /** |
| * Return a predicate that will NAND the results of the specified predicates. |
| */ |
| public static IntPredicate nand(Iterator<IntPredicate> predicates) { |
| return nand(IteratorTools.toArray(predicates, EMPTY_ARRAY)); |
| } |
| |
| /** |
| * Return a predicate that will NAND the results of the specified predicates. |
| */ |
| public static IntPredicate nand(IntPredicate... predicates) { |
| return not(and(predicates)); |
| } |
| |
| |
| // ********** NOR ********** |
| |
| /** |
| * Return a predicate that will NOR the results of the specified predicates. |
| */ |
| public static IntPredicate nor(Iterable<IntPredicate> predicates) { |
| return nor(predicates.iterator()); |
| } |
| |
| /** |
| * Return a predicate that will NOR the results of the specified predicates. |
| */ |
| public static IntPredicate nor(Iterator<IntPredicate> predicates) { |
| return nor(IteratorTools.toArray(predicates, EMPTY_ARRAY)); |
| } |
| |
| /** |
| * Return a predicate that will NOR the results of the specified predicates. |
| */ |
| public static IntPredicate nor(IntPredicate... predicates) { |
| return not(or(predicates)); |
| } |
| |
| |
| // ********** XNOR ********** |
| |
| /** |
| * Return a predicate that will XNOR the results of the specified predicates. |
| */ |
| public static IntPredicate xnor(IntPredicate predicate1, IntPredicate predicate2) { |
| return not(xor(predicate1, predicate2)); |
| } |
| |
| |
| // ********** NOT ********** |
| |
| /** |
| * Return a predicate that will return the NOT of the value returned |
| * by the specified predicate. |
| */ |
| public static IntPredicate not(IntPredicate predicate) { |
| return new NOT(predicate); |
| } |
| |
| |
| // ********** wrappers ********** |
| |
| /** |
| * Return a predicate that wraps the specified predicate, allowing the |
| * wrapped predicate to be changed as necessary. |
| */ |
| public static IntPredicateWrapper wrap(IntPredicate predicate) { |
| return new IntPredicateWrapper(predicate); |
| } |
| |
| |
| // ********** empty array ********** |
| |
| public static IntPredicate[] emptyArray() { |
| return EMPTY_ARRAY; |
| } |
| |
| public static final IntPredicate[] EMPTY_ARRAY = new IntPredicate[0]; |
| |
| |
| // ********** constructor ********** |
| |
| /** |
| * Suppress default constructor, ensuring non-instantiability. |
| */ |
| private IntPredicateTools() { |
| super(); |
| throw new UnsupportedOperationException(); |
| } |
| } |