AbstractConcurrentProcessor (univocity-parsers 2.8.4 API)

java.lang.Object
- com.univocity.parsers.common.processor.core.AbstractConcurrentProcessor<T>

All Implemented Interfaces:

Processor<T>

Direct Known Subclasses:

ConcurrentRowProcessor
```
public abstract class AbstractConcurrentProcessor<T extends Context>
extends Object
implements Processor<T>
```
A Processor implementation to perform row processing tasks in parallel. The ConcurrentRowProcessor wraps another Processor, and collects rows read from the input. The actual row processing is performed in by wrapped Processor in a separate thread. Note: by default the Context object passed on to the wrapped Processor will not reflect the state of the parser at the time the row as generated, but the current state of the parser instead. You can enable the contextCopyingEnabled flag to generate copies of the Context at the time each row was generated.

Author:

Univocity Software Pty Ltd - parsers@univocity.com

See Also:

AbstractParser, Processor

Constructor Summary

Constructors
Constructor and Description
`AbstractConcurrentProcessor(Processor<T> processor)` Creates a non-blocking `AbstractConcurrentProcessor`, to perform processing of rows parsed from the input in a separate thread.
`AbstractConcurrentProcessor(Processor<T> processor, int limit)` Creates a blocking `ConcurrentProcessor`, to perform processing of rows parsed from the input in a separate thread.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract T`	`copyContext(T context)`
`protected long`	`getRowCount()`
`boolean`	`isContextCopyingEnabled()` Indicates whether this processor should persist the `Context` object that is sent to the wrapped `Processor` given in the constructor of this class, so all methods of `Context` reflect the parser state at the time each row was parsed.
`void`	`processEnded(T context)` This method will by invoked by the parser once, after the parsing process stopped and all resources were closed.
`void`	`processStarted(T context)` This method will by invoked by the parser once, when it is ready to start processing the input.
`void`	`rowProcessed(String[] row, T context)` Invoked by the parser after all values of a valid record have been processed.
`void`	`setContextCopyingEnabled(boolean contextCopyingEnabled)` Configures this processor to persist the `Context` object that is sent to the wrapped `Processor` given in the constructor of this class, so all methods of `Context` reflect the parser state at the time each row was parsed.
`protected abstract T`	`wrapContext(T context)`

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

- Constructor Detail
  - AbstractConcurrentProcessor
```
public AbstractConcurrentProcessor(Processor<T> processor)
```
    Creates a non-blocking AbstractConcurrentProcessor, to perform processing of rows parsed from the input in a separate thread.
    
    Parameters:
    
    processor - a regular Processor implementation which will be executed in a separate thread.
  - AbstractConcurrentProcessor
```
public AbstractConcurrentProcessor(Processor<T> processor,
                                   int limit)
```
    Creates a blocking ConcurrentProcessor, to perform processing of rows parsed from the input in a separate thread.
    
    Parameters:
    
    processor - a regular Processor implementation which will be executed in a separate thread.
    
    limit - the limit of rows to be kept in memory before blocking the input parsing process.
- Method Detail
  - isContextCopyingEnabled
```
public boolean isContextCopyingEnabled()
```
    Indicates whether this processor should persist the Context object that is sent to the wrapped Processor given in the constructor of this class, so all methods of Context reflect the parser state at the time each row was parsed. Defaults to false
    
    Returns:
    
    a flag indicating whether the parsing context must be persisted along with the parsed row so its methods reflect the state of the parser at the time the record was produced.
  - setContextCopyingEnabled
```
public void setContextCopyingEnabled(boolean contextCopyingEnabled)
```
    Configures this processor to persist the Context object that is sent to the wrapped Processor given in the constructor of this class, so all methods of Context reflect the parser state at the time each row was parsed. Defaults to false
    
    Parameters:
    
    contextCopyingEnabled - a flag indicating whether the parsing context must be persisted along with the parsed row so its methods reflect the state of the parser at the time the record was produced.
  - processStarted
```
public final void processStarted(T context)
```
    Description copied from interface: Processor
    
    This method will by invoked by the parser once, when it is ready to start processing the input.
    
    Specified by:
    
    processStarted in interface Processor<T extends Context>
    
    Parameters:
    
    context - A contextual object with information and controls over the current state of the parsing process
  - rowProcessed
```
public final void rowProcessed(String[] row,
                               T context)
```
    Description copied from interface: Processor
    
    Invoked by the parser after all values of a valid record have been processed.
    Specified by:
    
    rowProcessed in interface Processor<T extends Context>
    
    Parameters:
    row - the data extracted by the parser for an individual record. Note that:
    
    it will never by null.
    
    it will never be empty unless explicitly configured using CommonSettings.setSkipEmptyLines(boolean)
    
    it won't contain lines identified by the parser as comments. To disable comment processing set Format.setComment(char) to '\0'
    context - A contextual object with information and controls over the current state of the parsing process
  - processEnded
```
public final void processEnded(T context)
```
    Description copied from interface: Processor
    
    This method will by invoked by the parser once, after the parsing process stopped and all resources were closed.
    It will always be called by the parser: in case of errors, if the end of the input us reached, or if the user stopped the process manually using Context.stop().
    
    Specified by:
    
    processEnded in interface Processor<T extends Context>
    
    Parameters:
    
    context - A contextual object with information and controls over the state of the parsing process
  - getRowCount
```
protected final long getRowCount()
```
  - copyContext
```
protected abstract T copyContext(T context)
```
  - wrapContext
```
protected abstract T wrapContext(T context)
```

Class AbstractConcurrentProcessor<T extends Context>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractConcurrentProcessor

AbstractConcurrentProcessor

Method Detail

isContextCopyingEnabled

setContextCopyingEnabled

processStarted

rowProcessed

processEnded

getRowCount

copyContext

wrapContext