com.azure.cosmos.implementation.apachecommons.lang.time.StopWatch Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/*
* Portions Copyright (c) Microsoft Corporation
*/
package com.azure.cosmos.implementation.apachecommons.lang.time;
import java.util.concurrent.TimeUnit;
public class StopWatch {
private static final long NANO_2_MILLIS = 1000000L;
/**
* Enumeration type which indicates the status of stopwatch.
*/
private enum State {
UNSTARTED {
@Override
boolean isStarted() {
return false;
}
},
RUNNING {
@Override
boolean isStarted() {
return true;
}
},
STOPPED {
@Override
boolean isStarted() {
return false;
}
},
SUSPENDED {
@Override
boolean isStarted() {
return true;
}
};
/**
*
* The method is used to find out if the StopWatch is started. A suspended
* StopWatch is also started watch.
*
* @return boolean
* If the StopWatch is started.
*/
abstract boolean isStarted();
}
/**
* The current running state of the StopWatch.
*/
private State runningState = State.UNSTARTED;
/**
* The start time.
*/
private long startTime;
/**
* The start time in Millis - nanoTime is only for elapsed time so we
* need to also store the currentTimeMillis to maintain the old
* getStartTime API.
*/
private long startTimeMillis;
/**
* The stop time.
*/
private long stopTime;
/**
*
* Constructor.
*
*/
public StopWatch() {
super();
}
/**
*
* Start the stopwatch.
*
*
*
* This method starts a new timing session, clearing any previous values.
*
*
* @throws IllegalStateException
* if the StopWatch is already running.
*/
public void start() {
if (this.runningState == State.STOPPED) {
throw new IllegalStateException("Stopwatch must be reset before being restarted. ");
}
if (this.runningState != State.UNSTARTED) {
throw new IllegalStateException("Stopwatch already started. ");
}
this.startTime = System.nanoTime();
this.startTimeMillis = System.currentTimeMillis();
this.runningState = State.RUNNING;
}
/**
*
* Stop the stopwatch.
*
*
*
* This method ends a new timing session, allowing the time to be retrieved.
*
*
* @throws IllegalStateException
* if the StopWatch is not running.
*/
public void stop() {
if (this.runningState != State.RUNNING && this.runningState != State.SUSPENDED) {
throw new IllegalStateException("Stopwatch is not running. ");
}
if (this.runningState == State.RUNNING) {
this.stopTime = System.nanoTime();
}
this.runningState = State.STOPPED;
}
/**
*
* Resets the stopwatch. Stops it if need be.
*
*
*
* This method clears the internal values to allow the object to be reused.
*
*/
public void reset() {
this.runningState = State.UNSTARTED;
}
/**
*
* Get the time on the stopwatch.
*
*
*
* This is either the time between the start and the moment this method is called, or the amount of time between
* start and stop.
*
*
* @return the time in milliseconds
*/
public long getTime() {
return getNanoTime() / NANO_2_MILLIS;
}
/**
*
* Get the time on the stopwatch in the specified TimeUnit.
*
*
*
* This is either the time between the start and the moment this method is called, or the amount of time between
* start and stop. The resulting time will be expressed in the desired TimeUnit with any remainder rounded down.
* For example, if the specified unit is {@code TimeUnit.HOURS} and the stopwatch time is 59 minutes, then the
* result returned will be {@code 0}.
*
*
* @param timeUnit the unit of time, not null
* @return the time in the specified TimeUnit, rounded down
*/
public long getTime(final TimeUnit timeUnit) {
return timeUnit.convert(getNanoTime(), TimeUnit.NANOSECONDS);
}
/**
*
* Get the time on the stopwatch in nanoseconds.
*
*
*
* This is either the time between the start and the moment this method is called, or the amount of time between
* start and stop.
*
*
* @return the time in nanoseconds
*/
public long getNanoTime() {
if (this.runningState == State.STOPPED || this.runningState == State.SUSPENDED) {
return this.stopTime - this.startTime;
} else if (this.runningState == State.UNSTARTED) {
return 0;
} else if (this.runningState == State.RUNNING) {
return System.nanoTime() - this.startTime;
}
throw new RuntimeException("Illegal running state has occurred.");
}
/**
* Returns the time this stopwatch was started.
*
* @return the time this stopwatch was started
* @throws IllegalStateException
* if this StopWatch has not been started
*/
public long getStartTime() {
if (this.runningState == State.UNSTARTED) {
throw new IllegalStateException("Stopwatch has not been started");
}
// System.nanoTime is for elapsed time
return this.startTimeMillis;
}
/**
*
* Gets a summary of the time that the stopwatch recorded as a string.
*
*
*
* The format used is ISO 8601-like, hours:minutes:seconds.milliseconds.
*
*
* @return the time as a String
*/
@Override
public String toString() {
return DurationFormatUtils.formatDurationHMS(getTime());
}
/**
*
* The method is used to find out if the StopWatch is started. A suspended
* StopWatch is also started watch.
*
*
* @return boolean
* If the StopWatch is started.
*/
public boolean isStarted() {
return runningState.isStarted();
}
}