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 java.io.Serializable; 20 21 import org.apache.commons.functor.UnaryFunction; 22 import org.apache.commons.functor.UnaryProcedure; 23 import org.apache.commons.functor.adapter.UnaryProcedureUnaryFunction; 24 25 /** 26 * A {@link UnaryProcedure UnaryProcedure} 27 * representing the composition of 28 * {@link UnaryFunction UnaryFunctions}, 29 * "chaining" the output of one to the input 30 * of another. For example, 31 * <pre>new CompositeUnaryProcedure(p).of(f)</pre> 32 * {@link #run runs} to 33 * <code>p.run(f.evaluate(obj))</code>, and 34 * <pre>new CompositeUnaryProcedure(p).of(f).of(g)</pre> 35 * {@link #run runs} 36 * <code>p.run(f.evaluate(g.evaluate(obj)))</code>. 37 * <p> 38 * Note that although this class implements 39 * {@link Serializable}, a given instance will 40 * only be truly <code>Serializable</code> if all the 41 * underlying functors are. Attempts to serialize 42 * an instance whose delegates are not all 43 * <code>Serializable</code> will result in an exception. 44 * </p> 45 * @version $Revision: 1166378 $ $Date: 2011-09-07 22:17:16 +0200 (Wed, 07 Sep 2011) $ 46 * @author Rodney Waldhoff 47 */ 48 public final class CompositeUnaryProcedure<A> implements UnaryProcedure<A>, Serializable { 49 /** 50 * serialVersionUID declaration. 51 */ 52 private static final long serialVersionUID = -7496282561355676509L; 53 // attributes 54 // ------------------------------------------------------------------------ 55 private final CompositeUnaryFunction<? super A, Object> function; 56 57 // constructor 58 // ------------------------------------------------------------------------ 59 /** 60 * Create a new CompositeUnaryProcedure. 61 * @param procedure final UnaryProcedure to run 62 */ 63 public CompositeUnaryProcedure(UnaryProcedure<? super A> procedure) { 64 if (null == procedure) { 65 throw new IllegalArgumentException("procedure must not be null"); 66 } 67 this.function = new CompositeUnaryFunction<A, Object>(new UnaryProcedureUnaryFunction<A, Object>(procedure)); 68 } 69 70 private CompositeUnaryProcedure(CompositeUnaryFunction<? super A, Object> function) { 71 this.function = function; 72 } 73 74 // modifiers 75 // ------------------------------------------------------------------------ 76 /** 77 * Fluently obtain a CompositeUnaryProcedure that runs our procedure against the result of the preceding function. 78 * @param preceding UnaryFunction 79 * @return CompositeUnaryProcedure<P> 80 */ 81 public <T> CompositeUnaryProcedure<T> of(UnaryFunction<? super T, ? extends A> preceding) { 82 return new CompositeUnaryProcedure<T>(function.of(preceding)); 83 } 84 85 // predicate interface 86 // ------------------------------------------------------------------------ 87 /** 88 * {@inheritDoc} 89 */ 90 public void run(A obj) { 91 function.evaluate(obj); 92 } 93 94 /** 95 * {@inheritDoc} 96 */ 97 public boolean equals(Object that) { 98 return that == this || (that instanceof CompositeUnaryProcedure<?> 99 && equals((CompositeUnaryProcedure<?>) that)); 100 } 101 102 /** 103 * Learn whether another CompositeUnaryProcedure is equal to this. 104 * @param that CompositeUnaryProcedure to test 105 * @return boolean 106 */ 107 public boolean equals(CompositeUnaryProcedure<?> that) { 108 return null != that && function.equals(that.function); 109 } 110 111 /** 112 * {@inheritDoc} 113 */ 114 public int hashCode() { 115 int hash = "CompositeUnaryProcedure".hashCode(); 116 hash <<= 2; 117 hash ^= function.hashCode(); 118 return hash; 119 } 120 121 /** 122 * {@inheritDoc} 123 */ 124 public String toString() { 125 return "CompositeUnaryProcedure<" + function + ">"; 126 } 127 128 }