org.apache.solr.common.util

## Class TimeSource

- java.lang.Object
- - org.apache.solr.common.util.TimeSource

Direct Known Subclasses:
  TimeSource.CurrentTimeSource, TimeSource.NanoTimeSource, TimeSource.SimTimeSource

    public abstract class TimeSource
    extends Object

Source of time.

NOTE: depending on implementation returned values may not be related in any way to the current Epoch or calendar time, and they may even be negative - but the API guarantees that they are always monotonically increasing.

### Nested Class Summary

Nested Classes
`static class` `TimeSource.CurrentTimeSource` Implementation that uses `System.currentTimeMillis()`.
`static class` `TimeSource.NanoTimeSource` Implementation that uses `System.nanoTime()`.
`static class` `TimeSource.SimTimeSource` Implementation that uses `NANO_TIME` accelerated by a double multiplier.

### Field Summary

Fields
`static TimeSource` `CURRENT_TIME` This instance uses `TimeSource.CurrentTimeSource` for generating timestamps.
`static TimeSource` `NANO_TIME` This instance uses `TimeSource.NanoTimeSource` for generating timestamps.

### Constructor Summary

Constructors
Constructor and Description
`TimeSource()`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`abstract long` `convertDelay(TimeUnit fromUnit, long value, TimeUnit toUnit)` This method allows using TimeSource with APIs that require providing just plain time intervals, eg.
`static TimeSource` `get(String type)` Obtain an instance of time source.
`abstract long` `getEpochTimeNs()` Return Epoch time.
`abstract long[]` `getTimeAndEpochNs()` Return both the source's time value and the corresponding epoch time value.
`abstract long` `getTimeNs()` Return a time value, in nanosecond units.
`abstract void` `sleep(long ms)` Sleep according to this source's notion of time.
`String` `toString()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Field Detail

#### CURRENT_TIME

    public static final TimeSource CURRENT_TIME

This instance uses `TimeSource.CurrentTimeSource` for generating timestamps.

#### NANO_TIME

    public static final TimeSource NANO_TIME

This instance uses `TimeSource.NanoTimeSource` for generating timestamps.

### Constructor Detail

#### TimeSource

    public TimeSource()

### Method Detail

#### get

    public static TimeSource get(String type)

Obtain an instance of time source.

Parameters:
  `type` - supported types: `currentTime`, `nanoTime` and accelerated time with a double factor in the form of `simTime:FACTOR`, eg. `simTime:2.5`
Returns:
  one of the supported types

#### getTimeNs

    public abstract long getTimeNs()

Return a time value, in nanosecond units. Depending on implementation this value may or may not be related to Epoch time.

#### getEpochTimeNs

    public abstract long getEpochTimeNs()

Return Epoch time. Implementations that are not natively based on epoch time may return values that are consistently off by a (small) fixed number of milliseconds from the actual epoch time.

#### getTimeAndEpochNs

    public abstract long[] getTimeAndEpochNs()

Return both the source's time value and the corresponding epoch time value. This method ensures that epoch time calculations use the same internal value of time as that reported by `getTimeNs()`.

Returns:
  an array where the first element is `getTimeNs()` and the second element is `getEpochTimeNs()`.

#### sleep

    public abstract void sleep(long ms)
                        throws InterruptedException

Sleep according to this source's notion of time. Eg. accelerated time source such as `TimeSource.SimTimeSource` will sleep proportionally shorter, according to its multiplier.

Parameters:
  `ms` - number of milliseconds to sleep
Throws:
  `InterruptedException` - when the current thread is interrupted

#### convertDelay

    public abstract long convertDelay(TimeUnit fromUnit,
                                      long value,
                                      TimeUnit toUnit)

This method allows using TimeSource with APIs that require providing just plain time intervals, eg. `Object.wait(long)`. Values returned by this method are adjusted according to the time source's notion of time - eg. accelerated time source provided by `TimeSource.SimTimeSource` will return intervals that are proportionally shortened by the multiplier.

NOTE: converting small values may significantly affect precision of the returned values due to rounding, especially for accelerated time source, so care should be taken to use time units that result in relatively large values. For example, converting a value of 1 expressed in seconds would result in less precision than converting a value of 1000 expressed in milliseconds.

Parameters:
  `fromUnit` - source unit
  `value` - original value
  `toUnit` - target unit
Returns:
  converted value, possibly scaled by the source's notion of accelerated time (see `TimeSource.SimTimeSource`)

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`