Difference between revisions of "Weight"

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

import java.io.Serializable;
import java.text.DecimalFormat;

/**
 * Represents a measurement of weight. When this object is serialised to/from JSON, it is done so using the
 * string form.
 */
public class Weight implements Comparable<Weight>, Serializable {

    private static final String NUMBER_FORMAT = "0.####";
    private double value = 0;
    private Units units = Units.G;

    /**
     * Create a zero-metre weight.
     */
    public Weight() {
    }

    /**
     * Create a weight.
     *
     * @param value The number of units.
     * @param units The units to use.
     */
    public Weight(double value, Units units) {
        setValue(value);
        setUnits(units);
    }

    /**
     * Parse the input and create a weight from it. If no units are provided, grammes are assumed. This is the
     * method that Jackson will use to create Weight objects from a JSON value.
     *
     * @param text The textual version of a weight.
     * @return A new weight object.
     * @throws IllegalArgumentException if the given string cannot be parsed.
     */
    @JsonCreator
    public static Weight parse(String text) {
        return parse(text, Units.G);
    }

    /**
     * Parse the input and create a weight from it. If no units are provided, the default units are assumed.
     *
     * @param text         The textual version of a weight.
     * @param defaultUnits The units to use if none is provided.
     * @return A new weight object.
     * @throws IllegalArgumentException if the given string cannot be parsed.
     */
    public static Weight parse(String text, Units defaultUnits) {
        Units foundUnits = null;
        if (text.endsWith(Units.KG.getSymbol())) foundUnits = Units.KG;
        else if (text.endsWith(Units.G.getSymbol())) foundUnits = Units.G;
        else if (text.endsWith(Units.LBS.getSymbol())) foundUnits = Units.LBS;
        if (foundUnits != null) {
            int index = text.lastIndexOf(foundUnits.getSymbol());
            String amountString = text.substring(0, index);
            try {
                return new Weight(Double.parseDouble(amountString), foundUnits);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("No a valid weight: '" + text + "'");
            }
        } else {
            try {
                return new Weight(Double.parseDouble(text), defaultUnits);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("No a valid weight: '" + text + "'");
            }
        }
    }

    /**
     * Convert one weight value into another.
     *
     * @param in   The value to convert.
     * @param from The origin units.
     * @param to   The destination units.
     * @return The converted value.
     */
    static double convert(double in, Units from, Units to) {
        return in * from.getScaleFactor() / to.getScaleFactor();
    }

    /**
     * Get the weight in the current units.
     *
     * @return The weight in the current units.
     */
    public double getValue() {
        return value;
    }

    /**
     * Set the weight in the current units.
     *
     * @param value The weight in the current units.
     */
    public void setValue(double value) {
        this.value = value;
    }

    /**
     * Get the units used by this weight.
     *
     * @return The units used by this weight.
     */
    public Units getUnits() {
        return units;
    }

    /**
     * Set the units used by this weight (without affecting the value).
     *
     * @param units The units used by this weight.
     */
    public void setUnits(Units units) {
        this.units = units;
    }

    /**
     * Convert this weight into one with different units.
     *
     * @param newUnits The desired units.
     * @return The new weight, in the desired units.
     */
    public Weight convertTo(Units newUnits) {
        return new Weight(convert(this.value, this.units, newUnits), newUnits);
    }

    /**
     * Add a weight to this one.
     *
     * @param weight The weight to add.
     * @return A new weight, representing the sum of the weights, in the units of the original.
     */
    public Weight add(Weight weight) {
        return new Weight(this.getInternalValue() + weight.getInternalValue(), Units.G)
            .convertTo(this.units);
    }

    /**
     * Format this weight as a string. A space will be inserted between the value and the unit symbol. This method
     * is called when serializing this object to a JSON value.
     *
     * @return The textual version of this weight.
     */
    @JsonValue
    public String toString() {
        return new DecimalFormat(NUMBER_FORMAT).format(getValue()) + " " + getUnits().getSymbol();
    }

    /**
     * Get the value (in grammes) used to compare.
     *
     * @return The number of grammes this weight represents.
     */
    double getInternalValue() {
        if (units == Units.G) {
            return value;
        } else {
            return convert(value, units, Units.G);
        }
    }

    /**
     * Compare two weight.
     *
     * @param o The weight to compare.
     * @return Zero if they're the same, -1 if this value is smaller than the argument, +1 if larger.
     */
    @Override
    public int compareTo(Weight o) {
        if (o == null) {
            return 1;
        } else {
            double lhs = getInternalValue();
            double rhs = o.getInternalValue();
            if (lhs < rhs) {
                return -1;
            } else if (lhs > rhs) {
                return 1;
            } else {
                return 0;
            }
        }
    }

    /**
     * Compare two weights for equality.
     *
     * @param obj The object to check.
     * @return True if they're the same, false otherwise.
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        } else if (obj instanceof Weight) {
            return this.getInternalValue() == ((Weight) obj).getInternalValue();
        } else {
            return false;
        }
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        int result = 17;
        result ^= 31 * Double.hashCode(value);
        result ^= 31 * units.hashCode();
        return result;
    }

    /**
     * The units of weight. By default, grammes are assumed.
     */
    public enum Units {
        /**
         * Grammes
         */
        G("g", 1),
        /**
         * Kilogrammes
         */
        KG("kg", 1000),
        /**
         * Ounces
         */
        OZ("oz", 28.3495),
        /**
         * Pounds
         */
        LBS("lbs", 453.592);

        private double scaleFactor;
        private String symbol;

        Units(String symbol, double scaleFactor) {
            this.symbol = symbol;
            this.scaleFactor = scaleFactor;
        }

        /**
         * Get the number of metres represented by this unit.
         *
         * @return The number of metres represented by this unit.
         */
        public double getScaleFactor() {
            return scaleFactor;
        }

        /**
         * Get the standard symbol for this unit.
         *
         * @return The standard symbol for this unit.
         */
        public String getSymbol() {
            return symbol;
        }
    }

}