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