Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Units of Measurement Implementation for Java SE
* Copyright (c) 2005-2018, Jean-Marie Dautelle, Werner Keil, Otavio Santana.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
* and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of JSR-363 nor the names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package tec.uom.se.quantity;
import java.io.Serializable;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.Objects;
import javax.measure.Quantity;
import javax.measure.UnconvertibleException;
import javax.measure.Unit;
import javax.measure.UnitConverter;
import tec.uom.se.AbstractQuantity;
import tec.uom.se.ComparableQuantity;
/**
* An amount of quantity, implementation of {@link ComparableQuantity} that keep {@link Number} as possible otherwise converts to
* {@link DecimalQuantity}, this object is immutable.
*
* @see AbstractQuantity
* @see Quantity
* @see ComparableQuantity
* @param
* The type of the quantity.
* @author otaviojava
* @author Werner Keil
* @version 1.0.1, $Date: 2017-05-28 $
* @since 1.0
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public class NumberQuantity> extends AbstractQuantity implements Serializable {
private static final long serialVersionUID = 7312161895652321241L;
private final Number value;
/**
* Indicates if this quantity is big.
*/
private final boolean isBig;
protected NumberQuantity(Number number, Unit unit) {
super(unit);
value = number;
isBig = number instanceof BigDecimal || number instanceof BigInteger;
}
@Override
public double doubleValue(Unit unit) {
Unit myUnit = getUnit();
try {
UnitConverter converter = myUnit.getConverterTo(unit);
return converter.convert(getValue().doubleValue());
} catch (UnconvertibleException e) {
throw e;
}
}
@Override
public Number getValue() {
return value;
}
/**
* Indicates if this measured amount is a big number, i.E. BigDecimal or BigInteger. In all other cases this would be false.
*
* @return true if this quantity is big; false otherwise.
*/
@Override
public boolean isBig() {
return isBig;
}
@Override
public ComparableQuantity add(Quantity that) {
return toDecimalQuantity().add(that);
}
@Override
public ComparableQuantity multiply(Quantity that) {
return toDecimalQuantity().multiply(that);
}
@Override
public ComparableQuantity multiply(Number that) {
return toDecimalQuantity().multiply(that);
}
@Override
public ComparableQuantity divide(Quantity that) {
return toDecimalQuantity().divide(that);
}
@Override
public ComparableQuantity divide(Number that) {
return toDecimalQuantity().divide(that);
}
@Override
public ComparableQuantity inverse() {
return new NumberQuantity((getValue() instanceof BigDecimal ? BigDecimal.ONE.divide((BigDecimal) getValue()) : 1d / getValue().doubleValue()),
getUnit().inverse());
}
@Override
public BigDecimal decimalValue(Unit unit, MathContext ctx) throws ArithmeticException {
if (value instanceof BigDecimal) {
return (BigDecimal) value;
}
if (value instanceof BigInteger) {
return new BigDecimal((BigInteger) value);
}
return BigDecimal.valueOf(value.doubleValue());
}
@Override
public ComparableQuantity subtract(Quantity that) {
return toDecimalQuantity().subtract(that);
}
private DecimalQuantity toDecimalQuantity() {
return new DecimalQuantity<>(BigDecimal.valueOf(value.doubleValue()), getUnit());
}
/**
* Returns the scalar quantity for the specified long stated in the specified unit.
*
* @param longValue
* the quantity value.
* @param unit
* the measurement unit.
* @return the corresponding int quantity.
*/
public static > AbstractQuantity of(long longValue, Unit unit) {
return new LongQuantity(longValue, unit);
}
/**
* Returns the scalar quantity for the specified int stated in the specified unit.
*
* @param intValue
* the quantity value.
* @param unit
* the measurement unit.
* @return the corresponding int quantity.
*/
public static > AbstractQuantity of(int intValue, Unit unit) {
return new IntegerQuantity(intValue, unit);
}
/**
* Returns the scalar quantity for the specified short stated in the specified unit.
*
* @param value
* the quantity value.
* @param unit
* the measurement unit.
* @return the corresponding short quantity.
*/
public static > AbstractQuantity of(short value, Unit unit) {
return new ShortQuantity(value, unit);
}
/**
* Returns the scalar quantity for the specified byte stated in the specified unit.
*
* @param value
* the quantity value.
* @param unit
* the measurement unit.
* @return the corresponding byte quantity.
*/
public static > AbstractQuantity of(byte value, Unit unit) {
return new ByteQuantity(value, unit);
}
/**
* Returns the scalar quantity for the specified float stated in the specified unit.
*
* @param floatValue
* the measurement value.
* @param unit
* the measurement unit.
* @return the corresponding float quantity.
*/
public static > AbstractQuantity of(float floatValue, Unit unit) {
return new FloatQuantity(floatValue, unit);
}
/**
* Returns the scalar quantity for the specified double stated in the specified unit.
*
* @param doubleValue
* the measurement value.
* @param unit
* the measurement unit.
* @return the corresponding double quantity.
*/
public static > AbstractQuantity of(double doubleValue, Unit unit) {
return new DoubleQuantity(doubleValue, unit);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Quantity) {
Quantity that = (Quantity) obj;
return Objects.equals(getUnit(), that.getUnit()) && Equalizer.hasEquality(value, that.getValue());
}
return false;
}
}