Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

TransformedBinaryProcedure

0/14

0/12

1.5

TransformedBinaryProcedure$1

N/A

1.5

TransformedBinaryProcedure$Helper

0/7

N/A

1.5

 /*
  * 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 java.io.Serializable;
 
 import org.apache.commons.functor.BinaryFunction;
 import org.apache.commons.functor.BinaryProcedure;
 import org.apache.commons.functor.UnaryProcedure;
 
 /**
  * A BinaryProcedure composed of a BinaryFunction whose result is then run through a UnaryProcedure.
  * @version $Revision: 1171154 $ $Date: 2011-09-15 17:58:38 +0200 (Thu, 15 Sep 2011) $
  * @author Matt Benson
  */
 public class TransformedBinaryProcedure<L, R> implements BinaryProcedure<L, R>, Serializable {
     /**
      * serialVersionUID declaration.
      */
     private static final long serialVersionUID = -7559182250073101798L;
 
     /**
      * Type-remembering helper
      * @param <X>
      */
     private static final class Helper<X, L, R> implements BinaryProcedure<L, R>, Serializable {
         /**
          * serialVersionUID declaration.
          */
         private static final long serialVersionUID = -4229496007094829301L;
         private BinaryFunction<? super L, ? super R, ? extends X> function;
         private UnaryProcedure<? super X> procedure;
 
         /**
          * Create a new Helper.
          * @param function BinaryFunction
          * @param procedure UnaryFunction
          */
         private Helper(BinaryFunction<? super L, ? super R, ? extends X> function,
                 UnaryProcedure<? super X> procedure) {
             this.function = function;
             this.procedure = procedure;
         }
 
         /**
          * {@inheritDoc}
          */
         public void run(L left, R right) {
             procedure.run(function.evaluate(left, right));
         }
     }
 
     private final Helper<?, L, R> helper;
 
     /**
      * Create a new TransformedBinaryProcedure.
      * @param <X>
      * @param function BinaryFunction
      * @param procedure UnaryProcedure
      */
     public <X> TransformedBinaryProcedure(BinaryFunction<? super L, ? super R, ? extends X> function,
             UnaryProcedure<? super X> procedure) {
         this.helper = new Helper<X, L, R>(function, procedure);
     }
 
     /**
      * {@inheritDoc}
      */
     public final void run(L left, R right) {
         helper.run(left, right);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final boolean equals(Object obj) {
         return obj == this || obj instanceof TransformedBinaryProcedure<?, ?>
                 && equals((TransformedBinaryProcedure<?, ?>) obj);
     }
 
     /**
      * Learn whether another TransformedBinaryProcedure is equal to <code>this</code>.
      * @param that instance to test
      * @return whether equal
      */
     public final boolean equals(TransformedBinaryProcedure<?, ?> that) {
         return that != null && that.helper.function.equals(this.helper.function)
                 && that.helper.procedure.equals(this.helper.procedure);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public int hashCode() {
         int result = "TransformedBinaryProcedure".hashCode();
         result <<= 2;
         result |= helper.procedure.hashCode();
         result <<= 2;
         result |= helper.function.hashCode();
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String toString() {
         return "TransformedBinaryProcedure<" + helper.function + "; " + helper.procedure + ">";
     }
 }

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.BinaryFunction;
22		import org.apache.commons.functor.BinaryProcedure;
23		import org.apache.commons.functor.UnaryProcedure;
24
25		/**
26		* A BinaryProcedure composed of a BinaryFunction whose result is then run through a UnaryProcedure.
27		* @version $Revision: 1171154 $ $Date: 2011-09-15 17:58:38 +0200 (Thu, 15 Sep 2011) $
28		* @author Matt Benson
29		*/
30		public class TransformedBinaryProcedure<L, R> implements BinaryProcedure<L, R>, Serializable {
31		/**
32		* serialVersionUID declaration.
33		*/
34		private static final long serialVersionUID = -7559182250073101798L;
35
36		/**
37		* Type-remembering helper
38		* @param <X>
39		*/
40	0	private static final class Helper<X, L, R> implements BinaryProcedure<L, R>, Serializable {
41		/**
42		* serialVersionUID declaration.
43		*/
44		private static final long serialVersionUID = -4229496007094829301L;
45		private BinaryFunction<? super L, ? super R, ? extends X> function;
46		private UnaryProcedure<? super X> procedure;
47
48		/**
49		* Create a new Helper.
50		* @param function BinaryFunction
51		* @param procedure UnaryFunction
52		*/
53		private Helper(BinaryFunction<? super L, ? super R, ? extends X> function,
54	0	UnaryProcedure<? super X> procedure) {
55	0	this.function = function;
56	0	this.procedure = procedure;
57	0	}
58
59		/**
60		* {@inheritDoc}
61		*/
62		public void run(L left, R right) {
63	0	procedure.run(function.evaluate(left, right));
64	0	}
65		}
66
67		private final Helper<?, L, R> helper;
68
69		/**
70		* Create a new TransformedBinaryProcedure.
71		* @param <X>
72		* @param function BinaryFunction
73		* @param procedure UnaryProcedure
74		*/
75		public <X> TransformedBinaryProcedure(BinaryFunction<? super L, ? super R, ? extends X> function,
76	0	UnaryProcedure<? super X> procedure) {
77	0	this.helper = new Helper<X, L, R>(function, procedure);
78	0	}
79
80		/**
81		* {@inheritDoc}
82		*/
83		public final void run(L left, R right) {
84	0	helper.run(left, right);
85	0	}
86
87		/**
88		* {@inheritDoc}
89		*/
90		@Override
91		public final boolean equals(Object obj) {
92	0	return obj == this \|\| obj instanceof TransformedBinaryProcedure<?, ?>
93		&& equals((TransformedBinaryProcedure<?, ?>) obj);
94		}
95
96		/**
97		* Learn whether another TransformedBinaryProcedure is equal to <code>this</code>.
98		* @param that instance to test
99		* @return whether equal
100		*/
101		public final boolean equals(TransformedBinaryProcedure<?, ?> that) {
102	0	return that != null && that.helper.function.equals(this.helper.function)
103		&& that.helper.procedure.equals(this.helper.procedure);
104		}
105
106		/**
107		* {@inheritDoc}
108		*/
109		@Override
110		public int hashCode() {
111	0	int result = "TransformedBinaryProcedure".hashCode();
112	0	result <<= 2;
113	0	result \|= helper.procedure.hashCode();
114	0	result <<= 2;
115	0	result \|= helper.function.hashCode();
116	0	return result;
117		}
118
119		/**
120		* {@inheritDoc}
121		*/
122		@Override
123		public String toString() {
124	0	return "TransformedBinaryProcedure<" + helper.function + "; " + helper.procedure + ">";
125		}
126		}