/*
 * Copyright (C) 2007 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;

import javax.annotation.Nullable;

/**
 * Determines a true or false value for a given input.
 *
 * <p>The {@link Predicates} class provides common predicates and related utilities.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/FunctionalExplained">the use of {@code
 * Predicate}</a>.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible
public interface Predicate<T> {
  /**
   * Returns the result of applying this predicate to {@code input}. This method is <i>generally
   * expected</i>, but not absolutely required, to have the following properties:
   *
   * <ul>
   * <li>Its execution does not cause any observable side effects.
   * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *     Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *     predicate.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@Nullable T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
   * {@link Predicate} that it considers <i>interchangeable</i> with this one. "Interchangeable"
   * <i>typically</i> means that {@code this.apply(t) == that.apply(t)} for all {@code t} of type
   * {@code T}). Note that a {@code false} result from this method does not imply that the
   * predicates are known <i>not</i> to be interchangeable.
   */
  @Override
  boolean equals(@Nullable Object object);
}

@@ -773,16 +773,81 @@
 en input
+; a pre-Java-8 version of %7B@code%0A * java.util.function.Predicate%7D
 .%0A *%0A * 
@@ -1084,16 +1084,922 @@
 /a%3E.%0A *%0A
+ * %3Ch3%3EFor Java 8+ users%3C/h3%3E%0A *%0A * %3Cp%3EThis interface is now a legacy type. Use %7B@code java.util.function.Predicate%7D (or the%0A * appropriate primitive specialization such as %7B@code IntPredicate%7D) instead whenever possible.%0A * Otherwise, reducing %3Ci%3Eexplicit%3C/i%3E dependencies on this type by using lambda expressions or%0A * method references instead of classes will leave your code easier to migrate in the future.%0A *%0A * %3Cp%3EIf you need to use a reference of this type (say, named %7B@code guavaPredicate%7D) in a context%0A * where %7B@code java.util.function.Predicate%7D is expected, use %7B@code guavaPredicate::apply%7D. For%0A * the other direction, use %7B@code javaUtilPredicate::test%7D. A future version of this interface will%0A * be made to %3Ci%3Eextend%3C/i%3E %7B@code java.util.function.Predicate%7D, so that conversion will be%0A * necessary in only one direction. At that time, this interface will be officially discouraged.%0A *%0A
  * @auth
@@ -2157,16 +2157,80 @@
 e input%7D
+ (Java 8 users, see notes in the%0A   * class documentation above)
 . This m
@@ -2250,21 +2250,16 @@
 enerally
-%0A   *
  expecte
@@ -2283,16 +2283,21 @@
 solutely
+%0A   *
  require

Document Predicate vs. Java 8 issues. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=110185504