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