Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.List;
 
Static utility methods pertaining to Predicate instances.

All methods returns serializable predicates as long as they're given serializable parameters.

See the Guava User Guide article on the use of Predicate.

Author(s):
Kevin Bourrillion
Since:
2.0 (imported from Google Collections Library)
 
 @GwtCompatible(emulated = true)
 public final class Predicates {
   private Predicates() {}
 
   // TODO(kevinb): considering having these implement a VisitablePredicate
   // interface which specifies an accept(PredicateVisitor) method.
 
  
Returns a predicate that always evaluates to true.
 
   @GwtCompatible(serializable = true)
   public static <T> Predicate<T> alwaysTrue() {
   }

  
Returns a predicate that always evaluates to false.
 
   @GwtCompatible(serializable = true)
   public static <T> Predicate<T> alwaysFalse() {
   }

  
Returns a predicate that evaluates to true if the object reference being tested is null.
 
   @GwtCompatible(serializable = true)
   public static <T> Predicate<T> isNull() {
   }

  
Returns a predicate that evaluates to true if the object reference being tested is not null.
 
   @GwtCompatible(serializable = true)
   public static <T> Predicate<T> notNull() {
   }

  
Returns a predicate that evaluates to true if the given predicate evaluates to false.
 
   public static <T> Predicate<T> not(Predicate<T> predicate) {
     return new NotPredicate<T>(predicate);
   }

  
Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.
  public static <T> Predicate<T> and(
      Iterable<? extends Predicate<? super T>> components) {
    return new AndPredicate<T>(defensiveCopy(components));
  }

  
Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.
  public static <T> Predicate<T> and(Predicate<? super T>... components) {
    return new AndPredicate<T>(defensiveCopy(components));
  }

  
Returns a predicate that evaluates to true if both of its components evaluate to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found.
  public static <T> Predicate<T> and(Predicate<? super T> first,
      Predicate<? super T> second) {
    return new AndPredicate<T>(Predicates.<T>asList(
        checkNotNull(first), checkNotNull(second)));
  }

  
Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.
  public static <T> Predicate<T> or(
      Iterable<? extends Predicate<? super T>> components) {
    return new OrPredicate<T>(defensiveCopy(components));
  }

  
Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.
  public static <T> Predicate<T> or(Predicate<? super T>... components) {
    return new OrPredicate<T>(defensiveCopy(components));
  }

  
Returns a predicate that evaluates to true if either of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found.
  public static <T> Predicate<T> or(
      Predicate<? super T> firstPredicate<? super T> second) {
    return new OrPredicate<T>(Predicates.<T>asList(
        checkNotNull(first), checkNotNull(second)));
  }

  
Returns a predicate that evaluates to true if the object being tested equals() the given target or both are null.
  public static <T> Predicate<T> equalTo(@Nullable T target) {
    return (target == null)
        ? Predicates.<T>isNull()
        : new IsEqualToPredicate<T>(target);
  }

  
Returns a predicate that evaluates to true if the object reference being tested is a member of the given collection. It does not defensively copy the collection passed in, so future changes to it will alter the behavior of the predicate.

This method can technically accept any Collection<?>, but using a typed collection helps prevent bugs. This approach doesn't block any potential users since it is always possible to use Predicates.<Object>in().

Parameters:
target the collection that may contain the function input
  public static <T> Predicate<T> in(Collection<? extends T> target) {
    return new InPredicate<T>(target);
  }

  
Returns the composition of a function and a predicate. For every x, the generated predicate returns predicate(function(x)).

Returns:
the composition of the provided function and predicate
  public static <A, B> Predicate<A> compose(
      Predicate<B> predicateFunction<A, ? extends B> function) {
    return new CompositionPredicate<A, B>(predicatefunction);
  }
  // End public API, begin private implementation classes.
  // Package private for GWT serialization.
  enum ObjectPredicate implements Predicate<Object> {
    
    ALWAYS_TRUE {
      @Override public boolean apply(@Nullable Object o) {
        return true;
      }
      @Override public String toString() {
        return "Predicates.alwaysTrue()";
      }
    },
    
    ALWAYS_FALSE {
      @Override public boolean apply(@Nullable Object o) {
        return false;
      }
      @Override public String toString() {
        return "Predicates.alwaysFalse()";
      }
    },
    
    IS_NULL {
      @Override public boolean apply(@Nullable Object o) {
        return o == null;
      }
      @Override public String toString() {
        return "Predicates.isNull()";
      }
    },
    
    NOT_NULL {
      @Override public boolean apply(@Nullable Object o) {
        return o != null;
      }
      @Override public String toString() {
        return "Predicates.notNull()";
      }
    };
    @SuppressWarnings("unchecked"// safe contravariant cast
    <T> Predicate<T> withNarrowedType() {
      return (Predicate<T>) this;
    }
  }

  
  private static class NotPredicate<T> implements Predicate<T>, Serializable {
    final Predicate<T> predicate;
    NotPredicate(Predicate<T> predicate) {
      this. = checkNotNull(predicate);
    }
    @Override
    public boolean apply(@Nullable T t) {
      return !.apply(t);
    }
    @Override public int hashCode() {
      return ~.hashCode();
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof NotPredicate) {
        NotPredicate<?> that = (NotPredicate<?>) obj;
        return .equals(that.predicate);
      }
      return false;
    }
    @Override public String toString() {
      return "Predicates.not(" + .toString() + ")";
    }
    private static final long serialVersionUID = 0;
  }
  private static final Joiner COMMA_JOINER = Joiner.on(',');

  
  private static class AndPredicate<T> implements Predicate<T>, Serializable {
    private final List<? extends Predicate<? super T>> components;
    private AndPredicate(List<? extends Predicate<? super T>> components) {
      this. = components;
    }
    @Override
    public boolean apply(@Nullable T t) {
      // Avoid using the Iterator to avoid generating garbage (issue 820).
      for (int i = 0; i < .size(); i++) {
        if (!.get(i).apply(t)) {
          return false;
        }
      }
      return true;
    }
    @Override public int hashCode() {
      // add a random number to avoid collisions with OrPredicate
      return .hashCode() + 0x12472c2c;
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof AndPredicate) {
        AndPredicate<?> that = (AndPredicate<?>) obj;
        return .equals(that.components);
      }
      return false;
    }
    @Override public String toString() {
      return "Predicates.and(" + .join() + ")";
    }
    private static final long serialVersionUID = 0;
  }

  
  private static class OrPredicate<T> implements Predicate<T>, Serializable {
    private final List<? extends Predicate<? super T>> components;
    private OrPredicate(List<? extends Predicate<? super T>> components) {
      this. = components;
    }
    @Override
    public boolean apply(@Nullable T t) {
      // Avoid using the Iterator to avoid generating garbage (issue 820).
      for (int i = 0; i < .size(); i++) {
        if (.get(i).apply(t)) {
          return true;
        }
      }
      return false;
    }
    @Override public int hashCode() {
      // add a random number to avoid collisions with AndPredicate
      return .hashCode() + 0x053c91cf;
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof OrPredicate) {
        OrPredicate<?> that = (OrPredicate<?>) obj;
        return .equals(that.components);
      }
      return false;
    }
    @Override public String toString() {
      return "Predicates.or(" + .join() + ")";
    }
    private static final long serialVersionUID = 0;
  }

  
  private static class IsEqualToPredicate<T>
      implements Predicate<T>, Serializable {
    private final T target;
    private IsEqualToPredicate(T target) {
      this. = target;
    }
    @Override
    public boolean apply(T t) {
      return .equals(t);
    }
    @Override public int hashCode() {
      return .hashCode();
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof IsEqualToPredicate) {
        IsEqualToPredicate<?> that = (IsEqualToPredicate<?>) obj;
        return .equals(that.target);
      }
      return false;
    }
    @Override public String toString() {
      return "Predicates.equalTo(" +  + ")";
    }
    private static final long serialVersionUID = 0;
  }

  
  private static class InPredicate<T> implements Predicate<T>, Serializable {
    private final Collection<?> target;
    private InPredicate(Collection<?> target) {
      this. = checkNotNull(target);
    }
    @Override
    public boolean apply(@Nullable T t) {
      try {
        return .contains(t);
      } catch (NullPointerException e) {
        return false;
      } catch (ClassCastException e) {
        return false;
      }
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof InPredicate) {
        InPredicate<?> that = (InPredicate<?>) obj;
        return .equals(that.target);
      }
      return false;
    }
    @Override public int hashCode() {
      return .hashCode();
    }
    @Override public String toString() {
      return "Predicates.in(" +  + ")";
    }
    private static final long serialVersionUID = 0;
  }

  
  private static class CompositionPredicate<A, B>
      implements Predicate<A>, Serializable {
    final Predicate<B> p;
    final Function<A, ? extends B> f;
    private CompositionPredicate(Predicate<B> pFunction<A, ? extends B> f) {
      this. = checkNotNull(p);
      this. = checkNotNull(f);
    }
    @Override
    public boolean apply(@Nullable A a) {
      return .apply(.apply(a));
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof CompositionPredicate) {
        CompositionPredicate<?, ?> that = (CompositionPredicate<?, ?>) obj;
        return .equals(that.f) && .equals(that.p);
      }
      return false;
    }
    @Override public int hashCode() {
      return .hashCode() ^ .hashCode();
    }
    @Override public String toString() {
      return .toString() + "(" + .toString() + ")";
    }
    private static final long serialVersionUID = 0;
  }
  private static <T> List<Predicate<? super T>> asList(
      Predicate<? super T> firstPredicate<? super T> second) {
    // TODO(kevinb): understand why we still get a warning despite @SafeVarargs!
    return Arrays.<Predicate<? super T>>asList(firstsecond);
  }
  private static <T> List<T> defensiveCopy(T... array) {
    return defensiveCopy(Arrays.asList(array));
  }
  static <T> List<T> defensiveCopy(Iterable<T> iterable) {
    ArrayList<T> list = new ArrayList<T>();
    for (T element : iterable) {
      list.add(checkNotNull(element));
    }
    return list;
  }
New to GrepCode? Check out our FAQ X