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.

Nested and Inner Type Summary

Modifier and Type	Class and Description
private static class	AbstractConcurrentProcessor.Node<T>

Field Summary

Modifier and Type	Field and Description
private boolean	contextCopyingEnabled
private T	currentContext
private boolean	ended
private final ExecutorService	executor
private volatile long	input
private AbstractConcurrentProcessor.Node<T>	inputQueue
private final int	limit
private final Object	lock
private volatile long	output
private volatile AbstractConcurrentProcessor.Node<T>	outputQueue
private Future<Void>	process
private final Processor<T extends Context>	processor
private volatile long	rowCount

Constructor Summary

Access	Constructor and Description
public	AbstractConcurrentProcessor(Processor<T> a regular `Processor` implementation which will be executed in a separate thread. processor) Creates a non-blocking `AbstractConcurrentProcessor`, to perform processing of rows parsed from the input in a separate thread.
public	AbstractConcurrentProcessor(Processor<T> a regular `Processor` implementation which will be executed in a separate thread. processor, int the limit of rows to be kept in memory before blocking the input parsing process. limit) Creates a blocking `ConcurrentProcessor`, to perform processing of rows parsed from the input in a separate thread.

Method Summary

Modifier and Type	Method and Description
protected abstract T	copyContext(T context)
protected final long	getRowCount()
private T	grabContext(T context)
public boolean	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. 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.
public final void	processEnded(T A contextual object with information and controls over the state of the parsing process context) Implements com.univocity.parsers.common.processor.core.Processor.processEnded. This method will by invoked by the parser once, after the parsing process stopped and all resources were closed.
public final void	processStarted(T A contextual object with information and controls over the current state of the parsing process context) Implements com.univocity.parsers.common.processor.core.Processor.processStarted. This method will by invoked by the parser once, when it is ready to start processing the input.
public final void	rowProcessed(String[] 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' row, T A contextual object with information and controls over the current state of the parsing process context) Implements com.univocity.parsers.common.processor.core.Processor.rowProcessed. Invoked by the parser after all values of a valid record have been processed.
public void	setContextCopyingEnabled(boolean 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. 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.
private void	startProcess()
protected abstract T	wrapContext(T context)

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

contextCopyingEnabled	back to summary
private boolean contextCopyingEnabled

currentContext	back to summary
private T currentContext

ended	back to summary
private boolean ended

executor	back to summary
private final ExecutorService executor

input	back to summary
private volatile long input

inputQueue	back to summary
private AbstractConcurrentProcessor.Node<T> inputQueue

limit	back to summary
private final int limit

lock	back to summary
private final Object lock

output	back to summary
private volatile long output

outputQueue	back to summary
private volatile AbstractConcurrentProcessor.Node<T> outputQueue

process	back to summary
private Future<Void> process

processor	back to summary
private final Processor<T extends Context> processor

rowCount	back to summary
private volatile long rowCount

Constructor Detail

AbstractConcurrentProcessor back to summary

AbstractConcurrentProcessor	back to summary
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:Processor<T> a regular `Processor` implementation which will be executed in a separate thread.

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:Processor<T>: a regular Processor implementation which will be executed in a separate thread.

AbstractConcurrentProcessor back to summary

AbstractConcurrentProcessor	back to summary
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:Processor<T> a regular `Processor` implementation which will be executed in a separate thread. limit:int the limit of rows to be kept in memory before blocking the input parsing process.

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:Processor<T>: a regular Processor implementation which will be executed in a separate thread.
limit:int: the limit of rows to be kept in memory before blocking the input parsing process.

Method Detail

copyContext	back to summary
protected abstract T copyContext(T context)

getRowCount	back to summary
protected final long getRowCount()

grabContext	back to summary
private T grabContext(T context)

isContextCopyingEnabled back to summary

isContextCopyingEnabled	back to summary
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:boolean 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.

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:boolean: 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.

processEnded back to summary

processEnded	back to summary
public final void processEnded(T context) Implements com.univocity.parsers.common.processor.core.Processor.processEnded. Doc from com.univocity.parsers.common.processor.core.Processor.processEnded. 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 `ParsingContext#stop()`. Parameters context:T A contextual object with information and controls over the state of the parsing process Annotations @Override

public final void processEnded(T context)

Implements com.univocity.parsers.common.processor.core.Processor.processEnded.

Doc from com.univocity.parsers.common.processor.core.Processor.processEnded.

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 ParsingContext#stop().

Parameters

context:T: A contextual object with information and controls over the state of the parsing process

Annotations

@Override

processStarted	back to summary
public final void processStarted(T context) Implements com.univocity.parsers.common.processor.core.Processor.processStarted. Doc from com.univocity.parsers.common.processor.core.Processor.processStarted. This method will by invoked by the parser once, when it is ready to start processing the input. Parameters context:T A contextual object with information and controls over the current state of the parsing process Annotations @Override

processStarted

back to summary

public final void processStarted(T context)

Implements com.univocity.parsers.common.processor.core.Processor.processStarted.

Doc from com.univocity.parsers.common.processor.core.Processor.processStarted.

This method will by invoked by the parser once, when it is ready to start processing the input.

Parameters

context:T: A contextual object with information and controls over the current state of the parsing process

Annotations

@Override

rowProcessed back to summary

rowProcessed	back to summary
public final void rowProcessed(String[] row, T context) Implements com.univocity.parsers.common.processor.core.Processor.rowProcessed. Doc from com.univocity.parsers.common.processor.core.Processor.rowProcessed. Invoked by the parser after all values of a valid record have been processed. Parameters row:String[] 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:T A contextual object with information and controls over the current state of the parsing process Annotations @Override

public final void rowProcessed(String[] row, T context)

Implements com.univocity.parsers.common.processor.core.Processor.rowProcessed.

Doc from com.univocity.parsers.common.processor.core.Processor.rowProcessed.

Invoked by the parser after all values of a valid record have been processed.

Parameters

row:String[]

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:T

A contextual object with information and controls over the current state of the parsing process

Annotations

@Override

setContextCopyingEnabled back to summary

setContextCopyingEnabled	back to summary
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:boolean 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.

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:boolean: 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.

startProcess	back to summary
private void startProcess()

wrapContext	back to summary
protected abstract T wrapContext(T context)

com.univocity.parsers.common.processor.core back to summary

private Class AbstractConcurrentProcessor.Node<T>

Class Inheritance

extends Object

java.lang.Object
com.univocity.parsers.common.processor.core.AbstractConcurrentProcessor.Node

Field Summary

Modifier and Type	Field and Description
public final T	context
public AbstractConcurrentProcessor.Node<T>	next
public final String[]	row

Constructor Summary

Access	Constructor and Description
public	Node(String[] row, T context)

Method Summary

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

context	back to summary
public final T context

next	back to summary
public AbstractConcurrentProcessor.Node<T> next

row	back to summary
public final String[] row

Constructor Detail

Node	back to summary
public Node(String[] row, T context)

public abstract Class AbstractConcurrentProcessor<T extends Context>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class AbstractConcurrentProcessor.Node<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail