src/share/classes/java/util/function/BiPredicate.java

rev 7047 : 8004015: Additional static and instance utils for functional interfaces.
Reviewed-by: briangoetz

*** 28,103 ****
  
  /**
   * Determines if the input objects match some criteria. This is the two-arity
   * specialization of {@link Predicate}.
   *
!  * @param <T> the type of the first argument to {@code test}.
!  * @param <U> the type of the second argument to {@code test}.
   *
   * @see Predicate
   * @since 1.8
   */
  @FunctionalInterface
  public interface BiPredicate<T, U> {
  
      /**
       * Return {@code true} if the inputs match some criteria.
       *
!      * @param t an input object.
!      * @param u an input object.
!      * @return {@code true} if the inputs match some criteria.
       */
      boolean test(T t, U u);
  
      /**
       * Returns a predicate which evaluates to {@code true} only if this
       * predicate and the provided predicate both evaluate to {@code true}. If
       * this predicate returns {@code false} then the remaining predicate is not
       * evaluated.
       *
!      * @param p a predicate which will be logically-ANDed with this predicate.
       * @return a new predicate which returns {@code true} only if both
!      * predicates return {@code true}.
       */
!     public default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> p) {
          Objects.requireNonNull(p);
          return (T t, U u) -> test(t, u) && p.test(t, u);
      }
  
      /**
       * Returns a predicate which negates the result of this predicate.
       *
       * @return a new predicate who's result is always the opposite of this
!      * predicate.
       */
!     public default BiPredicate<T, U> negate() {
          return (T t, U u) -> !test(t, u);
      }
  
      /**
       * Returns a predicate which evaluates to {@code true} if either this
       * predicate or the provided predicate evaluates to {@code true}. If this
       * predicate returns {@code true} then the remaining predicate is not
       * evaluated.
       *
!      * @param p a predicate which will be logically-ORed with this predicate.
       * @return a new predicate which returns {@code true} if either predicate
!      * returns {@code true}.
       */
!     public default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> p) {
          Objects.requireNonNull(p);
          return (T t, U u) -> test(t, u) || p.test(t, u);
      }
- 
-     /**
-      * Returns a predicate that evaluates to {@code true} if both or neither of
-      * the component predicates evaluate to {@code true}.
-      *
-      * @param p a predicate which will be logically-XORed with this predicate.
-      * @return a predicate that evaluates to {@code true} if both or neither of
-      * the component predicates evaluate to {@code true}.
-      */
-     public default BiPredicate<T, U> xor(BiPredicate<? super T, ? super U> p) {
-         Objects.requireNonNull(p);
-         return (T t, U u) -> test(t, u) ^ p.test(t, u);
-     }
  }
--- 28,92 ----
  
  /**
   * Determines if the input objects match some criteria. This is the two-arity
   * specialization of {@link Predicate}.
   *
!  * @param <T> the type of the first argument to {@code test}
!  * @param <U> the type of the second argument to {@code test}
   *
   * @see Predicate
   * @since 1.8
   */
  @FunctionalInterface
  public interface BiPredicate<T, U> {
  
      /**
       * Return {@code true} if the inputs match some criteria.
       *
!      * @param t an input object
!      * @param u an input object
!      * @return {@code true} if the inputs match some criteria
       */
      boolean test(T t, U u);
  
      /**
       * Returns a predicate which evaluates to {@code true} only if this
       * predicate and the provided predicate both evaluate to {@code true}. If
       * this predicate returns {@code false} then the remaining predicate is not
       * evaluated.
       *
!      * @param p a predicate which will be logically-ANDed with this predicate
       * @return a new predicate which returns {@code true} only if both
!      * predicates return {@code true}
!      * @throws NullPointerException if p is null
       */
!     default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> p) {
          Objects.requireNonNull(p);
          return (T t, U u) -> test(t, u) && p.test(t, u);
      }
  
      /**
       * Returns a predicate which negates the result of this predicate.
       *
       * @return a new predicate who's result is always the opposite of this
!      * predicate
       */
!     default BiPredicate<T, U> negate() {
          return (T t, U u) -> !test(t, u);
      }
  
      /**
       * Returns a predicate which evaluates to {@code true} if either this
       * predicate or the provided predicate evaluates to {@code true}. If this
       * predicate returns {@code true} then the remaining predicate is not
       * evaluated.
       *
!      * @param p a predicate which will be logically-ORed with this predicate
       * @return a new predicate which returns {@code true} if either predicate
!      * returns {@code true}
!      * @throws NullPointerException if p is null
       */
!     default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> p) {
          Objects.requireNonNull(p);
          return (T t, U u) -> test(t, u) || p.test(t, u);
      }
  }