All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.google.common.base.Predicates Maven / Gradle / Ivy

    Go to download

    Google Collections Library is a suite of new collections and collection-related goodness for Java 5.0

    There is a newer version: 1.0
    Show newest version
    /*
 * Copyright (C) 2007 Google Inc.
 *
 * 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 com.google.common.annotations.GwtIncompatible;
import static com.google.common.base.Preconditions.checkNotNull;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import javax.annotation.Nullable;

/**
 * Contains static factory methods for creating {@code Predicate} instances.
 *
 * 
    All methods returns serializable predicates as long as they're given
 * serializable parameters.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public final class Predicates {
  private Predicates() {}

  // TODO: considering having these implement a VisitablePredicate interface
  // which specifies an accept(PredicateVisitor) method.

  /**
   * Returns a predicate that always evaluates to {@code true}.
   */
  @SuppressWarnings("unchecked")
  public static  Predicate alwaysTrue() {
    return (Predicate) AlwaysTruePredicate.INSTANCE;
  }

  /**
   * Returns a predicate that always evaluates to {@code false}.
   */
  @SuppressWarnings("unchecked")
  public static  Predicate alwaysFalse() {
    return (Predicate) AlwaysFalsePredicate.INSTANCE;
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the object reference
   * being tested is null.
   */
  @SuppressWarnings("unchecked")
  public static  Predicate isNull() {
    return (Predicate) IsNullPredicate.INSTANCE;
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the object reference
   * being tested is not null.
   */
  @SuppressWarnings("unchecked")
  public static  Predicate notNull() {
    return (Predicate) NotNullPredicate.INSTANCE;
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the given predicate
   * evaluates to {@code false}.
   */
  public static  Predicate not(Predicate predicate) {
    return new NotPredicate(predicate);
  }

  /**
   * Returns a predicate that evaluates to {@code true} if each of its
   * components evaluates to {@code 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 {@code
   * components} is empty, the returned predicate will always evaluate to {@code
   * true}.
   */
  public static  Predicate and(
      Iterable> components) {
    return new AndPredicate(defensiveCopy(components));
  }

  /**
   * Returns a predicate that evaluates to {@code true} if each of its
   * components evaluates to {@code 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 {@code
   * components} is empty, the returned predicate will always evaluate to {@code
   * true}.
   */
  public static  Predicate and(Predicate... components) {
    return new AndPredicate(defensiveCopy(components));
  }

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

  /**
   * Returns a predicate that evaluates to {@code true} if any one of its
   * components evaluates to {@code true}. The components are evaluated in
   * order, and evaluation will be "short-circuited" as soon as 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 {@code
   * components} is empty, the returned predicate will always evaluate to {@code
   * false}.
   */
  public static  Predicate or(
      Iterable> components) {
    return new OrPredicate(defensiveCopy(components));
  }

  /**
   * Returns a predicate that evaluates to {@code true} if any one of its
   * components evaluates to {@code true}. The components are evaluated in
   * order, and evaluation will be "short-circuited" as soon as 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 {@code
   * components} is empty, the returned predicate will always evaluate to {@code
   * false}.
   */
  public static  Predicate or(Predicate... components) {
    return new OrPredicate(defensiveCopy(components));
  }

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

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

  /**
   * Returns a predicate that evaluates to {@code true} if the object being
   * tested is an instance of the given class. If the object being tested
   * is {@code null} this predicate evaluates to {@code false}.
   *
   * 
    If you want to filter an {@code Iterable} to narrow its type, consider
   * using {@link com.google.common.collect.Iterables#filter(Iterable, Class)}
   * in preference.
   */
  @GwtIncompatible("Class.isInstance")
  public static Predicate instanceOf(Class clazz) {
    return new InstanceOfPredicate(clazz);
  }

  /**
   * Returns a predicate that evaluates to {@code 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 {@code Predicates.in()}.
   *
   * @param target the collection that may contain the function input
   */
  public static  Predicate in(Collection target) {
    return new InPredicate(target);
  }

  /**
   * Returns the composition of a function and a predicate. For every {@code x},
   * the generated predicate returns {@code predicate(function(x))}.
   *
   * @return the composition of the provided function and predicate
   */
  public static  Predicate compose(
      Predicate predicate, Function function) {
    return new CompositionPredicate(predicate, function);
  }

  /** @see Predicates#alwaysTrue() */
  // enum singleton pattern
  private enum AlwaysTruePredicate implements Predicate {
    INSTANCE;

    public boolean apply(Object o) {
      return true;
    }
    @Override public String toString() {
      return "AlwaysTrue";
    }
  }

  /** @see Predicates#alwaysFalse() */
  // enum singleton pattern
  private enum AlwaysFalsePredicate implements Predicate {
    INSTANCE;

    public boolean apply(Object o) {
      return false;
    }
    @Override public String toString() {
      return "AlwaysFalse";
    }
  }

  /** @see Predicates#not(Predicate) */
  private static class NotPredicate
      implements Predicate, Serializable {
    private final Predicate predicate;

    private NotPredicate(Predicate predicate) {
      this.predicate = checkNotNull(predicate);
    }
    public boolean apply(T t) {
      return !predicate.apply(t);
    }
    @Override public int hashCode() {
      return ~predicate.hashCode(); /* Invert all bits. */
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof NotPredicate) {
        NotPredicate that = (NotPredicate) obj;
        return predicate.equals(that.predicate);
      }
      return false;
    }
    @Override public String toString() {
      return "Not(" + predicate.toString() + ")";
    }
    private static final long serialVersionUID = 0;
  }

  private static final Joiner commaJoiner = Joiner.on(",");

  /** @see Predicates#and(Iterable) */
  private static class AndPredicate
      implements Predicate, Serializable {
    private final Iterable> components;

    private AndPredicate(Iterable> components) {
      this.components = components;
    }
    public boolean apply(T t) {
      for (Predicate predicate : components) {
        if (!predicate.apply(t)) {
          return false;
        }
      }
      return true;
    }
    @Override public int hashCode() {
      int result = -1; /* Start with all bits on. */
      for (Predicate predicate : components) {
        result &= predicate.hashCode();
      }
      return result;
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof AndPredicate) {
        AndPredicate that = (AndPredicate) obj;
        return iterableElementsEqual(components, that.components);
      }
      return false;
    }
    @Override public String toString() {
      return "And(" + commaJoiner.join(components) + ")";
    }
    private static final long serialVersionUID = 0;
  }

  /** @see Predicates#or(Iterable) */
  private static class OrPredicate
      implements Predicate, Serializable {
    private final Iterable> components;

    private OrPredicate(Iterable> components) {
      this.components = components;
    }
    public boolean apply(T t) {
      for (Predicate predicate : components) {
        if (predicate.apply(t)) {
          return true;
        }
      }
      return false;
    }
    @Override public int hashCode() {
      int result = 0; /* Start with all bits off. */
      for (Predicate predicate : components) {
        result |= predicate.hashCode();
      }
      return result;
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof OrPredicate) {
        OrPredicate that = (OrPredicate) obj;
        return iterableElementsEqual(components, that.components);
      }
      return false;
    }
    @Override public String toString() {
      return "Or(" + commaJoiner.join(components) + ")";
    }
    private static final long serialVersionUID = 0;
  }

  /** @see Predicates#equalTo(Object) */
  private static class IsEqualToPredicate
      implements Predicate, Serializable {
    private final T target;

    private IsEqualToPredicate(T target) {
      this.target = target;
    }
    public boolean apply(T t) {
      return target.equals(t);
    }
    @Override public int hashCode() {
      return target.hashCode();
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof IsEqualToPredicate) {
        IsEqualToPredicate that = (IsEqualToPredicate) obj;
        return target.equals(that.target);
      }
      return false;
    }
    @Override public String toString() {
      return "IsEqualTo(" + target + ")";
    }
    private static final long serialVersionUID = 0;
  }

  /** @see Predicates#instanceOf(Class) */
  private static class InstanceOfPredicate
      implements Predicate, Serializable {
    private final Class clazz;

    private InstanceOfPredicate(Class clazz) {
      this.clazz = checkNotNull(clazz);
    }
    public boolean apply(Object o) {
      return Platform.isInstance(clazz, o);
    }
    @Override public int hashCode() {
      return clazz.hashCode();
    }
    @Override public boolean equals(Object obj) {
      if (obj instanceof InstanceOfPredicate) {
        InstanceOfPredicate that = (InstanceOfPredicate) obj;
        return clazz == that.clazz;
      }
      return false;
    }
    @Override public String toString() {
      return "IsInstanceOf(" + clazz.getName() + ")";
    }
    private static final long serialVersionUID = 0;
  }

  /** @see Predicates#isNull() */
  // enum singleton pattern
  private enum IsNullPredicate implements Predicate {
    INSTANCE;

    public boolean apply(Object o) {
      return o == null;
    }
    @Override public String toString() {
      return "IsNull";
    }
  }

  /** @see Predicates#notNull() */
  // enum singleton pattern
  private enum NotNullPredicate implements Predicate {
    INSTANCE;

    public boolean apply(Object o) {
      return o != null;
    }
    @Override public String toString() {
      return "NotNull";
    }
  }

  /** @see Predicates#in(Collection) */
  private static class InPredicate
      implements Predicate, Serializable {
    private final Collection target;

    private InPredicate(Collection target) {
      this.target = checkNotNull(target);
    }

    public boolean apply(T t) {
      try {
        return target.contains(t);
      } catch (NullPointerException e) {
        return false;
      } catch (ClassCastException e) {
        return false;
      }
    }

    @Override public boolean equals(Object obj) {
      if (obj instanceof InPredicate) {
        InPredicate that = (InPredicate) obj;
        return target.equals(that.target);
      }
      return false;
    }

    @Override public int hashCode() {
      return target.hashCode();
    }

    @Override public String toString() {
      return "In(" + target + ")";
    }
    private static final long serialVersionUID = 0;
  }

  /** @see Predicates#compose(Predicate, Function) */
  private static class CompositionPredicate
      implements Predicate, Serializable {
    final Predicate p;
    final Function f;

    private CompositionPredicate(Predicate p, Function f) {
      this.p = checkNotNull(p);
      this.f = checkNotNull(f);
    }

    public boolean apply(A a) {
      return p.apply(f.apply(a));
    }

    @Override public boolean equals(Object obj) {
      if (obj instanceof CompositionPredicate) {
        CompositionPredicate that = (CompositionPredicate) obj;
        return f.equals(that.f) && p.equals(that.p);
      }
      return false;
    }

    @Override public int hashCode() {
      /*
       * TODO:  To leave the door open for future enhancement, this
       * calculation should be coordinated with the hashCode() method of the
       * corresponding composition method in Functions.  To construct the
       * composition:
       *    predicate(function2(function1(x)))
       *
       * There are two different ways of composing it:
       *    compose(predicate, compose(function2, function1))
       *    compose(compose(predicate, function2), function1)
       *
       * It would be nice if these could be equal.
       */
      return f.hashCode() ^ p.hashCode();
    }

    @Override public String toString() {
      return p.toString() + "(" + f.toString() + ")";
    }

    private static final long serialVersionUID = 0;
  }

  /**
   * Determines whether the two Iterables contain equal elements. More
   * specifically, this method returns {@code true} if {@code iterable1} and
   * {@code iterable2} contain the same number of elements and every element of
   * {@code iterable1} is equal to the corresponding element of {@code
   * iterable2}.
   *
   * 
    This is not a general-purpose method; it assumes that the iterations
   * contain no {@code null} elements.
   */
  private static boolean iterableElementsEqual(
      Iterable iterable1, Iterable iterable2) {
    Iterator iterator1 = iterable1.iterator();
    Iterator iterator2 = iterable2.iterator();
    while (iterator1.hasNext()) {
      if (!iterator2.hasNext()) {
        return false;
      }
      if (!iterator1.next().equals(iterator2.next())) {
        return false;
      }
    }
    return !iterator2.hasNext();
  }

  @SuppressWarnings("unchecked")
  private static  List> asList(
      Predicate first, Predicate second) {
    return Arrays.>asList(first, second);
  }

  private static  List defensiveCopy(T... array) {
    return defensiveCopy(Arrays.asList(array));
  }

  static  List defensiveCopy(Iterable iterable) {
    ArrayList list = new ArrayList();
    for (T element : iterable) {
      list.add(checkNotNull(element));
    }
    return list;
  }
}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy