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 */
017package 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 */
027public 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(final 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(final 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(final String value) {
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    @Override
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(final 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    @Override
106    public void setValue(final Number value) {
107        this.value = value.floatValue();
108    }
109
110    //-----------------------------------------------------------------------
111    /**
112     * Checks whether the float value is the special NaN value.
113     *
114     * @return true if NaN
115     */
116    public boolean isNaN() {
117        return Float.isNaN(value);
118    }
119
120    /**
121     * Checks whether the float value is infinite.
122     *
123     * @return true if infinite
124     */
125    public boolean isInfinite() {
126        return Float.isInfinite(value);
127    }
128
129    //-----------------------------------------------------------------------
130    /**
131     * Increments the value.
132     *
133     * @since 2.2
134     */
135    public void increment() {
136        value++;
137    }
138
139    /**
140     * Increments this instance's value by 1; this method returns the value associated with the instance
141     * immediately prior to the increment operation. This method is not thread safe.
142     *
143     * @return the value associated with the instance before it was incremented
144     * @since 3.5
145     */
146    public float getAndIncrement() {
147        final float last = value;
148        value++;
149        return last;
150    }
151
152    /**
153     * Increments this instance's value by 1; this method returns the value associated with the instance
154     * immediately after the increment operation. This method is not thread safe.
155     *
156     * @return the value associated with the instance after it is incremented
157     * @since 3.5
158     */
159    public float incrementAndGet() {
160        value++;
161        return value;
162    }
163
164    /**
165     * Decrements the value.
166     *
167     * @since 2.2
168     */
169    public void decrement() {
170        value--;
171    }
172
173    /**
174     * Decrements this instance's value by 1; this method returns the value associated with the instance
175     * immediately prior to the decrement operation. This method is not thread safe.
176     *
177     * @return the value associated with the instance before it was decremented
178     * @since 3.5
179     */
180    public float getAndDecrement() {
181        final float last = value;
182        value--;
183        return last;
184    }
185
186    /**
187     * Decrements this instance's value by 1; this method returns the value associated with the instance
188     * immediately after the decrement operation. This method is not thread safe.
189     *
190     * @return the value associated with the instance after it is decremented
191     * @since 3.5
192     */
193    public float decrementAndGet() {
194        value--;
195        return value;
196    }
197
198    //-----------------------------------------------------------------------
199    /**
200     * Adds a value to the value of this instance.
201     *
202     * @param operand  the value to add, not null
203     * @since 2.2
204     */
205    public void add(final float operand) {
206        this.value += operand;
207    }
208
209    /**
210     * Adds a value to the value of this instance.
211     *
212     * @param operand  the value to add, not null
213     * @throws NullPointerException if the object is null
214     * @since 2.2
215     */
216    public void add(final Number operand) {
217        this.value += operand.floatValue();
218    }
219
220    /**
221     * Subtracts a value from the value of this instance.
222     *
223     * @param operand  the value to subtract
224     * @since 2.2
225     */
226    public void subtract(final float operand) {
227        this.value -= operand;
228    }
229
230    /**
231     * Subtracts a value from the value of this instance.
232     *
233     * @param operand  the value to subtract, not null
234     * @throws NullPointerException if the object is null
235     * @since 2.2
236     */
237    public void subtract(final Number operand) {
238        this.value -= operand.floatValue();
239    }
240
241    /**
242     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
243     * immediately after the addition operation. This method is not thread safe.
244     *
245     * @param operand the quantity to add, not null
246     * @return the value associated with this instance after adding the operand
247     * @since 3.5
248     */
249    public float addAndGet(final float operand) {
250        this.value += operand;
251        return value;
252    }
253
254    /**
255     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
256     * immediately after the addition operation. This method is not thread safe.
257     *
258     * @param operand the quantity to add, not null
259     * @throws NullPointerException if {@code operand} is null
260     * @return the value associated with this instance after adding the operand
261     * @since 3.5
262     */
263    public float addAndGet(final Number operand) {
264        this.value += operand.floatValue();
265        return value;
266    }
267
268    /**
269     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
270     * immediately prior to the addition operation. This method is not thread safe.
271     *
272     * @param operand the quantity to add, not null
273     * @return the value associated with this instance immediately before the operand was added
274     * @since 3.5
275     */
276    public float getAndAdd(final float operand) {
277        final float last = value;
278        this.value += operand;
279        return last;
280    }
281
282    /**
283     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
284     * immediately prior to the addition operation. This method is not thread safe.
285     *
286     * @param operand the quantity to add, not null
287     * @throws NullPointerException if {@code operand} is null
288     * @return the value associated with this instance immediately before the operand was added
289     * @since 3.5
290     */
291    public float getAndAdd(final Number operand) {
292        final float last = value;
293        this.value += operand.floatValue();
294        return last;
295    }
296
297    //-----------------------------------------------------------------------
298    // shortValue and byteValue rely on Number implementation
299    /**
300     * Returns the value of this MutableFloat as an int.
301     *
302     * @return the numeric value represented by this object after conversion to type int.
303     */
304    @Override
305    public int intValue() {
306        return (int) value;
307    }
308
309    /**
310     * Returns the value of this MutableFloat as a long.
311     *
312     * @return the numeric value represented by this object after conversion to type long.
313     */
314    @Override
315    public long longValue() {
316        return (long) value;
317    }
318
319    /**
320     * Returns the value of this MutableFloat as a float.
321     *
322     * @return the numeric value represented by this object after conversion to type float.
323     */
324    @Override
325    public float floatValue() {
326        return value;
327    }
328
329    /**
330     * Returns the value of this MutableFloat as a double.
331     *
332     * @return the numeric value represented by this object after conversion to type double.
333     */
334    @Override
335    public double doubleValue() {
336        return value;
337    }
338
339    //-----------------------------------------------------------------------
340    /**
341     * Gets this mutable as an instance of Float.
342     *
343     * @return a Float instance containing the value from this mutable, never null
344     */
345    public Float toFloat() {
346        return Float.valueOf(floatValue());
347    }
348
349    //-----------------------------------------------------------------------
350    /**
351     * Compares this object against some other object. The result is <code>true</code> if and only if the argument is
352     * not <code>null</code> and is a <code>Float</code> object that represents a <code>float</code> that has the
353     * identical bit pattern to the bit pattern of the <code>float</code> represented by this object. For this
354     * purpose, two float values are considered to be the same if and only if the method
355     * {@link Float#floatToIntBits(float)}returns the same int value when applied to each.
356     * <p>
357     * Note that in most cases, for two instances of class <code>Float</code>,<code>f1</code> and <code>f2</code>,
358     * the value of <code>f1.equals(f2)</code> is <code>true</code> if and only if <blockquote>
359     *
360     * <pre>
361     *   f1.floatValue() == f2.floatValue()
362     * </pre>
363     *
364     * </blockquote>
365     * <p>
366     * also has the value <code>true</code>. However, there are two exceptions:
367     * <ul>
368     * <li>If <code>f1</code> and <code>f2</code> both represent <code>Float.NaN</code>, then the
369     * <code>equals</code> method returns <code>true</code>, even though <code>Float.NaN==Float.NaN</code> has
370     * the value <code>false</code>.
371     * <li>If <code>f1</code> represents <code>+0.0f</code> while <code>f2</code> represents <code>-0.0f</code>,
372     * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though
373     * <code>0.0f==-0.0f</code> has the value <code>true</code>.
374     * </ul>
375     * This definition allows hashtables to operate properly.
376     *
377     * @param obj  the object to compare with, null returns false
378     * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
379     * @see java.lang.Float#floatToIntBits(float)
380     */
381    @Override
382    public boolean equals(final Object obj) {
383        return obj instanceof MutableFloat
384            && Float.floatToIntBits(((MutableFloat) obj).value) == Float.floatToIntBits(value);
385    }
386
387    /**
388     * Returns a suitable hash code for this mutable.
389     *
390     * @return a suitable hash code
391     */
392    @Override
393    public int hashCode() {
394        return Float.floatToIntBits(value);
395    }
396
397    //-----------------------------------------------------------------------
398    /**
399     * Compares this mutable to another in ascending order.
400     *
401     * @param other  the other mutable to compare to, not null
402     * @return negative if this is less, zero if equal, positive if greater
403     */
404    @Override
405    public int compareTo(final MutableFloat other) {
406        return Float.compare(this.value, other.value);
407    }
408
409    //-----------------------------------------------------------------------
410    /**
411     * Returns the String value of this mutable.
412     *
413     * @return the mutable value as a string
414     */
415    @Override
416    public String toString() {
417        return String.valueOf(value);
418    }
419
420}