Coverage Report

Coverage Report - org.apache.commons.functor.core.composite.Or

Classes in this File

Line Coverage

Branch Coverage

Complexity

87%

14/16

100%

10/10

1.556

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 org.apache.commons.functor.core.composite;
 
 import org.apache.commons.functor.Predicate;
 
 /**
  * {@link #test Tests} <code>true</code> iff
  * at least one of its children test <code>true</code>.
  * Note that by this definition, the "or" of
  * an empty collection of predicates tests <code>false</code>.
  * <p>
  * Note that although this class implements
  * {@link java.io.Serializable Serializable}, a given instance will
  * only be truly <code>Serializable</code> if all the
  * underlying functors are.  Attempts to serialize
  * an instance whose delegates are not all
  * <code>Serializable</code> will result in an exception.
  * </p>
  * @version $Revision: 1156320 $ $Date: 2011-08-10 21:14:50 +0200 (Wed, 10 Aug 2011) $
  * @author Rodney Waldhoff
  */
 public final class Or extends BasePredicateList {
 
     /**
      * serialVersionUID declaration.
      */
     private static final long serialVersionUID = -1636233158061690073L;
 
     // constructor
     // ------------------------------------------------------------------------
     /**
      * Create a new Or.
      */
     public Or() {
         super();
     }
 
     /**
      * Create a new Or instance.
      *
      * @param predicates
      */
     public Or(Iterable<Predicate> predicates) {
         super(predicates);
     }
 
     /**
      * Create a new Or instance.
      *
      * @param predicates
      */
     public Or(Predicate... predicates) {
         super(predicates);
     }
 
     /**
      * Fluently add a Predicate.
      * @param p Predicate to add
      * @return this
      */
     public Or or(Predicate p) {
         super.addPredicate(p);
         return this;
     }
 
     // predicate interface
     // ------------------------------------------------------------------------
     /**
      * {@inheritDoc}
      */
     public boolean test() {
         for (Predicate p : getPredicateList()) {
             if (p.test()) {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean equals(Object that) {
         return that == this || (that instanceof Or && equals((Or) that));
     }
 
     /**
      * Learn whether another Or is equal to this.
      * @param that Or to test
      * @return boolean
      */
     public boolean equals(Or that) {
         return getPredicateListEquals(that);
     }
 
     /**
      * {@inheritDoc}
      */
     public int hashCode() {
         return "Or".hashCode() ^ getPredicateListHashCode();
     }
 
     /**
      * {@inheritDoc}
      */
     public String toString() {
         return "Or<" + getPredicateListToString() + ">";
     }
 
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.functor.core.composite;
18
19		import org.apache.commons.functor.Predicate;
20
21		/**
22		* {@link #test Tests} <code>true</code> iff
23		* at least one of its children test <code>true</code>.
24		* Note that by this definition, the "or" of
25		* an empty collection of predicates tests <code>false</code>.
26		* <p>
27		* Note that although this class implements
28		* {@link java.io.Serializable Serializable}, a given instance will
29		* only be truly <code>Serializable</code> if all the
30		* underlying functors are. Attempts to serialize
31		* an instance whose delegates are not all
32		* <code>Serializable</code> will result in an exception.
33		* </p>
34		* @version $Revision: 1156320 $ $Date: 2011-08-10 21:14:50 +0200 (Wed, 10 Aug 2011) $
35		* @author Rodney Waldhoff
36		*/
37		public final class Or extends BasePredicateList {
38
39		/**
40		* serialVersionUID declaration.
41		*/
42		private static final long serialVersionUID = -1636233158061690073L;
43
44		// constructor
45		// ------------------------------------------------------------------------
46		/**
47		* Create a new Or.
48		*/
49		public Or() {
50	6	super();
51	6	}
52
53		/**
54		* Create a new Or instance.
55		*
56		* @param predicates
57		*/
58		public Or(Iterable<Predicate> predicates) {
59	0	super(predicates);
60	0	}
61
62		/**
63		* Create a new Or instance.
64		*
65		* @param predicates
66		*/
67		public Or(Predicate... predicates) {
68	52	super(predicates);
69	52	}
70
71		/**
72		* Fluently add a Predicate.
73		* @param p Predicate to add
74		* @return this
75		*/
76		public Or or(Predicate p) {
77	124	super.addPredicate(p);
78	124	return this;
79		}
80
81		// predicate interface
82		// ------------------------------------------------------------------------
83		/**
84		* {@inheritDoc}
85		*/
86		public boolean test() {
87	134	for (Predicate p : getPredicateList()) {
88	406	if (p.test()) {
89	76	return true;
90		}
91		}
92	58	return false;
93		}
94
95		/**
96		* {@inheritDoc}
97		*/
98		public boolean equals(Object that) {
99	140	return that == this \|\| (that instanceof Or && equals((Or) that));
100		}
101
102		/**
103		* Learn whether another Or is equal to this.
104		* @param that Or to test
105		* @return boolean
106		*/
107		public boolean equals(Or that) {
108	118	return getPredicateListEquals(that);
109		}
110
111		/**
112		* {@inheritDoc}
113		*/
114		public int hashCode() {
115	190	return "Or".hashCode() ^ getPredicateListHashCode();
116		}
117
118		/**
119		* {@inheritDoc}
120		*/
121		public String toString() {
122	182	return "Or<" + getPredicateListToString() + ">";
123		}
124
125		}