1 files changed, 269 insertions, 0 deletions

diff --git a/src/main/java/org/gnunet/util/AbsoluteTime.java b/src/main/java/org/gnunet/util/AbsoluteTime.java
new file mode 100644
index 0000000..9d22d36
--- /dev/null
+++ b/src/main/java/org/gnunet/util/AbsoluteTime.java
@@ -0,0 +1,269 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+ */
+
+package org.gnunet.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Date;
+
+/**
+ * A specific point in time.
+ * 
+ * @author Florian Dold
+ */
+public class AbsoluteTime implements Comparable<AbsoluteTime> {
+    private static final Logger logger = LoggerFactory
+            .getLogger(AbsoluteTime.class);
+
+    /**
+     * Constant for 'the beginning of time' in our frame.
+     */
+    public final static AbsoluteTime ZERO = new AbsoluteTime(0);
+    public final static AbsoluteTime FOREVER = new AbsoluteTime(Long.MAX_VALUE);
+
+    /**
+     * Absolute time value in microseconds.
+     */
+    private final long abs_value_us;
+
+    /**
+     * Gets the current time.
+     * 
+     * @return the current time
+     */
+    public static AbsoluteTime now() {
+        return new AbsoluteTime(System.currentTimeMillis() * 1000);
+    }
+
+    public AbsoluteTime(final long abs_value_us) {
+        this.abs_value_us = abs_value_us;
+    }
+
+    /**
+     * Adds a relative time value to an absolute time.
+     * 
+     * @param duration duration to add to {@literal this}
+     * @return {@literal this + duration}
+     */
+    public AbsoluteTime add(RelativeTime duration) {
+        if (abs_value_us == Long.MAX_VALUE
+                || duration.isForever()) {
+            return AbsoluteTime.FOREVER;
+        }
+        if (abs_value_us + duration.getMicroseconds() < abs_value_us) {
+            return AbsoluteTime.FOREVER;
+        }
+        return new AbsoluteTime(abs_value_us + duration.getMicroseconds());
+    }
+
+    /**
+     * Calculates the estimate time of arrival/completion for an operation.
+     * 
+     * @param start
+     *            when did the operation start?
+     * @param finished
+     *            how much has been done?
+     * @param total
+     *            how much must be done overall (same unit as for "finished")
+     * @return remaining duration for the operation, assuming it continues at
+     *         the same speed
+     */
+    public static RelativeTime calculateETA(final AbsoluteTime start,
+            final long finished, final long total) {
+        if (finished >= total) {
+            return RelativeTime.ZERO;
+        }
+        if (finished == 0) {
+            return RelativeTime.FOREVER;
+        }
+        final RelativeTime dur = start.getDuration();
+        final double exp = dur.getMicroseconds() * total
+                / (double) finished;
+        return new RelativeTime((long) exp);
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof AbsoluteTime && compareTo((AbsoluteTime) other) == 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int hashCode() {
+        return (int) this.abs_value_us;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public int compareTo(AbsoluteTime other) {
+        if (this.abs_value_us < other.abs_value_us) {
+            return -1;
+        }
+        if (this.abs_value_us > other.abs_value_us) {
+            return 1;
+        }
+        return 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String toString() {
+        if (this.isForever()) {
+            return "AbsoluteTime(FOREVER)";
+        }
+        return "AbsoluteTime("+this.abs_value_us +")";
+    }
+
+
+    /**
+     * Check if a deadline is due.
+     * @return true if NOW is greater than the given time, false otherwise
+     */
+    public boolean isDue() {
+        return this.abs_value_us < now().abs_value_us;
+    }
+
+    /**
+     * Does this AbsoluteTime value represent forever?
+     *
+     * @return this==FOREVER
+     */
+    public boolean isForever() {
+        return this.abs_value_us == Long.MAX_VALUE;
+    }
+
+    /**
+     * Calculates the difference between two absolute times.
+     * 
+     * @param other ...
+     * @return this - other
+     */
+    public RelativeTime getDifference(final AbsoluteTime other) {
+        if (other.abs_value_us == Long.MAX_VALUE) {
+            return RelativeTime.FOREVER;
+        }
+        return new RelativeTime(abs_value_us - other.abs_value_us);
+    }
+
+    /**
+     * Gets the duration of an operation as the difference of the current time
+     * and {@literal this}.
+     *
+     * @return this - now
+     */
+    public RelativeTime getDuration() {
+        assert abs_value_us != Long.MAX_VALUE;
+        return getDifference(AbsoluteTime.now());
+    }
+
+    /**
+     * Returns the milliseconds since some fixed point of reference.
+     * 
+     * @return the absolute time in milliseconds
+     */
+    public long getMicroseconds() {
+        return abs_value_us;
+    }
+
+    /**
+     * Calculates the remaining time relative to now.
+     * 
+     * @return this - now
+     */
+    public RelativeTime getRemaining() {
+        if (abs_value_us == Long.MAX_VALUE) {
+            return RelativeTime.FOREVER;
+        }
+        return getDifference(AbsoluteTime.now());
+    }
+
+    /**
+     * Returns the maximum of two time values.
+     * 
+     * @param other ...
+     * @return max(this,other)
+     */
+    public AbsoluteTime max(final AbsoluteTime other) {
+        return abs_value_us >= other.abs_value_us ? this : other;
+
+    }
+
+    /**
+     * Returns the minimum of two time values.
+     * 
+     * @param other ...
+     * @return min(this,other)
+     */
+    public AbsoluteTime min(final AbsoluteTime other) {
+        return abs_value_us <= other.abs_value_us ? this : other;
+    }
+
+    /**
+     * Subtracts a relative time value to an absolute time
+     * 
+     * @param duration ...
+     * @return this - duration
+     */
+    public AbsoluteTime subtract(final RelativeTime duration) {
+        if (abs_value_us <= duration.getMicroseconds()) {
+            return AbsoluteTime.ZERO;
+        }
+        if (abs_value_us == Long.MAX_VALUE) {
+            return this;
+        }
+        return new AbsoluteTime(abs_value_us - duration.getMicroseconds());
+    }
+
+    /**
+     * Get a serializable message corresponding to this AbsoluteTime.
+     *
+     * @return a serializable message corresponding to this AbsoluteTime
+     */
+    public AbsoluteTimeMessage asMessage() {
+        return new AbsoluteTimeMessage(this);
+    }
+
+    /**
+     * Get the AbsoluteTime from a AbsoluteTimeMessage.
+     *
+     * @param m serializable representation of an AbsoluteTime
+     *
+     * @return the real AbsoluteTime associated with m
+     */
+    public static AbsoluteTime fromNetwork(AbsoluteTimeMessage m) {
+        return m.value__ < 0 ? AbsoluteTime.FOREVER : new AbsoluteTime(m.value__);
+    }
+
+    public Date toDate() {
+        return new Date(abs_value_us / 1000);
+    }
+}