Duration (Apache Brooklyn)

java.lang.Object
- 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

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(com.google.common.base.Stopwatch stopwatch)`
`boolean`	`isPositive()`
`boolean`	`isShorterThan(Duration x)`
`boolean`	`isShorterThan(com.google.common.base.Stopwatch stopwatch)`
`Duration`	`lowerBound(Duration alternateMinimumValue)` returns the larger of this value or the argument
`static Duration`	`max(Duration first, Duration second)`
`Duration`	`maximum(Duration alternateMaximumValue)` Deprecated. since 0.7.0 use `upperBound(Duration)`
`static Duration`	`millis(java.lang.Number n)` creates new `Duration` instance of the given length of time
`static com.google.common.base.Function<java.lang.Number,java.lang.String>`	`millisToStringRounded()`
`static Duration`	`min(Duration first, Duration second)`
`Duration`	`minimum(Duration alternateMinimumValue)` Deprecated. since 0.7.0 use `lowerBound(Duration)`
`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)` tries to convert given object to a Duration, parsing strings, treating numbers as millis, etc; throws IAE if not convertible
`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 com.google.common.base.Function<java.lang.Number,java.lang.String>`	`secondsToStringRounded()`
`static Duration`	`sinceUtc(long millisSinceEpoch)`
`static void`	`sleep(Duration duration)` see `Time.sleep(long)`
`Duration`	`subtract(Duration other)`
`Duration`	`times(long x)`
`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"). 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

nanos
```
public static Duration nanos(java.lang.Number n)
```
creates new Duration instance of the given length of time

millisToStringRounded

public static com.google.common.base.Function<java.lang.Number,java.lang.String> millisToStringRounded()

secondsToStringRounded

public static com.google.common.base.Function<java.lang.Number,java.lang.String> secondsToStringRounded()

of
```
public static Duration of(java.lang.Object o)
```
tries to convert given object to a Duration, parsing strings, treating numbers as millis, etc; throws IAE if not convertible

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
```
public Duration times(long x)
```

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()
```

isLongerThan

public boolean isLongerThan(Duration x)

isLongerThan

public boolean isLongerThan(com.google.common.base.Stopwatch stopwatch)

isShorterThan

public boolean isShorterThan(Duration x)

isShorterThan

public boolean isShorterThan(com.google.common.base.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

minimum

@Deprecated
public Duration minimum(Duration alternateMinimumValue)

Deprecated. since 0.7.0 use lowerBound(Duration)

maximum

@Deprecated
public Duration maximum(Duration alternateMaximumValue)

Deprecated. since 0.7.0 use upperBound(Duration)

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

nanos

millisToStringRounded

secondsToStringRounded

of

of

max

min

untilUtc

sinceUtc

add

subtract

multiply

times

multiply

half

sleep

countdownTimer

isPositive

isLongerThan

isLongerThan

isShorterThan

isShorterThan

lowerBound

upperBound

minimum

maximum