001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.functor.core.composite; 018 019 import java.io.Serializable; 020 021 import org.apache.commons.functor.UnaryFunction; 022 import org.apache.commons.functor.UnaryPredicate; 023 import org.apache.commons.functor.adapter.UnaryPredicateUnaryFunction; 024 025 /** 026 * A {@link UnaryPredicate UnaryPredicate} 027 * representing the composition of 028 * {@link UnaryFunction UnaryFunctions}, 029 * "chaining" the output of one to the input 030 * of another. For example, 031 * <pre>new CompositeUnaryPredicate(p).of(f)</pre> 032 * {@link #test tests} to 033 * <code>p.test(f.evaluate(obj))</code>, and 034 * <pre>new CompositeUnaryPredicate(p).of(f).of(g)</pre> 035 * {@link #test tests} to 036 * <code>p.test(f.evaluate(g.evaluate(obj)))</code>. 037 * <p> 038 * Note that although this class implements 039 * {@link Serializable}, a given instance will 040 * only be truly <code>Serializable</code> if all the 041 * underlying functors are. Attempts to serialize 042 * an instance whose delegates are not all 043 * <code>Serializable</code> will result in an exception. 044 * </p> 045 * @version $Revision: 1166375 $ $Date: 2011-09-07 22:13:25 +0200 (Wed, 07 Sep 2011) $ 046 * @author Rodney Waldhoff 047 */ 048 public final class CompositeUnaryPredicate<A> implements UnaryPredicate<A>, Serializable { 049 /** 050 * serialVersionUID declaration. 051 */ 052 private static final long serialVersionUID = 4880363949059265252L; 053 // attributes 054 // ------------------------------------------------------------------------ 055 private final CompositeUnaryFunction<? super A, Boolean> function; 056 057 // constructor 058 // ------------------------------------------------------------------------ 059 /** 060 * Create a new CompositeUnaryPredicate. 061 * @param predicate UnaryPredicate against which the composite functions' output will be tested 062 */ 063 public CompositeUnaryPredicate(UnaryPredicate<? super A> predicate) { 064 if (null == predicate) { 065 throw new IllegalArgumentException("predicate must not be null"); 066 } 067 this.function = new CompositeUnaryFunction<A, Boolean>(new UnaryPredicateUnaryFunction<A>(predicate)); 068 } 069 070 /** 071 * Create a new CompositeUnaryPredicate. 072 * @param function delegate 073 */ 074 private CompositeUnaryPredicate(CompositeUnaryFunction<? super A, Boolean> function) { 075 this.function = function; 076 } 077 078 // modifiers 079 // ------------------------------------------------------------------------ 080 /** 081 * Fluently obtain a CompositeUnaryPredicate that applies our predicate to the result of the preceding function. 082 * @param preceding UnaryFunction 083 * @return CompositeUnaryPredicate<P> 084 */ 085 public <P> CompositeUnaryPredicate<P> of(UnaryFunction<? super P, ? extends A> preceding) { 086 return new CompositeUnaryPredicate<P>(function.of(preceding)); 087 } 088 089 // predicate interface 090 // ------------------------------------------------------------------------ 091 /** 092 * {@inheritDoc} 093 */ 094 public boolean test(A obj) { 095 return function.evaluate(obj); 096 } 097 098 /** 099 * {@inheritDoc} 100 */ 101 public boolean equals(Object that) { 102 return that == this || (that instanceof CompositeUnaryPredicate<?> 103 && equals((CompositeUnaryPredicate<?>) that)); 104 } 105 106 /** 107 * Learn whether another CompositeUnaryPredicate is equal to this. 108 * @param that CompositeUnaryPredicate to test 109 * @return boolean 110 */ 111 public boolean equals(CompositeUnaryPredicate<?> that) { 112 return null != that && function.equals(that.function); 113 } 114 115 /** 116 * {@inheritDoc} 117 */ 118 public int hashCode() { 119 int hash = "CompositeUnaryPredicate".hashCode(); 120 hash <<= 2; 121 hash ^= function.hashCode(); 122 return hash; 123 } 124 125 /** 126 * {@inheritDoc} 127 */ 128 public String toString() { 129 return "CompositeUnaryFunction<" + function + ">"; 130 } 131 132 }