p ){
+ return e -> !p.test(e);
+ }
+
+}
diff --git a/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/time/TimeUtils.java b/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/time/TimeUtils.java
new file mode 100644
index 0000000..5bdc975
--- /dev/null
+++ b/xtra4j-misc/src/main/java/ch/hiddenalpha/xtra4j/time/TimeUtils.java
@@ -0,0 +1,61 @@
+package ch.hiddenalpha.xtra4j.time;
+
+import static java.lang.System.*;
+
+
+public class TimeUtils {
+
+ /**
+ * Delegates to {@link #nanosToEpochMillis(long, long, long)} and
+ * assumes that the 'nanos' value was measured in the same JVM
+ * process as this call here occurs and is not too long back.
+ */
+ public static long nanosToEpochMillis( long nanos ){
+ return nanosToEpochMillis(nanos, nanoTime(), currentTimeMillis());
+ }
+
+ public static long nanosToEpochMillis( long nanos, long referenceNanos, long referenceEpochMs ){
+ long diffNs = nanos - referenceNanos;
+ if( diffNs < (Long.MIN_VALUE >> 1) || diffNs > (Long.MAX_VALUE>>1) ){
+ // Looks as System.nanoTime() did overflow while measurement. So
+ // flip result.
+ diffNs -= Long.MAX_VALUE;
+ }
+ return referenceEpochMs + (diffNs / 1_000_000);
+ }
+
+ /**
+ * Find smallest distance assuming integers overflow "like a circle".
+ *
+ * Just imagine integers more like a circle. So when we infinitely
+ * increment an integer, we assume it overflows and continues to walk around
+ * this (imaginary) circle continuing its steps in the far negative range
+ * towards zero again.
+ *
+ * This function takes two of those numbers on this circle and returns
+ * the smallest distance to travel on the circle between them. Here some
+ * examples:
+ *
+ * - f(7, 13) = 6
+ * - f(-7, +11) = 18
+ * - f(LONG_MIN, LONG_MAX) = 1
+ * - f(-9223372036854775805, 9223372036854775802) = 9
+ *
+ *
+ * This can be handy for example in conjunction with {@link System#nanoTime()}.
+ * Because in case of overflows between measuring begNs and endNs a simple
+ * subtraction would lead to uselessly large results. So we can use it as:
+ *
+ * long begNs = System.nanoTime();
+ * long endNs = System.nanoTime();
+ * long durationNs = nanosSmallDiff(endNs, begNs);
+ *
+ *
+ * WARN: Do NOT use this if your distance can reach (LONG_MAX / 2).
+ * Because in this case you would get wrong (too small) results.
+ */
+ public static long nanosSmallDiff( long a, long b ){
+ return (a - b >= 0) ? a - b : b - a;
+ }
+
+}
--
cgit v1.1