Duration (Apache Brooklyn)

java.lang.Object
- org.apache.brooklyn.util.time.Duration

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Duration>
```
public class Duration
extends java.lang.Object
implements java.lang.Comparable<Duration>, java.io.Serializable
```
simple class determines a length of time

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static Duration`	`FIVE_MINUTES`
`static Duration`	`FIVE_SECONDS`
`static Duration`	`ONE_DAY`
`static Duration`	`ONE_HOUR`
`static Duration`	`ONE_MILLISECOND`
`static Duration`	`ONE_MINUTE`
`static Duration`	`ONE_SECOND`
`static Duration`	`PRACTICALLY_FOREVER` longest supported duration, 2^{63}-1 nanoseconds, approx ten billion seconds, or 300 years
`static Duration`	`TEN_SECONDS`
`static Duration`	`THIRTY_SECONDS`
`static Duration`	`TWO_MINUTES`
`static Duration`	`ZERO`

Constructor Summary

Constructors
Constructor and Description

Duration(long value, java.util.concurrent.TimeUnit unit)

Constructors
Constructor and Description
`Duration(long value, java.util.concurrent.TimeUnit unit)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Duration`	`add(Duration other)`
`int`	`compareTo(Duration o)`
`CountdownTimer`	`countdownTimer()` returns a new started `CountdownTimer` with this duration
`static Duration`	`days(java.lang.Number n)` creates new `Duration` instance of the given length of time
`boolean`	`equals(java.lang.Object o)`
`Duration`	`half()`
`int`	`hashCode()`
`static Duration`	`hours(java.lang.Number n)` creates new `Duration` instance of the given length of time
`boolean`	`isLongerThan(Duration x)`
`boolean`	`isLongerThan(Stopwatch stopwatch)`
`boolean`	`isNegative()`
`boolean`	`isPositive()`
`boolean`	`isShorterThan(Duration x)`
`boolean`	`isShorterThan(Stopwatch stopwatch)`
`Duration`	`lowerBound(Duration alternateMinimumValue)` returns the larger of this value or the argument
`static Duration`	`max(Duration first, Duration second)`
`static Duration`	`micros(java.lang.Number n)` creates new `Duration` instance of the given length of time
`static Duration`	`millis(java.lang.Number n)` creates new `Duration` instance of the given length of time
`static <any>`	`millisToStringRounded()`
`static Duration`	`min(Duration first, Duration second)`
`static Duration`	`minutes(java.lang.Number n)` creates new `Duration` instance of the given length of time
`Duration`	`multiply(double d)` as #multiply(long), but approximate due to the division (nano precision)
`Duration`	`multiply(long x)`
`long`	`nanos()` number of nanoseconds of this duration
`static Duration`	`nanos(java.lang.Number n)` creates new `Duration` instance of the given length of time
`static Duration`	`of(long value, java.util.concurrent.TimeUnit unit)`
`static Duration`	`of(java.lang.Object o)` Converts the given object to a Duration by attempting the following in order: return null if the object is null `parse` the object as a string treat numbers as milliseconds obtain the elapsed time of a `Stopwatch` invoke the object's `toMilliseconds` method, if one exists. If none of these cases work the method throws an `IllegalArgumentException`.
`static Duration`	`parse(java.lang.String textualDescription)` See `Time.parseElapsedTime(String)`; also accepts "forever" (and for those who prefer things exceedingly accurate, "practically_forever").
`static Duration`	`seconds(java.lang.Number n)` creates new `Duration` instance of the given length of time
`static <any>`	`secondsToStringRounded()`
`static Duration`	`sinceUtc(long millisSinceEpoch)`
`static void`	`sleep(Duration duration)` see `Time.sleep(long)`
`Duration`	`subtract(Duration other)`
`Duration`	`times(long x)` Deprecated. since 0.10.0 use `multiply(long)` instead.
`long`	`toMilliseconds()`
`long`	`toMillisecondsRoundingUp()` as `toMilliseconds()` but rounding away from zero (so 1 nanosecond gets rounded to 1 millisecond); see `toUnitRoundingUp(TimeUnit)`; provided as a convenience on top of `toUnit(TimeUnit, RoundingMode)` as this is a common case (when you want to make sure you wait at least a certain amount of time)
`long`	`toNanoseconds()`
`long`	`toSeconds()`
`java.lang.String`	`toString()`
`java.lang.String`	`toStringRounded()`
`long`	`toUnit(java.util.concurrent.TimeUnit unit)` converts to the given `TimeUnit`, using `TimeUnit.convert(long, TimeUnit)` which rounds _down_ (so 1 nanosecond converted to milliseconds gives 0 milliseconds, and -1 ns gives -1 ms)
`long`	`toUnit(java.util.concurrent.TimeUnit unit, java.math.RoundingMode rounding)` as `toUnit(TimeUnit)` but rounding as indicated (rather than always taking the floor which is TimeUnit's default behaviour)
`long`	`toUnitRoundingUp(java.util.concurrent.TimeUnit unit)` as `toUnit(TimeUnit)` but rounding away from zero, so 1 ns converted to ms gives 1 ms, and -1 ns gives 1ms
`static Duration`	`untilUtc(long millisSinceEpoch)`
`Duration`	`upperBound(Duration alternateMaximumValue)` returns the smaller of this value or the argument

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Field Detail

ZERO
```
public static final Duration ZERO
```

ONE_MILLISECOND

public static final Duration ONE_MILLISECOND

ONE_SECOND

public static final Duration ONE_SECOND

FIVE_SECONDS

public static final Duration FIVE_SECONDS

TEN_SECONDS

public static final Duration TEN_SECONDS

THIRTY_SECONDS

public static final Duration THIRTY_SECONDS

ONE_MINUTE

public static final Duration ONE_MINUTE

TWO_MINUTES

public static final Duration TWO_MINUTES

FIVE_MINUTES

public static final Duration FIVE_MINUTES

ONE_HOUR
```
public static final Duration ONE_HOUR
```

ONE_DAY
```
public static final Duration ONE_DAY
```

PRACTICALLY_FOREVER
```
public static final Duration PRACTICALLY_FOREVER
```
longest supported duration, 2^{63}-1 nanoseconds, approx ten billion seconds, or 300 years

Constructor Detail

Duration

public Duration(long value,
                java.util.concurrent.TimeUnit unit)

Method Detail
- compareTo
```
public int compareTo(Duration o)
```
  Specified by:
  
  compareTo in interface java.lang.Comparable<Duration>
- toString
```
public java.lang.String toString()
```
  Overrides:
  
  toString in class java.lang.Object
- toStringRounded
```
public java.lang.String toStringRounded()
```
- equals
```
public boolean equals(java.lang.Object o)
```
  Overrides:
  
  equals in class java.lang.Object
- hashCode
```
public int hashCode()
```
  Overrides:
  
  hashCode in class java.lang.Object
- toUnit
```
public long toUnit(java.util.concurrent.TimeUnit unit)
```
  converts to the given TimeUnit, using TimeUnit.convert(long, TimeUnit) which rounds _down_ (so 1 nanosecond converted to milliseconds gives 0 milliseconds, and -1 ns gives -1 ms)
- toUnit
```
public long toUnit(java.util.concurrent.TimeUnit unit,
                   java.math.RoundingMode rounding)
```
  as toUnit(TimeUnit) but rounding as indicated (rather than always taking the floor which is TimeUnit's default behaviour)
- toUnitRoundingUp
```
public long toUnitRoundingUp(java.util.concurrent.TimeUnit unit)
```
  as toUnit(TimeUnit) but rounding away from zero, so 1 ns converted to ms gives 1 ms, and -1 ns gives 1ms
- toMilliseconds
```
public long toMilliseconds()
```
- toMillisecondsRoundingUp
```
public long toMillisecondsRoundingUp()
```
  as toMilliseconds() but rounding away from zero (so 1 nanosecond gets rounded to 1 millisecond); see toUnitRoundingUp(TimeUnit); provided as a convenience on top of toUnit(TimeUnit, RoundingMode) as this is a common case (when you want to make sure you wait at least a certain amount of time)
- toNanoseconds
```
public long toNanoseconds()
```
- toSeconds
```
public long toSeconds()
```
- nanos
```
public long nanos()
```
  number of nanoseconds of this duration
- parse
```
public static Duration parse(java.lang.String textualDescription)
```
  See Time.parseElapsedTime(String); also accepts "forever" (and for those who prefer things exceedingly accurate, "practically_forever"). If null or blank or 'null' is passed in, then null will be returned. Also see of(Object).
- days
```
public static Duration days(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- hours
```
public static Duration hours(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- minutes
```
public static Duration minutes(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- seconds
```
public static Duration seconds(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- millis
```
public static Duration millis(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- micros
```
public static Duration micros(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- nanos
```
public static Duration nanos(java.lang.Number n)
```
  creates new Duration instance of the given length of time
- millisToStringRounded
```
public static <any> millisToStringRounded()
```
- secondsToStringRounded
```
public static <any> secondsToStringRounded()
```
- of
```
public static Duration of(java.lang.Object o)
```
  Converts the given object to a Duration by attempting the following in order:
  1. return null if the object is null
  2. parse the object as a string
  3. treat numbers as milliseconds
  4. obtain the elapsed time of a Stopwatch
  5. invoke the object's toMilliseconds method, if one exists.
  If none of these cases work the method throws an IllegalArgumentException.
- of
```
public static Duration of(long value,
                          java.util.concurrent.TimeUnit unit)
```
- max
```
public static Duration max(Duration first,
                           Duration second)
```
- min
```
public static Duration min(Duration first,
                           Duration second)
```
- untilUtc
```
public static Duration untilUtc(long millisSinceEpoch)
```
- sinceUtc
```
public static Duration sinceUtc(long millisSinceEpoch)
```
- add
```
public Duration add(Duration other)
```
- subtract
```
public Duration subtract(Duration other)
```
- multiply
```
public Duration multiply(long x)
```
- times
```
@Deprecated
public Duration times(long x)
```
  Deprecated. since 0.10.0 use multiply(long) instead.
- multiply
```
public Duration multiply(double d)
```
  as #multiply(long), but approximate due to the division (nano precision)
- half
```
public Duration half()
```
- sleep
```
public static void sleep(Duration duration)
```
  see Time.sleep(long)
- countdownTimer
```
public CountdownTimer countdownTimer()
```
  returns a new started CountdownTimer with this duration
- isPositive
```
public boolean isPositive()
```
- isNegative
```
public boolean isNegative()
```
- isLongerThan
```
public boolean isLongerThan(Duration x)
```
- isLongerThan
```
public boolean isLongerThan(Stopwatch stopwatch)
```
- isShorterThan
```
public boolean isShorterThan(Duration x)
```
- isShorterThan
```
public boolean isShorterThan(Stopwatch stopwatch)
```
- lowerBound
```
public Duration lowerBound(Duration alternateMinimumValue)
```
  returns the larger of this value or the argument
- upperBound
```
public Duration upperBound(Duration alternateMaximumValue)
```
  returns the smaller of this value or the argument

Class Duration

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

ONE_MILLISECOND

ONE_SECOND

FIVE_SECONDS

TEN_SECONDS

THIRTY_SECONDS

ONE_MINUTE

TWO_MINUTES

FIVE_MINUTES

ONE_HOUR

ONE_DAY

PRACTICALLY_FOREVER

Constructor Detail

Duration

Method Detail

compareTo

toString

toStringRounded

equals

hashCode

toUnit

toUnit

toUnitRoundingUp

toMilliseconds

toMillisecondsRoundingUp

toNanoseconds

toSeconds

nanos

parse

days

hours

minutes

seconds

millis

micros

nanos

millisToStringRounded

secondsToStringRounded

of

of

max

min

untilUtc

sinceUtc

add

subtract

multiply

times

multiply

half

sleep

countdownTimer

isPositive

isNegative

isLongerThan

isLongerThan

isShorterThan

isShorterThan

lowerBound

upperBound