/*
* Copyright (C) 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.caliper.util;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Ascii;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.primitives.Longs;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.Nullable;
/**
* Represents a nonnegative duration from 0 to 100 days, with picosecond precision.
* Contrast with Joda-Time's duration class, which has only millisecond precision but can
* represent durations of millions of years.
*/
public abstract class ShortDuration implements Comparable<ShortDuration> {
// Factories
public static ShortDuration of(long duration, TimeUnit unit) {
if (duration == 0) {
return ZERO;
}
checkArgument(duration >= 0, "negative duration: %s", duration);
checkArgument(duration <= MAXES.get(unit),
"ShortDuration cannot exceed 100 days: %s %s", duration, unit);
long nanos = TimeUnit.NANOSECONDS.convert(duration, unit);
return new PositiveShortDuration(nanos * 1000);
}
public static ShortDuration of(BigDecimal duration, TimeUnit unit) {
// convert to picoseconds first, to minimize rounding
BigDecimal picos = duration.multiply(ONE_IN_PICOS.get(unit));
return ofPicos(toLong(picos, RoundingMode.HALF_UP));
}
public static ShortDuration valueOf(String s) {
if ("0".equals(s)) {
return ZERO;
}
Matcher matcher = PATTERN.matcher(s);
checkArgument(matcher.matches(), "Invalid ShortDuration: %s", s);
BigDecimal value = new BigDecimal(matcher.group(1));
String abbrev = matcher.group(2);
TimeUnit unit = ABBREV_TO_UNIT.get(abbrev);
checkArgument(unit != null, "Unrecognized time unit: %s", abbrev);
return of(value, unit);
}
public static ShortDuration zero() {
return ZERO;
}
// fortunately no abbreviation starts with 'e', so this should work
private static final Pattern PATTERN = Pattern.compile("^([0-9.eE+-]+) ?(\\S+)$");
private static ShortDuration ofPicos(long picos) {
if (picos == 0) {
return ZERO;
}
checkArgument(picos > 0);
return new PositiveShortDuration(picos);
}
// TODO(kevinb): we sure seem to convert back and forth with BigDecimal a lot.
// Why not just *make* this a BigDecimal?
final long picos;
ShortDuration(long picos) {
this.picos = picos;
}
public long toPicos() {
return picos;
}
public long to(TimeUnit unit) {
return to(unit, RoundingMode.HALF_UP);
}
public abstract long to(TimeUnit unit, RoundingMode roundingMode);
/*
* In Guava, this will probably implement an interface called Quantity, and the following methods
* will come from there, so they won't have to be defined here.
*/
/**
* Returns an instance of this type that represents the sum of this value and {@code
* addend}.
*/
public abstract ShortDuration plus(ShortDuration addend);
/**
* Returns an instance of this type that represents the difference of this value and
* {@code subtrahend}.
*/
public abstract ShortDuration minus(ShortDuration subtrahend);
/**
* Returns an instance of this type that represents the product of this value and the
* integral value {@code multiplicand}.
*/
public abstract ShortDuration times(long multiplicand);
/**
* Returns an instance of this type that represents the product of this value and {@code
* multiplicand}, rounded according to {@code roundingMode} if necessary.
*
* <p>If this class represents an amount that is "continuous" rather than discrete, the
* implementation of this method may simply ignore the rounding mode.
*/
public abstract ShortDuration times(BigDecimal multiplicand, RoundingMode roundingMode);
/**
* Returns an instance of this type that represents this value divided by the integral
* value {@code divisor}, rounded according to {@code roundingMode} if necessary.
*
* <p>If this class represents an amount that is "continuous" rather than discrete, the
* implementation of this method may simply ignore the rounding mode.
*/
public abstract ShortDuration dividedBy(long divisor, RoundingMode roundingMode);
/**
* Returns an instance of this type that represents this value divided by {@code
* divisor}, rounded according to {@code roundingMode} if necessary.
*
* <p>If this class represents an amount that is "continuous" rather than discrete, the
* implementation of this method may simply ignore the rounding mode.
*/
public abstract ShortDuration dividedBy(BigDecimal divisor, RoundingMode roundingMode);
// Zero
private static ShortDuration ZERO = new ShortDuration(0) {
@Override public long to(TimeUnit unit, RoundingMode roundingMode) {
return 0;
}
@Override public ShortDuration plus(ShortDuration addend) {
return addend;
}
@Override public ShortDuration minus(ShortDuration subtrahend) {
checkArgument(this == subtrahend);
return this;
}
@Override public ShortDuration times(long multiplicand) {
return this;
}
@Override public ShortDuration times(BigDecimal multiplicand, RoundingMode roundingMode) {
return this;
}
@Override public ShortDuration dividedBy(long divisor, RoundingMode roundingMode) {
return dividedBy(new BigDecimal(divisor), roundingMode);
}
@Override public ShortDuration dividedBy(BigDecimal divisor, RoundingMode roundingMode) {
checkArgument(divisor.compareTo(BigDecimal.ZERO) != 0);
return this;
}
@Override public int compareTo(ShortDuration that) {
if (this == that) {
return 0;
}
checkNotNull(that);
return -1;
}
@Override public boolean equals(@Nullable Object that) {
return this == that;
}
@Override public int hashCode() {
return 0;
}
@Override public String toString() {
return "0s";
}
};
// Non-zero
private static class PositiveShortDuration extends ShortDuration {
private PositiveShortDuration(long picos) {
super(picos);
checkArgument(picos > 0);
}
@Override public long to(TimeUnit unit, RoundingMode roundingMode) {
BigDecimal divisor = ONE_IN_PICOS.get(unit);
return toLong(new BigDecimal(picos).divide(divisor), roundingMode);
}
@Override public ShortDuration plus(ShortDuration addend) {
return new PositiveShortDuration(picos + addend.picos);
}
@Override public ShortDuration minus(ShortDuration subtrahend) {
return ofPicos(picos - subtrahend.picos);
}
@Override public ShortDuration times(long multiplicand) {
if (multiplicand == 0) {
return ZERO;
}
checkArgument(multiplicand >= 0, "negative multiplicand: %s", multiplicand);
checkArgument(multiplicand <= Long.MAX_VALUE / picos,
"product of %s and %s would overflow", this, multiplicand);
return new PositiveShortDuration(picos * multiplicand);
}
@Override public ShortDuration times(BigDecimal multiplicand, RoundingMode roundingMode) {
BigDecimal product = BigDecimal.valueOf(picos).multiply(multiplicand);
return ofPicos(toLong(product, roundingMode));
}
@Override public ShortDuration dividedBy(long divisor, RoundingMode roundingMode) {
return dividedBy(new BigDecimal(divisor), roundingMode);
}
@Override public ShortDuration dividedBy(BigDecimal divisor, RoundingMode roundingMode) {
BigDecimal product = BigDecimal.valueOf(picos).divide(divisor, roundingMode);
return ofPicos(product.longValueExact());
}
@Override public int compareTo(ShortDuration that) {
return Longs.compare(this.picos, that.picos);
}
@Override public boolean equals(Object object) {
if (object instanceof PositiveShortDuration) {
PositiveShortDuration that = (PositiveShortDuration) object;
return this.picos == that.picos;
}
return false;
}
@Override public int hashCode() {
return Longs.hashCode(picos);
}
@Override public String toString() {
TimeUnit bestUnit = TimeUnit.NANOSECONDS;
for (TimeUnit unit : TimeUnit.values()) {
if (picosIn(unit) > picos) {
break;
}
bestUnit = unit;
}
BigDecimal divisor = ONE_IN_PICOS.get(bestUnit);
return new BigDecimal(picos).divide(divisor, ROUNDER) + preferredAbbrev(bestUnit);
}
private static final MathContext ROUNDER = new MathContext(4);
}
// Private parts
private static String preferredAbbrev(TimeUnit bestUnit) {
return ABBREVIATIONS.get(bestUnit).get(0);
}
private static final ImmutableListMultimap<TimeUnit, String> ABBREVIATIONS =
createAbbreviations();
private static ImmutableListMultimap<TimeUnit, String> createAbbreviations() {
ImmutableListMultimap.Builder<TimeUnit, String> builder = ImmutableListMultimap.builder();
builder.putAll(TimeUnit.NANOSECONDS, "ns", "nanos");
builder.putAll(TimeUnit.MICROSECONDS, "\u03bcs" /*μs*/, "us", "micros");
builder.putAll(TimeUnit.MILLISECONDS, "ms", "millis");
builder.putAll(TimeUnit.SECONDS, "s", "sec");
// Do the rest in a JDK5-safe way
TimeUnit[] allUnits = TimeUnit.values();
if (allUnits.length >= 7) {
builder.putAll(allUnits[4], "m", "min");
builder.putAll(allUnits[5], "h", "hr");
builder.putAll(allUnits[6], "d");
}
for (TimeUnit unit : TimeUnit.values()) {
builder.put(unit, Ascii.toLowerCase(unit.name()));
}
return builder.build();
}
private static final Map<String, TimeUnit> ABBREV_TO_UNIT = createAbbrevToUnitMap();
private static Map<String, TimeUnit> createAbbrevToUnitMap() {
ImmutableMap.Builder<String, TimeUnit> builder = ImmutableMap.builder();
for (Map.Entry<TimeUnit, String> entry : ABBREVIATIONS.entries()) {
builder.put(entry.getValue(), entry.getKey());
}
return builder.build();
}
private static final Map<TimeUnit, BigDecimal> ONE_IN_PICOS = createUnitToPicosMap();
private static Map<TimeUnit, BigDecimal> createUnitToPicosMap() {
Map<TimeUnit, BigDecimal> map = Maps.newEnumMap(TimeUnit.class);
for (TimeUnit unit : TimeUnit.values()) {
map.put(unit, new BigDecimal(picosIn(unit)));
}
return Collections.unmodifiableMap(map);
}
private static final Map<TimeUnit, Long> MAXES = createMaxesMap();
private static Map<TimeUnit, Long> createMaxesMap() {
Map<TimeUnit, Long> map = Maps.newEnumMap(TimeUnit.class);
for (TimeUnit unit : TimeUnit.values()) {
// Max is 100 days
map.put(unit, unit.convert(100L * 24 * 60 * 60, TimeUnit.SECONDS));
}
return Collections.unmodifiableMap(map);
}
private static long toLong(BigDecimal bd, RoundingMode roundingMode) {
// setScale does not really mutate the BigDecimal
return bd.setScale(0, roundingMode).longValueExact();
}
private static long picosIn(TimeUnit unit) {
return unit.toNanos(1000);
}
}