Coverage Report

Coverage Report - org.apache.commons.functor.adapter.FunctionProcedure

Classes in this File

Line Coverage

Branch Coverage

Complexity

FunctionProcedure

93%

14/15

70%

14/20

2.143

 /*
  * 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.adapter;
 
 import java.io.Serializable;
 
 import org.apache.commons.functor.Function;
 import org.apache.commons.functor.Procedure;
 
 /**
  * Adapts a {@link Function Function}
  * to the {@link Procedure Procedure}
  * interface by ignoring the value returned
  * by the function.
  * <p/>
  * Note that although this class implements
  * {@link Serializable}, a given instance will
  * only be truly <code>Serializable</code> if the
  * underlying function is.  Attempts to serialize
  * an instance whose delegate is not
  * <code>Serializable</code> will result in an exception.
  *
  * @version $Revision: 1156778 $ $Date: 2011-08-11 21:50:51 +0200 (Thu, 11 Aug 2011) $
  * @author Rodney Waldhoff
  */
 public final class FunctionProcedure implements Procedure, Serializable {
     /**
      * serialVersionUID declaration.
      */
     private static final long serialVersionUID = -7300031015086684901L;
     /** The {@link Function Function} I'm wrapping. */
     private final Function<?> function;
 
     /**
      * Create an {@link Procedure Procedure} wrapping
      * the given {@link Function Function}.
      * @param function the {@link Function Function} to wrap
      */
     public FunctionProcedure(Function<?> function) {
         if (function == null) {
             throw new IllegalArgumentException("Function argument was null");
         }
         this.function = function;
     }
 
     /**
      * {@inheritDoc}
      * {@link Function#evaluate Evaluate} my function,
      * but ignore its returned value.
      */
     public void run() {
         function.evaluate();
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean equals(Object that) {
         return that == this || (that instanceof FunctionProcedure && equals((FunctionProcedure) that));
     }
 
     /**
      * Learn whether another FunctionProcedure is equal to this.
      * @param that FunctionProcedure to test
      * @return boolean
      */
     public boolean equals(FunctionProcedure that) {
         return null != that && (null == function ? null == that.function : function.equals(that.function));
     }
 
     /**
      * {@inheritDoc}
      */
     public int hashCode() {
         int hash = "FunctionProcedure".hashCode();
         if (null != function) {
             hash ^= function.hashCode();
         }
         return hash;
     }
 
     /**
      * {@inheritDoc}
      */
     public String toString() {
         return "FunctionProcedure<" + function + ">";
     }
 
     /**
      * Adapt the given, possibly-<code>null</code>,
      * {@link Function Function} to the
      * {@link Procedure Procedure} interface.
      * When the given <code>Function</code> is <code>null</code>,
      * returns <code>null</code>.
      *
      * @param function the possibly-<code>null</code>
      *        {@link Function Function} to adapt
      * @return a {@link Procedure Procedure} wrapping the given
      *         {@link Function Function}, or <code>null</code>
      *         if the given <code>Function</code> is <code>null</code>
      */
     public static FunctionProcedure adapt(Function<?> function) {
         return null == function ? null : new FunctionProcedure(function);
     }
 
 }

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.adapter;
18
19		import java.io.Serializable;
20
21		import org.apache.commons.functor.Function;
22		import org.apache.commons.functor.Procedure;
23
24		/**
25		* Adapts a {@link Function Function}
26		* to the {@link Procedure Procedure}
27		* interface by ignoring the value returned
28		* by the function.
29		* <p/>
30		* Note that although this class implements
31		* {@link Serializable}, a given instance will
32		* only be truly <code>Serializable</code> if the
33		* underlying function is. Attempts to serialize
34		* an instance whose delegate is not
35		* <code>Serializable</code> will result in an exception.
36		*
37		* @version $Revision: 1156778 $ $Date: 2011-08-11 21:50:51 +0200 (Thu, 11 Aug 2011) $
38		* @author Rodney Waldhoff
39		*/
40		public final class FunctionProcedure implements Procedure, Serializable {
41		/**
42		* serialVersionUID declaration.
43		*/
44		private static final long serialVersionUID = -7300031015086684901L;
45		/** The {@link Function Function} I'm wrapping. */
46		private final Function<?> function;
47
48		/**
49		* Create an {@link Procedure Procedure} wrapping
50		* the given {@link Function Function}.
51		* @param function the {@link Function Function} to wrap
52		*/
53	20	public FunctionProcedure(Function<?> function) {
54	20	if (function == null) {
55	0	throw new IllegalArgumentException("Function argument was null");
56		}
57	20	this.function = function;
58	20	}
59
60		/**
61		* {@inheritDoc}
62		* {@link Function#evaluate Evaluate} my function,
63		* but ignore its returned value.
64		*/
65		public void run() {
66	6	function.evaluate();
67	6	}
68
69		/**
70		* {@inheritDoc}
71		*/
72		public boolean equals(Object that) {
73	22	return that == this \|\| (that instanceof FunctionProcedure && equals((FunctionProcedure) that));
74		}
75
76		/**
77		* Learn whether another FunctionProcedure is equal to this.
78		* @param that FunctionProcedure to test
79		* @return boolean
80		*/
81		public boolean equals(FunctionProcedure that) {
82	14	return null != that && (null == function ? null == that.function : function.equals(that.function));
83		}
84
85		/**
86		* {@inheritDoc}
87		*/
88		public int hashCode() {
89	24	int hash = "FunctionProcedure".hashCode();
90	24	if (null != function) {
91	24	hash ^= function.hashCode();
92		}
93	24	return hash;
94		}
95
96		/**
97		* {@inheritDoc}
98		*/
99		public String toString() {
100	16	return "FunctionProcedure<" + function + ">";
101		}
102
103		/**
104		* Adapt the given, possibly-<code>null</code>,
105		* {@link Function Function} to the
106		* {@link Procedure Procedure} interface.
107		* When the given <code>Function</code> is <code>null</code>,
108		* returns <code>null</code>.
109		*
110		* @param function the possibly-<code>null</code>
111		* {@link Function Function} to adapt
112		* @return a {@link Procedure Procedure} wrapping the given
113		* {@link Function Function}, or <code>null</code>
114		* if the given <code>Function</code> is <code>null</code>
115		*/
116		public static FunctionProcedure adapt(Function<?> function) {
117	6	return null == function ? null : new FunctionProcedure(function);
118		}
119
120		}