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;
018
019 import java.io.Serializable;
020
021 import org.apache.commons.functor.BinaryFunction;
022 import org.apache.commons.functor.BinaryPredicate;
023 import org.apache.commons.functor.Function;
024 import org.apache.commons.functor.Predicate;
025 import org.apache.commons.functor.UnaryFunction;
026 import org.apache.commons.functor.UnaryPredicate;
027
028 /**
029 * {@link #evaluate Evaluates} to constant value.
030 * <p>
031 * {@link #test Tests} to a constant value, assuming
032 * a boolean of Boolean value is supplied.
033 *
034 * Note that although this class implements
035 * {@link Serializable}, a given instance will
036 * only be truly <code>Serializable</code> if the
037 * constant <code>Object</code> is. Attempts to serialize
038 * an instance whose value is not
039 * <code>Serializable</code> will result in an exception.
040 * </p>
041 * @param <T> the returned value type.
042 * @version $Revision: 1160381 $ $Date: 2011-08-22 21:23:26 +0200 (Mon, 22 Aug 2011) $
043 * @author Rodney Waldhoff
044 */
045 public final class Constant<T> implements Function<T>, UnaryFunction<Object, T>, BinaryFunction<Object, Object, T>,
046 Predicate, UnaryPredicate<Object>, BinaryPredicate<Object, Object>, Serializable {
047
048 // static attributes
049 // ------------------------------------------------------------------------
050 /**
051 * Constant for <code>true</code>.
052 */
053 public static final Constant<Boolean> TRUE = of(true);
054
055 /**
056 * Constant for <code>false</code>.
057 */
058 public static final Constant<Boolean> FALSE = of(false);
059
060 /**
061 * serialVersionUID declaration.
062 */
063 private static final long serialVersionUID = -8754373778528773039L;
064
065 // attributes
066 // ------------------------------------------------------------------------
067 /**
068 * The constant value.
069 */
070 private final T value;
071
072 // constructor
073 // ------------------------------------------------------------------------
074
075 /**
076 * Create a new Constant.
077 * @param value Object
078 */
079 public Constant(T value) {
080 this.value = value;
081 }
082
083 // function interface
084 // ------------------------------------------------------------------------
085 /**
086 * {@inheritDoc}
087 */
088 public T evaluate() {
089 return value;
090 }
091
092 /**
093 * {@inheritDoc}
094 */
095 public T evaluate(Object obj) {
096 return evaluate();
097 }
098
099 /**
100 * {@inheritDoc}
101 */
102 public T evaluate(Object left, Object right) {
103 return evaluate();
104 }
105
106 /**
107 * {@inheritDoc}
108 */
109 public boolean test() {
110 return ((Boolean) evaluate()).booleanValue();
111 }
112
113 /**
114 * {@inheritDoc}
115 */
116 public boolean test(Object obj) {
117 return test();
118 }
119
120 /**
121 * {@inheritDoc}
122 */
123 public boolean test(Object left, Object right) {
124 return test();
125 }
126
127 /**
128 * {@inheritDoc}
129 */
130 public boolean equals(Object that) {
131 return that == this || (that instanceof Constant<?> && equals((Constant<?>) that));
132 }
133
134 /**
135 * Learn whether another Constant is equal to this.
136 * @param that Constant to test
137 * @return boolean
138 */
139 public boolean equals(Constant<?> that) {
140 return (null != that && (null == this.value ? null == that.value : this.value.equals(that.value)));
141 }
142
143 /**
144 * {@inheritDoc}
145 */
146 public int hashCode() {
147 int hash = "Constant".hashCode();
148 if (null != value) {
149 hash ^= value.hashCode();
150 }
151 return hash;
152 }
153
154 /**
155 * {@inheritDoc}
156 */
157 public String toString() {
158 return "Constant<" + String.valueOf(value) + ">";
159 }
160
161 // static methods
162 // ------------------------------------------------------------------------
163
164 /**
165 * Get a <code>Constant</code> that always
166 * returns <code>true</code>.
167 * @return a <code>Constant</code> that always
168 * returns <code>true</code>
169 */
170 public static Constant<Boolean> truePredicate() {
171 return TRUE;
172 }
173
174 /**
175 * Get a <code>Constant</code> that always
176 * returns <code>false</code>.
177 * @return a <code>Constant</code> that always
178 * returns <code>false</code>
179 */
180 public static Constant<Boolean> falsePredicate() {
181 return FALSE;
182 }
183
184 /**
185 * Get a <code>Constant</code> that always
186 * returns <i>value</i>.
187 * @param value the constant value
188 * @return a <code>Constant</code> that always
189 * returns <i>value</i>
190 */
191 public static Constant<Boolean> predicate(boolean value) {
192 return value ? TRUE : FALSE;
193 }
194
195 /**
196 * Get a Constant instance for the specified value.
197 * @param <T> the constant value
198 * @param value T
199 * @return Constant<T>
200 */
201 public static <T> Constant<T> of(T value) {
202 return new Constant<T>(value);
203 }
204
205 }