ApproximateReportedProgress (Google Dataflow API v1b3 (Rev. 213) 1.22.0)

java.lang.Object
- java.util.AbstractMap<java.lang.String,java.lang.Object>
- - com.google.api.client.util.GenericData
  - - com.google.api.client.json.GenericJson
    - - com.google.api.services.dataflow.model.ApproximateReportedProgress

All Implemented Interfaces:

java.lang.Cloneable, java.util.Map<java.lang.String,java.lang.Object>
```
public final class ApproximateReportedProgress
extends com.google.api.client.json.GenericJson
```
A progress measurement of a WorkItem by a worker.
This is the Java data model class that specifies how to parse/serialize into the JSON that is transmitted over HTTP when working with the Google Dataflow API. For a detailed explanation see: https://developers.google.com/api-client-library/java/google-http-java-client/json

Author:

Google, Inc.

Nested Class Summary
- Nested classes/interfaces inherited from class com.google.api.client.util.GenericData
  com.google.api.client.util.GenericData.Flags
- Nested classes/interfaces inherited from class java.util.AbstractMap
  java.util.AbstractMap.SimpleEntry<K,V>, java.util.AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  java.util.Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description

ApproximateReportedProgress()

Constructors
Constructor and Description
`ApproximateReportedProgress()`

Method Summary

Methods
Modifier and Type	Method and Description
`ApproximateReportedProgress`	`clone()`
`ReportedParallelism`	`getConsumedParallelism()` Total amount of parallelism in the portion of input of this task that has already been consumed and is no longer active.
`java.lang.Double`	`getFractionConsumed()` Completion as fraction of the input consumed, from 0.0 (beginning, nothing consumed), to 1.0 (end of the input, entire input consumed).
`Position`	`getPosition()` A Position within the work to represent a progress.
`ReportedParallelism`	`getRemainingParallelism()` Total amount of parallelism in the input of this task that remains, (i.e.
`ApproximateReportedProgress`	`set(java.lang.String fieldName, java.lang.Object value)`
`ApproximateReportedProgress`	`setConsumedParallelism(ReportedParallelism consumedParallelism)` Total amount of parallelism in the portion of input of this task that has already been consumed and is no longer active.
`ApproximateReportedProgress`	`setFractionConsumed(java.lang.Double fractionConsumed)` Completion as fraction of the input consumed, from 0.0 (beginning, nothing consumed), to 1.0 (end of the input, entire input consumed).
`ApproximateReportedProgress`	`setPosition(Position position)` A Position within the work to represent a progress.
`ApproximateReportedProgress`	`setRemainingParallelism(ReportedParallelism remainingParallelism)` Total amount of parallelism in the input of this task that remains, (i.e.

Methods inherited from class com.google.api.client.json.GenericJson
getFactory, setFactory, toPrettyString, toString

Methods inherited from class com.google.api.client.util.GenericData
entrySet, get, getClassInfo, getUnknownKeys, put, putAll, remove, setUnknownKeys

Methods inherited from class java.util.AbstractMap
clear, containsKey, containsValue, equals, hashCode, isEmpty, keySet, size, values

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

- Constructor Detail
  - ApproximateReportedProgress
```
public ApproximateReportedProgress()
```
- Method Detail
  - getConsumedParallelism
```
public ReportedParallelism getConsumedParallelism()
```
    Total amount of parallelism in the portion of input of this task that has already been consumed and is no longer active. In the first two examples above (see remaining_parallelism), the value should be 29 or 2 respectively. The sum of remaining_parallelism and consumed_parallelism should equal the total amount of parallelism in this work item. If specified, must be finite.
    
    Returns:
    value or null for none
  - setConsumedParallelism
```
public ApproximateReportedProgress setConsumedParallelism(ReportedParallelism consumedParallelism)
```
    Total amount of parallelism in the portion of input of this task that has already been consumed and is no longer active. In the first two examples above (see remaining_parallelism), the value should be 29 or 2 respectively. The sum of remaining_parallelism and consumed_parallelism should equal the total amount of parallelism in this work item. If specified, must be finite.
    
    Parameters:
    consumedParallelism - consumedParallelism or null for none
  - getFractionConsumed
```
public java.lang.Double getFractionConsumed()
```
    Completion as fraction of the input consumed, from 0.0 (beginning, nothing consumed), to 1.0 (end of the input, entire input consumed).
    
    Returns:
    value or null for none
  - setFractionConsumed
```
public ApproximateReportedProgress setFractionConsumed(java.lang.Double fractionConsumed)
```
    Completion as fraction of the input consumed, from 0.0 (beginning, nothing consumed), to 1.0 (end of the input, entire input consumed).
    
    Parameters:
    fractionConsumed - fractionConsumed or null for none
  - getPosition
```
public Position getPosition()
```
    A Position within the work to represent a progress.
    
    Returns:
    value or null for none
  - setPosition
```
public ApproximateReportedProgress setPosition(Position position)
```
    A Position within the work to represent a progress.
    
    Parameters:
    position - position or null for none
  - getRemainingParallelism
```
public ReportedParallelism getRemainingParallelism()
```
    Total amount of parallelism in the input of this task that remains, (i.e. can be delegated to this task and any new tasks via dynamic splitting). Always at least 1 for non-finished work items and 0 for finished. "Amount of parallelism" refers to how many non-empty parts of the input can be read in parallel. This does not necessarily equal number of records. An input that can be read in parallel down to the individual records is called "perfectly splittable". An example of non- perfectly parallelizable input is a block-compressed file format where a block of records has to be read as a whole, but different blocks can be read in parallel. Examples: * If we are processing record #30 (starting at 1) out of 50 in a perfectly splittable 50-record input, this value should be 21 (20 remaining + 1 current). * If we are reading through block 3 in a block-compressed file consisting of 5 blocks, this value should be 3 (since blocks 4 and 5 can be processed in parallel by new tasks via dynamic splitting and the current task remains processing block 3). * If we are reading through the last block in a block-compressed file, or reading or processing the last record in a perfectly splittable input, this value should be 1, because apart from the current task, no additional remainder can be split off.
    
    Returns:
    value or null for none
  - setRemainingParallelism
```
public ApproximateReportedProgress setRemainingParallelism(ReportedParallelism remainingParallelism)
```
    Total amount of parallelism in the input of this task that remains, (i.e. can be delegated to this task and any new tasks via dynamic splitting). Always at least 1 for non-finished work items and 0 for finished. "Amount of parallelism" refers to how many non-empty parts of the input can be read in parallel. This does not necessarily equal number of records. An input that can be read in parallel down to the individual records is called "perfectly splittable". An example of non- perfectly parallelizable input is a block-compressed file format where a block of records has to be read as a whole, but different blocks can be read in parallel. Examples: * If we are processing record #30 (starting at 1) out of 50 in a perfectly splittable 50-record input, this value should be 21 (20 remaining + 1 current). * If we are reading through block 3 in a block-compressed file consisting of 5 blocks, this value should be 3 (since blocks 4 and 5 can be processed in parallel by new tasks via dynamic splitting and the current task remains processing block 3). * If we are reading through the last block in a block-compressed file, or reading or processing the last record in a perfectly splittable input, this value should be 1, because apart from the current task, no additional remainder can be split off.
    
    Parameters:
    remainingParallelism - remainingParallelism or null for none
  - set
```
public ApproximateReportedProgress set(java.lang.String fieldName,
                              java.lang.Object value)
```
    Overrides:
    
    set in class com.google.api.client.json.GenericJson
  - clone
```
public ApproximateReportedProgress clone()
```
    Overrides:
    
    clone in class com.google.api.client.json.GenericJson

Google Dataflow API v1b3 (revision 213)

Class ApproximateReportedProgress

Nested Class Summary

Nested classes/interfaces inherited from class com.google.api.client.util.GenericData

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class com.google.api.client.json.GenericJson

Methods inherited from class com.google.api.client.util.GenericData

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Constructor Detail

ApproximateReportedProgress

Method Detail

getConsumedParallelism

setConsumedParallelism

getFractionConsumed

setFractionConsumed

getPosition

setPosition

getRemainingParallelism

setRemainingParallelism

set

clone