tec.uom.se.function.QuantityFunctions Maven / Gradle / Ivy
/*
* 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.function;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collector;
import javax.measure.Quantity;
import javax.measure.Unit;
/**
* @author Otavio
* @author Werner
* @version 1.0
* @since 1.0
*
*/
@SuppressWarnings("rawtypes")
public final class QuantityFunctions {
private QuantityFunctions() {
}
/**
* Creates a comparator to sort by number, ignoring the unit.
*
* @return
* Given:
*
*
* Quantity
*
* will return: day, hours, minutes, seconds
*
* @throws NullPointerException
*/
public static > Comparator> sortNumber() {
return (q1, q2) -> Double.compare(q1.getValue().doubleValue(), q2.getValue().doubleValue());
}
/**
* Creates a comparator to sort by number descending, ignoring the unit.
*
* @return
* Given:
*
*
* Quantity
*
* will return: seconds, hours, minutes, day
*
* @throws NullPointerException
*/
public static > Comparator> sortNumberDesc() {
Comparator> sortNumber = sortNumber();
return sortNumber.reversed();
}
/**
* Creates a comparator to sort by name, ignoring the value.
*
* @return
* Given:
*
*
* Quantity
*
* will return: day, hours, minutes, seconds
*
* @throws NullPointerException
*/
public static > Comparator> sortSymbol() {
return (q1, q2) -> q1.getUnit().getSymbol().compareTo(q2.getUnit().getSymbol());
}
/**
* Creates a comparator to sort by name descending, ignoring the value.
*
* @return
* Given:
*
*
* Quantity
*
* will return: seconds, minutes, hour, day
*
* @throws NullPointerException
*/
public static > Comparator> sortSymbolDesc() {
Comparator> sortSymbol = sortSymbol();
return sortSymbol.reversed();
}
/**
* Creates a comparator to sort by natural order, looking to both the unit and the value.
*
* @return
* Given:
*
*
* Quantity
*
* will return: seconds, minutes, hours, day
*
* @throws NullPointerException
*/
@SuppressWarnings("unchecked")
public static > Comparator> sortNatural() {
return new NaturalOrder();
}
/**
* Creates a comparator to sort by natural order descending, looking to both the unit and the value.
*
* @return
* Given:
*
*
* Quantity
*
* will return: day, hour, minute, second
*
* @throws NullPointerException
*/
public static > Comparator> sortNaturalDesc() {
Comparator> sortNatural = sortNatural();
return sortNatural.reversed();
}
/**
* Creates a BinaryOperator to calculate the minimum Quantity
*
* @return the min BinaryOperator, not null.
*/
public static > BinaryOperator> min() {
return (q1, q2) -> {
double d1 = q1.getValue().doubleValue();
double d2 = q2.to(q1.getUnit()).getValue().doubleValue();
double min = Double.min(d1, d2);
if (min == d1) {
return q1;
}
return q2;
};
}
/**
* Creates a BinaryOperator to calculate the maximum Quantity
*
* @return the max BinaryOperator, not null.
*/
public static > BinaryOperator> max() {
return (q1, q2) -> {
double d1 = q1.getValue().doubleValue();
double d2 = q2.to(q1.getUnit()).getValue().doubleValue();
double min = Double.max(d1, d2);
if (min == d1) {
return q1;
}
return q2;
};
}
/**
* Creates a BinaryOperator to sum.
*
* @return the sum BinaryOperator
*/
public static > BinaryOperator> sum() {
return Quantity::add;
}
/**
* Creates a BinaryOperator to sum converting to unit
*
* @param unit
* unit to be converting
* @return the sum BinaryOperator converting to unit
*/
public static > BinaryOperator> sum(Unit unit) {
return (q1, q2) -> q1.to(unit).add(q2.to(unit));
}
/**
* Predicate to filter to one or more units
*
* @param units
* - units to be filtered (optional)
* @return A predicate to filter one or more units
*/
@SafeVarargs
public static > Predicate> fiterByUnit(Unit... units) {
if (Objects.isNull(units) || units.length == 0) {
return q -> true;
}
Predicate> predicate = null;
for (Unit u : units) {
if (Objects.isNull(predicate)) {
predicate = q -> q.getUnit().equals(u);
} else {
predicate = predicate.or(q -> q.getUnit().equals(u));
}
}
return predicate;
}
/**
* Predicate to filter excluding these units
*
* @param units
* - units to be filtered (optional)
* @return A predicate to filter to not be these units
*/
@SafeVarargs
public static > Predicate> fiterByExcludingUnit(Unit... units) {
if (Objects.isNull(units) || units.length == 0) {
return q -> true;
}
return fiterByUnit(units).negate();
}
/**
* creates a Filter to greater than number, ignoring units
*
* @param value
* - the value to be used in Predicate
* @return the Predicate greater than this number, ignoring units
*/
public static > Predicate> isGreaterThan(Number value) {
return q -> q.getValue().doubleValue() > value.doubleValue();
}
/**
* creates a filter to greater than the quantity measure
*
* @param quantity
* - the measure to be used in filter
* @return the Predicate greater than this measure
*/
public static > Predicate> isGreaterThan(Quantity quantity) {
return q -> q.to(quantity.getUnit()).getValue().doubleValue() > quantity.getValue().doubleValue();
}
/**
* creates a Filter to greater or equals than number, ignoring units
*
* @param value
* - the value to be used in Predicate
* @return the Predicate greater or equals than this number, ignoring units
*/
public static > Predicate> isGreaterThanOrEqualTo(Number value) {
return q -> q.getValue().doubleValue() >= value.doubleValue();
}
/**
* creates a filter to greater or equals than the quantity measure
*
* @param quantity
* - the measure to be used in filter
* @return the Predicate greater or equals than this measure
*/
public static > Predicate> isGreaterThanOrEqualTo(Quantity quantity) {
return q -> q.to(quantity.getUnit()).getValue().doubleValue() >= quantity.getValue().doubleValue();
}
/**
* creates a Filter to lesser than number, ignoring units
*
* @param value
* - the value to be used in Predicate
* @return the Predicate greater than this number, ignoring units
*/
public static > Predicate> isLesserThan(Number value) {
return q -> q.getValue().doubleValue() < value.doubleValue();
}
/**
* creates a filter to lesser than the quantity measure
*
* @param quantity
* - the measure to be used in filter
* @return the Predicate lesser than this measure
*/
public static > Predicate> isLesserThan(Quantity quantity) {
return q -> q.to(quantity.getUnit()).getValue().doubleValue() < quantity.getValue().doubleValue();
}
/**
* creates a Filter to lesser or equals than number, ignoring units
*
* @param value
* - the value to be used in Predicate
* @return the Predicate lesser or equals than this number, ignoring units
*/
public static > Predicate> isLesserThanOrEqualTo(Number value) {
return q -> q.getValue().doubleValue() <= value.doubleValue();
}
/**
* creates a filter to lesser or equals than the quantity measure
*
* @param quantity
* - the measure to be used in filter
* @return the Predicate lesser or equals than this measure
*/
public static > Predicate> isLesserThanOrEqualTo(Quantity quantity) {
return q -> q.to(quantity.getUnit()).getValue().doubleValue() <= quantity.getValue().doubleValue();
}
/**
* creates a Filter to between, lesser or equals and greater or equals, than number, ignoring units
*
* @param min
* - the min value to be used in Predicate
* @param max
* - the max value to be used in Predicate
* @return the Predicate lesser or equals than this number, ignoring units
*/
public static > Predicate> isBetween(Number min, Number max) {
Predicate> minFilter = isGreaterThanOrEqualTo(min);
Predicate> maxFilter = isLesserThanOrEqualTo(max);
return minFilter.and(maxFilter);
}
/**
* creates a filter to between, lesser or equals and greater or equals, than the quantity measure
*
* @param min
* - the min value to be used in Predicate
* @param max
* - the max value to be used in Predicate
* @return the Predicate lesser or equals than this measure
*/
public static > Predicate> isBetween(Quantity min, Quantity max) {
return isGreaterThanOrEqualTo(min).and(isLesserThanOrEqualTo(max));
}
/**
* Summary of Quantity
*
* @return the QuantitySummaryStatistics
*/
public static > Collector, QuantitySummaryStatistics, QuantitySummaryStatistics> summarizeQuantity(
Unit unit) {
Supplier> supplier = () -> new QuantitySummaryStatistics<>(unit);
return Collector.of(supplier, QuantitySummaryStatistics::accept, QuantitySummaryStatistics::combine);
}
public static > Function, Unit> groupByUnit() {
return Quantity::getUnit;
}
}