Move utils used by Duration and Timestamp from i.o.internal.Utils to TimeUtils.

This change breaks the circular dependency between io.opencensus.internal and
io.opencensus.common.

3 files changed, 38 insertions, 9 deletions

diff --git a/api/src/main/java/io/opencensus/common/Duration.java b/api/src/main/java/io/opencensus/common/Duration.java
index 2d90f506..4b7bb367 100644
--- a/api/src/main/java/io/opencensus/common/Duration.java
+++ b/api/src/main/java/io/opencensus/common/Duration.java
@@ -22,7 +22,6 @@ import static io.opencensus.common.TimeUtils.MILLIS_PER_SECOND;
 import static io.opencensus.common.TimeUtils.NANOS_PER_MILLI;
 
 import com.google.auto.value.AutoValue;
-import io.opencensus.internal.Utils;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.concurrent.Immutable;
 
@@ -115,11 +114,11 @@ public abstract class Duration implements Comparable<Duration> {
    */
   @Override
   public int compareTo(Duration otherDuration) {
-    int cmp = Utils.compareLongs(getSeconds(), otherDuration.getSeconds());
+    int cmp = TimeUtils.compareLongs(getSeconds(), otherDuration.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Utils.compareLongs(getNanos(), otherDuration.getNanos());
+    return TimeUtils.compareLongs(getNanos(), otherDuration.getNanos());
   }
 
   Duration() {}
diff --git a/api/src/main/java/io/opencensus/common/TimeUtils.java b/api/src/main/java/io/opencensus/common/TimeUtils.java
index 2429cc90..db119e2e 100644
--- a/api/src/main/java/io/opencensus/common/TimeUtils.java
+++ b/api/src/main/java/io/opencensus/common/TimeUtils.java
@@ -16,6 +16,8 @@
 
 package io.opencensus.common;
 
+import java.math.BigInteger;
+
 /** Util class for {@link Timestamp} and {@link Duration}. */
 final class TimeUtils {
   static final long MAX_SECONDS = 315576000000L;
@@ -25,4 +27,33 @@ final class TimeUtils {
   static final long NANOS_PER_SECOND = NANOS_PER_MILLI * MILLIS_PER_SECOND;
 
   private TimeUtils() {}
+
+  /**
+   * Compares two longs. This functionality is provided by {@code Long.compare(long, long)} in Java
+   * 7.
+   */
+  static int compareLongs(long x, long y) {
+    if (x < y) {
+      return -1;
+    } else if (x == y) {
+      return 0;
+    } else {
+      return 1;
+    }
+  }
+
+  private static final BigInteger MAX_LONG_VALUE = BigInteger.valueOf(Long.MAX_VALUE);
+  private static final BigInteger MIN_LONG_VALUE = BigInteger.valueOf(Long.MIN_VALUE);
+
+  /**
+   * Adds two longs and throws an {@link ArithmeticException} if the result overflows. This
+   * functionality is provided by {@code Math.addExact(long, long)} in Java 8.
+   */
+  static long checkedAdd(long x, long y) {
+    BigInteger sum = BigInteger.valueOf(x).add(BigInteger.valueOf(y));
+    if (sum.compareTo(MAX_LONG_VALUE) > 0 || sum.compareTo(MIN_LONG_VALUE) < 0) {
+      throw new ArithmeticException("Long sum overflow: x=" + x + ", y=" + y);
+    }
+    return x + y;
+  }
 }
diff --git a/api/src/main/java/io/opencensus/common/Timestamp.java b/api/src/main/java/io/opencensus/common/Timestamp.java
index 86c14cda..e3aae3a6 100644
--- a/api/src/main/java/io/opencensus/common/Timestamp.java
+++ b/api/src/main/java/io/opencensus/common/Timestamp.java
@@ -23,7 +23,6 @@ import static io.opencensus.common.TimeUtils.NANOS_PER_MILLI;
 import static io.opencensus.common.TimeUtils.NANOS_PER_SECOND;
 
 import com.google.auto.value.AutoValue;
-import io.opencensus.internal.Utils;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import javax.annotation.concurrent.Immutable;
@@ -153,11 +152,11 @@ public abstract class Timestamp implements Comparable<Timestamp> {
    */
   @Override
   public int compareTo(Timestamp otherTimestamp) {
-    int cmp = Utils.compareLongs(getSeconds(), otherTimestamp.getSeconds());
+    int cmp = TimeUtils.compareLongs(getSeconds(), otherTimestamp.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Utils.compareLongs(getNanos(), otherTimestamp.getNanos());
+    return TimeUtils.compareLongs(getNanos(), otherTimestamp.getNanos());
   }
 
   // Returns a Timestamp with the specified duration added.
@@ -165,8 +164,8 @@ public abstract class Timestamp implements Comparable<Timestamp> {
     if ((secondsToAdd | nanosToAdd) == 0) {
       return this;
     }
-    long epochSec = Utils.checkedAdd(getSeconds(), secondsToAdd);
-    epochSec = Utils.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
+    long epochSec = TimeUtils.checkedAdd(getSeconds(), secondsToAdd);
+    epochSec = TimeUtils.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
     nanosToAdd = nanosToAdd % NANOS_PER_SECOND;
     long nanoAdjustment = getNanos() + nanosToAdd; // safe int + NANOS_PER_SECOND
     return ofEpochSecond(epochSec, nanoAdjustment);
@@ -175,7 +174,7 @@ public abstract class Timestamp implements Comparable<Timestamp> {
   // Returns a Timestamp calculated using seconds from the epoch and nanosecond fraction of
   // second (arbitrary number of nanoseconds).
   private static Timestamp ofEpochSecond(long epochSecond, long nanoAdjustment) {
-    long secs = Utils.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
+    long secs = TimeUtils.checkedAdd(epochSecond, floorDiv(nanoAdjustment, NANOS_PER_SECOND));
     int nos = (int) floorMod(nanoAdjustment, NANOS_PER_SECOND);
     return create(secs, nos);
   }