Predicates.java revision 9b222c8fda48f87ad05338c74eb13e80738e194e 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.internal.util;
18
19import java.util.Arrays;
20
21/**
22 * Predicates contains static methods for creating the standard set of
23 * {@code Predicate} objects.
24 */
25public class Predicates {
26
27    private Predicates() {
28    }
29
30    /**
31     * Returns a Predicate that evaluates to true iff each of its components
32     * evaluates to true.  The components are evaluated in order, and evaluation
33     * will be "short-circuited" as soon as the answer is determined.
34     */
35    public static <T> Predicate<T> and(Predicate<? super T>... components) {
36        return Predicates.<T>and(Arrays.asList(components));
37    }
38
39    /**
40     * Returns a Predicate that evaluates to true iff each of its components
41     * evaluates to true.  The components are evaluated in order, and evaluation
42     * will be "short-circuited" as soon as the answer is determined.  Does not
43     * defensively copy the iterable passed in, so future changes to it will alter
44     * the behavior of this Predicate. If components is empty, the returned
45     * Predicate will always evaluate to true.
46     */
47    public static <T> Predicate<T> and(Iterable<? extends Predicate<? super T>> components) {
48        return new AndPredicate(components);
49    }
50
51    /**
52     * Returns a Predicate that evaluates to true iff any one of its components
53     * evaluates to true.  The components are evaluated in order, and evaluation
54     * will be "short-circuited" as soon as the answer is determined.
55     */
56    public static <T> Predicate<T> or(Predicate<? super T>... components) {
57        return Predicates.<T>or(Arrays.asList(components));
58    }
59
60    /**
61     * Returns a Predicate that evaluates to true iff any one of its components
62     * evaluates to true.  The components are evaluated in order, and evaluation
63     * will be "short-circuited" as soon as the answer is determined.  Does not
64     * defensively copy the iterable passed in, so future changes to it will alter
65     * the behavior of this Predicate. If components is empty, the returned
66     * Predicate will always evaluate to false.
67     */
68    public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> components) {
69        return new OrPredicate(components);
70    }
71
72    /**
73     * Returns a Predicate that evaluates to true iff the given Predicate
74     * evaluates to false.
75     */
76    public static <T> Predicate<T> not(Predicate<? super T> predicate) {
77        return new NotPredicate<T>(predicate);
78    }
79
80    private static class AndPredicate<T> implements Predicate<T> {
81        private final Iterable<? extends Predicate<? super T>> components;
82
83        private AndPredicate(Iterable<? extends Predicate<? super T>> components) {
84            this.components = components;
85        }
86
87        public boolean apply(T t) {
88            for (Predicate<? super T> predicate : components) {
89                if (!predicate.apply(t)) {
90                    return false;
91                }
92            }
93            return true;
94        }
95    }
96
97    private static class OrPredicate<T> implements Predicate<T> {
98        private final Iterable<? extends Predicate<? super T>> components;
99
100        private OrPredicate(Iterable<? extends Predicate<? super T>> components) {
101            this.components = components;
102        }
103
104        public boolean apply(T t) {
105            for (Predicate<? super T> predicate : components) {
106                if (predicate.apply(t)) {
107                    return true;
108                }
109            }
110            return false;
111        }
112    }
113
114    private static class NotPredicate<T> implements Predicate<T> {
115        private final Predicate<? super T> predicate;
116
117        private NotPredicate(Predicate<? super T> predicate) {
118            this.predicate = predicate;
119        }
120
121        public boolean apply(T t) {
122            return !predicate.apply(t);
123        }
124    }
125}
126