Code example for TimeUnit

Methods: convert, ordinal

0
 *  
 * @author Kevin Bourrillion 
 * @since 10.0 
 */ 
@TargetApi(9) 
public final class Stopwatch { 
 
    private final Ticker mTicker;
 
    private boolean mIsRunning;
 
    private long mElapsedNanos;
 
    private long mStartTick;
 
    /** 
     * Creates (but does not start) a new stopwatch using 
     * {@link System#nanoTime} as its time source. 
     */ 
    public Stopwatch() { 
        this(Ticker.systemTicker()); 
    } 
 
    /** 
     * Creates (but does not start) a new stopwatch, using the specified time 
     * source. 
     */ 
    public Stopwatch(final Ticker ticker) {
        mTicker = checkNotNull(ticker);
    } 
 
    /** 
     * Returns {@code true} if {@link #start()} has been called on this 
     * stopwatch, and {@link #stop()} has not been called since the last call to 
     * {@code start()}. 
     */ 
    public boolean isRunning() { 
        return mIsRunning;
    } 
 
    /** 
     * Starts the stopwatch. 
     *  
     * @return this {@code Stopwatch} instance 
     * @throws IllegalStateException if the stopwatch is already running. 
     */ 
    public Stopwatch start() { 
        checkState(!mIsRunning);
        mIsRunning = true;
        mStartTick = mTicker.read();
        return this;
    } 
 
    /** 
     * Stops the stopwatch. Future reads will return the fixed duration that had 
     * elapsed up to this point. 
     *  
     * @return this {@code Stopwatch} instance 
     * @throws IllegalStateException if the stopwatch is already stopped. 
     */ 
    public Stopwatch stop() { 
        final long mTick = mTicker.read();
        checkState(mIsRunning);
        mIsRunning = false;
        mElapsedNanos += mTick - mStartTick;
        return this;
    } 
 
    /** 
     * Sets the elapsed time for this stopwatch to zero, and places it in a 
     * stopped state. 
     *  
     * @return this {@code Stopwatch} instance 
     */ 
    public Stopwatch reset() { 
        mElapsedNanos = 0;
        mIsRunning = false;
        return this;
    } 
 
    private long elapsedNanos() { 
        return mIsRunning ? mTicker.read() - mStartTick + mElapsedNanos : mElapsedNanos;
    } 
 
    /** 
     * Returns the current elapsed time shown on this stopwatch, expressed in 
     * the desired time unit, with any fraction rounded down. 
     * <p> 
     * Note that the overhead of measurement can be more than a microsecond, so 
     * it is generally not useful to specify {@link TimeUnit#NANOSECONDS} 
     * precision here. 
     */ 
    public long elapsedTime(final TimeUnit desiredUnit) {
        return desiredUnit.convert(elapsedNanos(), NANOSECONDS);
    } 
 
    /** 
     * Returns the current elapsed time shown on this stopwatch, expressed in 
     * milliseconds, with any fraction rounded down. This is identical to 
     * {@code elapsedTime(TimeUnit.MILLISECONDS)}. 
     */ 
    public long elapsedMillis() { 
        return elapsedTime(MILLISECONDS);
    } 
 
    /** 
     * Returns a string representation of the current elapsed time. 
     */ 
    @Override 
    public String toString() {
        return toString(4); 
    } 
 
    /** 
     * Returns a string representation of the current elapsed time, choosing an 
     * appropriate unit and using the specified number of significant figures. 
     * For example, at the instant when {@code elapsedTime(NANOSECONDS)} would 
     * return {1234567}, {@code toString(4)} returns {@code "1.235 ms"}. 
     *  
     * @deprecated Use {@link #toString()} instead. This method is scheduled to 
     *             be removed in Guava release 15.0. 
     */ 
    @Deprecated 
    public String toString(final int significantDigits) {
        final long mNanos = elapsedNanos();
 
        final TimeUnit mUnit = chooseUnit(mNanos);
        final double mValue = (double)mNanos / NANOSECONDS.convert(1, mUnit);
 
        /* Too bad this functionality is not exposed as a regular method call */ 
        return String.format("%." + significantDigits + "g %s", mValue, abbreviate(mUnit));
    } 
 
    private static TimeUnit chooseUnit(final long nanos) {
        if (SECONDS.convert(nanos, NANOSECONDS) > 0) {
            return SECONDS;
        } 
        if (MILLISECONDS.convert(nanos, NANOSECONDS) > 0) {
            return MILLISECONDS;
        } 
        if (MICROSECONDS.convert(nanos, NANOSECONDS) > 0) {
            return MICROSECONDS;
        } 
        return NANOSECONDS;
    } 
 
    private static String abbreviate(final TimeUnit unit) {
        switch (unit) {
            case NANOSECONDS:
                return "ns"; 
            case MICROSECONDS:
                return "\u03bcs"; 
            case MILLISECONDS: