panda.lang.mutable.MutableFloat Maven / Gradle / Ivy

Go to download
package panda.lang.mutable;

/**
 * A mutable float wrapper.
 * 
 * Note that as MutableFloat does not extend Float, it is not treated by String.format as a Float parameter. 
 * 
 */
public class MutableFloat extends Number implements Comparable, Mutable {

	/**
	 * Required for serialization support.
	 * 
	 * @see java.io.Serializable
	 */
	private static final long serialVersionUID = 5787169186L;

	/** The mutable value. */
	private float value;

	/**
	 * Constructs a new MutableFloat with the default value of zero.
	 */
	public MutableFloat() {
		super();
	}

	/**
	 * Constructs a new MutableFloat with the specified value.
	 * 
	 * @param value the initial value to store
	 */
	public MutableFloat(float value) {
		super();
		this.value = value;
	}

	/**
	 * Constructs a new MutableFloat with the specified value.
	 * 
	 * @param value the initial value to store, not null
	 * @throws NullPointerException if the object is null
	 */
	public MutableFloat(Number value) {
		super();
		this.value = value.floatValue();
	}

	/**
	 * Constructs a new MutableFloat parsing the given string.
	 * 
	 * @param value the string to parse, not null
	 * @throws NumberFormatException if the string cannot be parsed into a float
	 */
	public MutableFloat(String value) throws NumberFormatException {
		super();
		this.value = Float.parseFloat(value);
	}

	// -----------------------------------------------------------------------
	/**
	 * Gets the value as a Float instance.
	 * 
	 * @return the value as a Float, never null
	 */
	public Float getValue() {
		return Float.valueOf(this.value);
	}

	/**
	 * Sets the value.
	 * 
	 * @param value the value to set
	 */
	public void setValue(float value) {
		this.value = value;
	}

	/**
	 * Sets the value from any Number instance.
	 * 
	 * @param value the value to set, not null
	 * @throws NullPointerException if the object is null
	 */
	public void setValue(Number value) {
		this.value = value.floatValue();
	}

	// -----------------------------------------------------------------------
	/**
	 * Checks whether the float value is the special NaN value.
	 * 
	 * @return true if NaN
	 */
	public boolean isNaN() {
		return Float.isNaN(value);
	}

	/**
	 * Checks whether the float value is infinite.
	 * 
	 * @return true if infinite
	 */
	public boolean isInfinite() {
		return Float.isInfinite(value);
	}

	// -----------------------------------------------------------------------
	/**
	 * Increments the value.
	 */
	public void increment() {
		value++;
	}

	/**
	 * Decrements the value.
	 */
	public void decrement() {
		value--;
	}

	// -----------------------------------------------------------------------
	/**
	 * Adds a value to the value of this instance.
	 * 
	 * @param operand the value to add, not null
	 */
	public void add(float operand) {
		this.value += operand;
	}

	/**
	 * Adds a value to the value of this instance.
	 * 
	 * @param operand the value to add, not null
	 * @throws NullPointerException if the object is null
	 */
	public void add(Number operand) {
		this.value += operand.floatValue();
	}

	/**
	 * Subtracts a value from the value of this instance.
	 * 
	 * @param operand the value to subtract
	 */
	public void subtract(float operand) {
		this.value -= operand;
	}

	/**
	 * Subtracts a value from the value of this instance.
	 * 
	 * @param operand the value to subtract, not null
	 * @throws NullPointerException if the object is null
	 */
	public void subtract(Number operand) {
		this.value -= operand.floatValue();
	}

	// -----------------------------------------------------------------------
	// shortValue and byteValue rely on Number implementation
	/**
	 * Returns the value of this MutableFloat as an int.
	 * 
	 * @return the numeric value represented by this object after conversion to type int.
	 */
	@Override
	public int intValue() {
		return (int)value;
	}

	/**
	 * Returns the value of this MutableFloat as a long.
	 * 
	 * @return the numeric value represented by this object after conversion to type long.
	 */
	@Override
	public long longValue() {
		return (long)value;
	}

	/**
	 * Returns the value of this MutableFloat as a float.
	 * 
	 * @return the numeric value represented by this object after conversion to type float.
	 */
	@Override
	public float floatValue() {
		return value;
	}

	/**
	 * Returns the value of this MutableFloat as a double.
	 * 
	 * @return the numeric value represented by this object after conversion to type double.
	 */
	@Override
	public double doubleValue() {
		return value;
	}

	// -----------------------------------------------------------------------
	/**
	 * Gets this mutable as an instance of Float.
	 * 
	 * @return a Float instance containing the value from this mutable, never null
	 */
	public Float toFloat() {
		return Float.valueOf(floatValue());
	}

	// -----------------------------------------------------------------------
	/**
	 * Compares this object against some other object. The result is true if and only
	 * if the argument is not null and is a Float object that represents a
	 * float that has the identical bit pattern to the bit pattern of the
	 * float represented by this object. For this purpose, two float values are
	 * considered to be the same if and only if the method {@link Float#floatToIntBits(float)}
	 * returns the same int value when applied to each.
	 * 

	 * Note that in most cases, for two instances of class Float,f1 and
	 * f2, the value of f1.equals(f2) is true if and only if
	 * 

	 * 
	 * 	 * f1.floatValue() == f2.floatValue()
	 * 
	 * 
	 * 
	 * 
	 * also has the value true. However, there are two exceptions:
	 * 

	 * If f1 and f2 both represent Float.NaN, then the
	 * equals method returns true, even though
	 * Float.NaN==Float.NaN has the value false.
	 * 
If f1 represents +0.0f while f2 represents
	 * -0.0f, or vice versa, the equal test has the value
	 * false, even though 0.0f==-0.0f has the value true.
	 * 
	 * This definition allows hashtables to operate properly.
	 * 
	 * @param obj the object to compare with, null returns false
	 * @return true if the objects are the same; false otherwise.
	 * @see java.lang.Float#floatToIntBits(float)
	 */
	@Override
	public boolean equals(Object obj) {
		return obj instanceof MutableFloat
				&& Float.floatToIntBits(((MutableFloat)obj).value) == Float.floatToIntBits(value);
	}

	/**
	 * Returns a suitable hash code for this mutable.
	 * 
	 * @return a suitable hash code
	 */
	@Override
	public int hashCode() {
		return Float.floatToIntBits(value);
	}

	// -----------------------------------------------------------------------
	/**
	 * Compares this mutable to another in ascending order.
	 * 
	 * @param other the other mutable to compare to, not null
	 * @return negative if this is less, zero if equal, positive if greater
	 */
	public int compareTo(MutableFloat other) {
		float anotherVal = other.value;
		return Float.compare(value, anotherVal);
	}

	// -----------------------------------------------------------------------
	/**
	 * Returns the String value of this mutable.
	 * 
	 * @return the mutable value as a string
	 */
	@Override
	public String toString() {
		return String.valueOf(value);
	}

}