TimeWindows (kafka 0.10.2.1 API)

java.lang.Object
- org.apache.kafka.streams.kstream.Windows<TimeWindow>
- - org.apache.kafka.streams.kstream.TimeWindows

```
@InterfaceStability.Unstable
public final class TimeWindows
extends Windows<TimeWindow>
```
The fixed-size time-based window specifications used for aggregations.
The semantics of time-based aggregation windows are: Every T1 (advance) milliseconds, compute the aggregate total for T2 (size) milliseconds.
- If advance < size a hopping windows is defined:
  it discretize a stream into overlapping windows, which implies that a record maybe contained in one and or more "adjacent" windows.
- If advance == size a tumbling window is defined:
  it discretize a stream into non-overlapping windows, which implies that a record is only ever contained in one and only one tumbling window.
Thus, the specified TimeWindows are aligned to the epoch. Aligned to the epoch means, that the first window starts at timestamp zero. For example, hopping windows with size of 5000ms and advance of 3000ms, have window boundaries [0;5000),[3000;8000),... and not [1000;6000),[4000;9000),... or even something "random" like [1452;6452),[4452;9452),...
For time semantics, see TimestampExtractor.
See Also:
SessionWindows, UnlimitedWindows, JoinWindows, KGroupedStream.count(Windows, String), KGroupedStream.count(Windows, org.apache.kafka.streams.processor.StateStoreSupplier), KGroupedStream.reduce(Reducer, Windows, String), KGroupedStream.reduce(Reducer, Windows, org.apache.kafka.streams.processor.StateStoreSupplier), KGroupedStream.aggregate(Initializer, Aggregator, Windows, org.apache.kafka.common.serialization.Serde, String), KGroupedStream.aggregate(Initializer, Aggregator, Windows, org.apache.kafka.streams.processor.StateStoreSupplier), TimestampExtractor

Field Summary

Fields
Modifier and Type	Field and Description
`long`	`advanceMs` The size of the window's advance interval in milliseconds, i.e., by how much a window moves forward relative to the previous one.
`long`	`sizeMs` The size of the windows in milliseconds.

Fields inherited from class org.apache.kafka.streams.kstream.Windows
segments

Method Summary

Methods
Modifier and Type	Method and Description
`TimeWindows`	`advanceBy(long advanceMs)` Return a window definition with the original size, but advance ("hop") the window by the given interval, which specifies by how much a window moves forward relative to the previous one.
`boolean`	`equals(Object o)`
`int`	`hashCode()`
`long`	`maintainMs()` Return the window maintain duration (retention time) in milliseconds.
`static TimeWindows`	`of(long sizeMs)` Return a window definition with the given window size, and with the advance interval being equal to the window size.
`long`	`size()` Return the size of the specified windows in milliseconds.
`TimeWindows`	`until(long durationMs)` Set the window maintain duration (retention time) in milliseconds.
`Map<Long,TimeWindow>`	`windowsFor(long timestamp)` Create all windows that contain the provided timestamp, indexed by non-negative window start timestamps.

Methods inherited from class org.apache.kafka.streams.kstream.Windows
segments

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

- Field Detail
  - sizeMs
```
public final long sizeMs
```
    The size of the windows in milliseconds.
  - advanceMs
```
public final long advanceMs
```
    The size of the window's advance interval in milliseconds, i.e., by how much a window moves forward relative to the previous one.
- Method Detail
  - of
```
public static TimeWindows of(long sizeMs)
                      throws IllegalArgumentException
```
    Return a window definition with the given window size, and with the advance interval being equal to the window size. The time interval represented by the the N-th window is: [N * size, N * size + size).
    This provides the semantics of tumbling windows, which are fixed-sized, gap-less, non-overlapping windows. Tumbling windows are a special case of hopping windows with advance == size.
    
    Parameters:
    sizeMs - The size of the window in milliseconds
    
    Returns:
    a new window definition with default maintain duration of 1 day
    
    Throws:
    
    IllegalArgumentException - if the specified window size is zero or negative
  - advanceBy
```
public TimeWindows advanceBy(long advanceMs)
```
    Return a window definition with the original size, but advance ("hop") the window by the given interval, which specifies by how much a window moves forward relative to the previous one. The time interval represented by the the N-th window is: [N * advance, N * advance + size).
    This provides the semantics of hopping windows, which are fixed-sized, overlapping windows.
    
    Parameters:
    advanceMs - The advance interval ("hop") in milliseconds of the window, with the requirement that 0 < advanceMs ≤ sizeMs.
    
    Returns:
    a new window definition with default maintain duration of 1 day
    
    Throws:
    
    IllegalArgumentException - if the advance interval is negative, zero, or larger-or-equal the window size
  - windowsFor
```
public Map<Long,TimeWindow> windowsFor(long timestamp)
```
    Description copied from class: Windows
    
    Create all windows that contain the provided timestamp, indexed by non-negative window start timestamps.
    
    Specified by:
    
    windowsFor in class Windows<TimeWindow>
    
    Parameters:
    timestamp - the timestamp window should get created for
    
    Returns:
    a map of windowStartTimestamp -> Window entries
  - size
```
public long size()
```
    Description copied from class: Windows
    
    Return the size of the specified windows in milliseconds.
    
    Specified by:
    
    size in class Windows<TimeWindow>
    
    Returns:
    the size of the specified windows
  - until
```
public TimeWindows until(long durationMs)
                  throws IllegalArgumentException
```
    Description copied from class: Windows
    
    Set the window maintain duration (retention time) in milliseconds. This retention time is a guaranteed lower bound for how long a window will be maintained.
    
    Overrides:
    
    until in class Windows<TimeWindow>
    
    Parameters:
    durationMs - the window retention time
    
    Returns:
    itself
    
    Throws:
    
    IllegalArgumentException - if duration is smaller than the window size
  - maintainMs
```
public long maintainMs()
```
    Return the window maintain duration (retention time) in milliseconds.
    For TimeWindows the maintain duration is at least as small as the window size.
    
    Overrides:
    
    maintainMs in class Windows<TimeWindow>
    
    Returns:
    the window maintain duration
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class TimeWindows

Field Summary

Fields inherited from class org.apache.kafka.streams.kstream.Windows

Method Summary

Methods inherited from class org.apache.kafka.streams.kstream.Windows

Methods inherited from class java.lang.Object

Field Detail

sizeMs

advanceMs

Method Detail

of

advanceBy

windowsFor

size

until

maintainMs

equals

hashCode