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.lang3.mutable;
018
019 /**
020 * A mutable <code>float</code> wrapper.
021 *
022 * @see Float
023 * @since 2.1
024 * @author Apache Software Foundation
025 * @version $Id: MutableFloat.java 916081 2010-02-25 01:28:13Z niallp $
026 */
027 public class MutableFloat extends Number implements Comparable<MutableFloat>, Mutable<Number> {
028
029 /**
030 * Required for serialization support.
031 *
032 * @see java.io.Serializable
033 */
034 private static final long serialVersionUID = 5787169186L;
035
036 /** The mutable value. */
037 private float value;
038
039 /**
040 * Constructs a new MutableFloat with the default value of zero.
041 */
042 public MutableFloat() {
043 super();
044 }
045
046 /**
047 * Constructs a new MutableFloat with the specified value.
048 *
049 * @param value the initial value to store
050 */
051 public MutableFloat(float value) {
052 super();
053 this.value = value;
054 }
055
056 /**
057 * Constructs a new MutableFloat with the specified value.
058 *
059 * @param value the initial value to store, not null
060 * @throws NullPointerException if the object is null
061 */
062 public MutableFloat(Number value) {
063 super();
064 this.value = value.floatValue();
065 }
066
067 /**
068 * Constructs a new MutableFloat parsing the given string.
069 *
070 * @param value the string to parse, not null
071 * @throws NumberFormatException if the string cannot be parsed into a float
072 * @since 2.5
073 */
074 public MutableFloat(String value) throws NumberFormatException {
075 super();
076 this.value = Float.parseFloat(value);
077 }
078
079 //-----------------------------------------------------------------------
080 /**
081 * Gets the value as a Float instance.
082 *
083 * @return the value as a Float, never null
084 */
085 public Float getValue() {
086 return new Float(this.value);
087 }
088
089 /**
090 * Sets the value.
091 *
092 * @param value the value to set
093 */
094 public void setValue(float value) {
095 this.value = value;
096 }
097
098 /**
099 * Sets the value from any Number instance.
100 *
101 * @param value the value to set, not null
102 * @throws NullPointerException if the object is null
103 */
104 public void setValue(Number value) {
105 this.value = value.floatValue();
106 }
107
108 //-----------------------------------------------------------------------
109 /**
110 * Checks whether the float value is the special NaN value.
111 *
112 * @return true if NaN
113 */
114 public boolean isNaN() {
115 return Float.isNaN(value);
116 }
117
118 /**
119 * Checks whether the float value is infinite.
120 *
121 * @return true if infinite
122 */
123 public boolean isInfinite() {
124 return Float.isInfinite(value);
125 }
126
127 //-----------------------------------------------------------------------
128 /**
129 * Increments the value.
130 *
131 * @since Commons Lang 2.2
132 */
133 public void increment() {
134 value++;
135 }
136
137 /**
138 * Decrements the value.
139 *
140 * @since Commons Lang 2.2
141 */
142 public void decrement() {
143 value--;
144 }
145
146 //-----------------------------------------------------------------------
147 /**
148 * Adds a value to the value of this instance.
149 *
150 * @param operand the value to add, not null
151 * @since Commons Lang 2.2
152 */
153 public void add(float operand) {
154 this.value += operand;
155 }
156
157 /**
158 * Adds a value to the value of this instance.
159 *
160 * @param operand the value to add, not null
161 * @throws NullPointerException if the object is null
162 * @since Commons Lang 2.2
163 */
164 public void add(Number operand) {
165 this.value += operand.floatValue();
166 }
167
168 /**
169 * Subtracts a value from the value of this instance.
170 *
171 * @param operand the value to subtract
172 * @since Commons Lang 2.2
173 */
174 public void subtract(float operand) {
175 this.value -= operand;
176 }
177
178 /**
179 * Subtracts a value from the value of this instance.
180 *
181 * @param operand the value to subtract, not null
182 * @throws NullPointerException if the object is null
183 * @since Commons Lang 2.2
184 */
185 public void subtract(Number operand) {
186 this.value -= operand.floatValue();
187 }
188
189 //-----------------------------------------------------------------------
190 // shortValue and bytValue rely on Number implementation
191 /**
192 * Returns the value of this MutableFloat as an int.
193 *
194 * @return the numeric value represented by this object after conversion to type int.
195 */
196 @Override
197 public int intValue() {
198 return (int) value;
199 }
200
201 /**
202 * Returns the value of this MutableFloat as a long.
203 *
204 * @return the numeric value represented by this object after conversion to type long.
205 */
206 @Override
207 public long longValue() {
208 return (long) value;
209 }
210
211 /**
212 * Returns the value of this MutableFloat as a float.
213 *
214 * @return the numeric value represented by this object after conversion to type float.
215 */
216 @Override
217 public float floatValue() {
218 return value;
219 }
220
221 /**
222 * Returns the value of this MutableFloat as a double.
223 *
224 * @return the numeric value represented by this object after conversion to type double.
225 */
226 @Override
227 public double doubleValue() {
228 return value;
229 }
230
231 //-----------------------------------------------------------------------
232 /**
233 * Gets this mutable as an instance of Float.
234 *
235 * @return a Float instance containing the value from this mutable, never null
236 */
237 public Float toFloat() {
238 return Float.valueOf(floatValue());
239 }
240
241 //-----------------------------------------------------------------------
242 /**
243 * Compares this object against some other object. The result is <code>true</code> if and only if the argument is
244 * not <code>null</code> and is a <code>Float</code> object that represents a <code>float</code> that has the
245 * identical bit pattern to the bit pattern of the <code>float</code> represented by this object. For this
246 * purpose, two float values are considered to be the same if and only if the method
247 * {@link Float#floatToIntBits(float)}returns the same int value when applied to each.
248 * <p>
249 * Note that in most cases, for two instances of class <code>Float</code>,<code>f1</code> and <code>f2</code>,
250 * the value of <code>f1.equals(f2)</code> is <code>true</code> if and only if <blockquote>
251 *
252 * <pre>
253 * f1.floatValue() == f2.floatValue()
254 * </pre>
255 *
256 * </blockquote>
257 * <p>
258 * also has the value <code>true</code>. However, there are two exceptions:
259 * <ul>
260 * <li>If <code>f1</code> and <code>f2</code> both represent <code>Float.NaN</code>, then the
261 * <code>equals</code> method returns <code>true</code>, even though <code>Float.NaN==Float.NaN</code> has
262 * the value <code>false</code>.
263 * <li>If <code>f1</code> represents <code>+0.0f</code> while <code>f2</code> represents <code>-0.0f</code>,
264 * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though
265 * <code>0.0f==-0.0f</code> has the value <code>true</code>.
266 * </ul>
267 * This definition allows hashtables to operate properly.
268 *
269 * @param obj the object to compare with, null returns false
270 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
271 * @see java.lang.Float#floatToIntBits(float)
272 */
273 @Override
274 public boolean equals(Object obj) {
275 return (obj instanceof MutableFloat)
276 && (Float.floatToIntBits(((MutableFloat) obj).value) == Float.floatToIntBits(value));
277 }
278
279 /**
280 * Returns a suitable hash code for this mutable.
281 *
282 * @return a suitable hash code
283 */
284 @Override
285 public int hashCode() {
286 return Float.floatToIntBits(value);
287 }
288
289 //-----------------------------------------------------------------------
290 /**
291 * Compares this mutable to another in ascending order.
292 *
293 * @param other the other mutable to compare to, not null
294 * @return negative if this is less, zero if equal, positive if greater
295 */
296 public int compareTo(MutableFloat other) {
297 float anotherVal = other.value;
298 return Float.compare(value, anotherVal);
299 }
300
301 //-----------------------------------------------------------------------
302 /**
303 * Returns the String value of this mutable.
304 *
305 * @return the mutable value as a string
306 */
307 @Override
308 public String toString() {
309 return String.valueOf(value);
310 }
311
312 }