All Classes and Interfaces
Class
Description
A
Processor
implementation that stores values of columns in batches.A
Processor
implementation for converting batches of rows extracted from any implementation of AbstractParser
into columns of objects.A convenience
Processor
implementation for storing all java objects generated form the parsed input into a list.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.The base class for implementing different flavours of
CharInputReader
.Basic support operations for mapping attributes/methods to columns in a
ColumnMapper
A simple
Processor
implementation that stores values of columns.A
Processor
implementation to perform row processing tasks in parallel.Class responsible for managing field selections and any conversion sequence associated with each.
Parent class of the Exception classes thrown by univocity-parsers.
A convenience
Processor
implementation for storing all rows parsed into a list.A convenience
Processor
implementation for storing all MasterDetailRecord
generated form the parsed input into a list.A
Processor
implementation for associating rows extracted from any implementation of AbstractParser
into MasterDetailRecord
instances.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects, storing
them into lists.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into columns of objects.A convenience
Processor
implementation for storing all rows parsed and converted to Object arrays into a list.A
Processor
implementation for converting rows extracted from any implementation of AbstractParser
into arrays of objects.The AbstractParser class provides a common ground for all parsers in univocity-parsers.
A
Processor
implementation that just implements all methods defined by the interface.A special
Processor
implementation that combines and allows switching among different
Processors.An abstract factory class which allows subclasses to provide implementations of
Record
Basic implementation of commonly used routines around parsing/writing of data that can be reused and extended
by parsers/writers of any supported format.
A
RowProcessor
implementation that just implements all methods defined by the interface.The AbstractWriter class provides a common ground for all writers in univocity-parsers.
A FieldSelector that selects all indexes of a record.
Helper class to process fields annotated with
Parsed
An internal registry of annotated elements and their properties that have been set via a
Copy
annotation.An utility class for validating inputs.
A
RowProcessor
implementation that stores values of columns in batches.A common interface for
Processor
s that collect the values parsed from each column in a row and store values of columns in batches.A
RowProcessor
implementation for converting batches of rows extracted from any implementation of AbstractParser
into columns of objects.The base class for
Processor
and RowWriterProcessor
implementations that support java beans annotated with the annotations provided in
com.univocity.parsers.annotations
.Helper class used to obtain property descriptors from annotated java beans whose values are set via reflection.
A convenience
BeanProcessor
implementation for storing all java objects generated form the parsed input into a list.A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.A
RowWriterProcessor
implementation for converting annotated java objects into object arrays suitable for writing in any implementation of AbstractWriter
.Converts Strings to BigDecimals and vice versa
Converts Strings to BigIntegers and vice versa
A wrapper for an
InputStream
that attempts to detect a Byte Order Mark (BOM) in the input
and derive the character encoding that should be used to decode the incoming content.Internal notification exception used to re-wrap the original
InputStream
into a Reader
.Converts Strings to Booleans and vice versa
Indicates that parsed values such as "y", "No" or "null" should be interpreted as boolean values.
Converts Strings to Bytes and vice versa
Converts Strings to instances of
Calendar
and vice versa.Converts Strings to Characters and vice versa
The general interface for classes responsible for appending characters efficiently while handling whitespaces and padding characters.
A buffer of characters.
A (very) basic character input definition.
The definition of a character input reader used by all univocity-parsers that extend
AbstractParser
.Class responsible for calculating and storing the position of fields parsed from the input.
A utility that allows users to manually define mappings from
attributes/methods of a given class to columns to be parsed or written.
Implementation the
ColumnMapper
interface which allows
users to manually define mappings from attributes/methods of a given class
to columns to be parsed or written.A marker interface used by special implementations of
RowProcessor
to indicate columns should not
be reordered by the parser.A simple
RowProcessor
implementation that stores values of columns.A common interface for
Processor
s that collect the values parsed from each column in a row.A utility class used split and store values columns parsed from each row in a
Processor
.This is the parent class for all configuration classes used by parsers (
AbstractParser
)This is the parent class for all configuration classes used by parsers (
AbstractParser
) and writers (AbstractWriter
)This is the parent class for all configuration classes used by writers (
AbstractWriter
)A utility
RowProcessor
implementation that facilitates using multiple implementations of RowProcessor
at the
same time.A concurrent CharInputReader that loads batches of characters in a separate thread and assigns them to buffer in
AbstractCharInputReader
when requested.A concurrent character loader for loading a pool of
CharBucket
instances using a Reader
in a separate threadA
RowProcessor
implementation to perform row processing tasks in parallel.A simple a wrapper for a
Context
.The interface that defines the conversion from one type of value to another, and vice versa.
A basic interface for classes that associate
Conversion
implementations with fields of a given input/output.This class provides default instances of common implementations if
com.univocity.parsers.conversions.Conversion
, as well as useful methods for obtaining new instances of these.Assigns a custom implementation of
Conversion
to be executed (Conversion.execute(Object)
)
when writing to the field and reverted (Conversion.revert(Object)
) when reading from the field.Allows copying values of meta-annotation properties into the properties of an annotation that composes it.
This class provides default configurations using CSV formats commonly used for parsing/writing.
The CSV format configuration.
An
InputAnalysisProcess
to detect column delimiters, quotes and quote escapes in a CSV input.A very fast CSV parser implementation.
This is the configuration class used by the CSV parser (
CsvParser
)A collection of common routines involving the processing of CSV data.
A powerful and flexible CSV writer implementation.
This is the configuration class used by the CSV writer (
CsvWriter
)Interface used by
InputValueSwitch
to allow users to to provide custom matching rules against input values.A
DataProcessingException
is an error thrown during the processing of a record successfully parsed.A
DataValidationException
is an error thrown during the processing of a record successfully parsed,
but whose data failed to pass a validation defined by annotation Validate
Converts Strings to instances of
Date
and vice versa.Default implementation of the
CharAppender
interfaceA default CharInputReader which only loads batches of characters when requested by the
AbstractCharInputReader
through the DefaultCharInputReader.reloadBuffer()
method.Default implementation of the
Context
interface with essential information about the output being produced.The base class for
RowProcessor
and RowWriterProcessor
implementations that support value conversions provided by Conversion
instances.The default
ParsingContext
implementation used internally by AbstractParser
to expose information about a parsing process in execution.Converts Strings to Doubles and vice versa
A concrete (dummy) implementation of
Format
.A character appender that restores its internal buffer size after expanding to accommodate larger contents.
An entry used by the
FixedInstancePool
Converts Strings to enumeration constants and vice versa.
The
EnumSelector
annotation is meant to be used in conjunction with enumeration attributes.Identifies a property of an enumeration that should be used by
EnumOptions
to identify an input value.Internal exception marker to signalize the end of the input.
A FieldSelector capable of deselecting fields in a record.
A FieldSelector capable of deselecting fields by their position in a record.
A FieldSelector capable of deselecting fields by their name in a record.
An implementation
CharAppender
that expands the internal buffer of characters as required.Alignment of text in a fixed-width field.
A class for mapping field selections to sequences of
Conversion
objectsA FieldSelector capable of selecting fields represented by values of an enumeration type.
A FieldSelector capable of selecting fields by their position in a record.
A helper class with information about the location of an field annotated with
Parsed
in a record.A FieldSelector capable of selecting fields by their name.
Interface used to identify classes capable of selecting fields and returning their positions in a given sequence.
A set of selected fields.
A very simple object instance pool with a fixed size.
The
@FixedWidth
annotation, along with the Parsed
annotation, allows users to configure the length,
alignment and padding of fields parsed/written using the FixedWidthParser
and FixedWidthWriter
Deprecated.
This class has been modified over time and its name became misleading.
This class provides the name, length, alignment and padding of each field in a fixed-width record.
The Fixed-Width format configuration.
A fast and flexible fixed-with parser implementation.
This is the configuration class used by the Fixed-Width parser (
FixedWidthParser
)A collection of common routines involving the processing of Fixed-Width data.
A fast and flexible fixed-with writer implementation.
This is the configuration class used by the Fixed-Width writer (
FixedWidthWriter
)Converts Strings to Floats and vice versa
Indicates that a parsed value is formatted and must be parsed before being assigned.
This is the parent class for all configuration classes that define a text format.
Converts formatted Strings to instances of
BigDecimal
and vice versa.This interface identifies conversions associated with the
Format
annotation.Converts objects of different date types (
java.util.Date
and java.util.Calendar
) to a formatted
date String
.The
Headers
annotation allows java beans to configure how to handle field names in a given input/outputA transformer of headers used in
Nested
attributes.A process to be executed over a sample of data being parsed.
A simple class to hold information about the dimensions of a given input, which are calculated using
AbstractRoutines.getInputDimension(File)
A concrete implementation of
RowProcessorSwitch
that allows switching among different implementations of
RowProcessor
based on values found on the rows parsed from the input.Converts Strings to Integers and vice versa
Internal class to keep common internal functions that are used in multiple places.
An
Iterable
result that provides the current parsing context
through the IterableResult.getContext()
methodA simple Reader implementation to enable parsers to process lines on demand, via
AbstractParser.parseLine(String)
An
InputAnalysisProcess
to detect the line separators used in the input.Converts Strings to Longs and vice versa
A special implementation of
CharInputReader
that wraps another CharInputReader
and
collects a sequence of characters from the wrapped input, in order to analyze what the buffer contains
ahead of the current position.Indicates the String value of a field must be converted to lower case using
LowerCaseConversion
.Converts an input String to its lower case representation
The
LowerCaseConversion.revert(String)
implements the same behavior of LowerCaseConversion.execute(String)
.A convenience
MasterDetailProcessor
implementation for storing all MasterDetailRecord
generated form the parsed input into a list.A
RowProcessor
implementation for associating rows extracted from any implementation of AbstractParser
into MasterDetailRecord
instances.An utility class to store data of a master row and its detail records.
A very basic descriptor or getter/setter methods
A filter for annotated methods.
A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects, storing
them into lists.A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into java objects.Marks a field as a nested object to be constructed with the values of the current row.
An implementation of
CharAppender
that does nothing.A
ParsingContext
implementation that does nothing.A singleton instance of a
Processor
that does nothing.An (singleton) implementation of
ProcessorErrorHandler
that simply rethrows any DataProcessingException
that comes into its NoopProcessorErrorHandler.handleError(DataProcessingException, Object[], Context)
} methodA singleton instance of a
RowProcessor
that does nothing.An (singleton) implementation of
RowProcessorErrorHandler
that simply rethrows any DataProcessingException
that comes into its NoopRowProcessorErrorHandler.handleError(DataProcessingException, Object[], ParsingContext)
methodA
NormalizedString
allows representing text in a normalized fashion.Default implementation for conversions from input Objects of type I to output Objects of type O
Indicates that parsed values such as "", "?" or "null" should be interpreted as null.
Converts Strings to null and vice versa
Converts Strings to instances of
Number
and vice versa.A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into columns of objects.Default implementation for conversions from an input String to Objects of a given type T
A convenience
RowProcessor
implementation for storing all rows parsed and converted to Object arrays into a list.A
RowProcessor
implementation for converting rows extracted from any implementation of AbstractParser
into arrays of objects.A
RowWriterProcessor
implementation for executing conversion sequences in object arrays before for writing them using any implementation of AbstractWriter
.A concrete implementation of
RowWriterProcessorSwitch
that allows switching among different implementations of
RowWriterProcessor
based on values found on rows to be written to an outputIndicates the field is parsed.
An
Iterator
over the parser enabling easy iteration against rows and records
Multiple iterations are possible if Files are being fed into the parser,
but other forms of input (such as InputStream
s and Reader
s) can not be iterated over more than once.The ParserOutput is the component that manages records parsed by
AbstractParser
and their values.Parsing context information available to instances of
RowProcessor
.A snapshot of a
ParsingContext
which retains copies of variable attributes of a given ParsingContext
to
store the state of the parsing process at a given point in time.A simple a wrapper for a
ParsingContext
.The essential callback interface to handle records parsed by any parser that extends
AbstractParser
.The
ProcessorErrorHandler
is a callback used by the parser/writer to handle non-fatal DataProcessingException
s that may occur when
processing rows using a Processor
or RowWriterProcessor
.Wrapper for a implementation of PropertyDescriptor from either
java.beans.PropertyDescriptor
or com.googlecode.openbeans.PropertyDescriptor
.A record parsed from the input, with convenience methods for easier data manipulation.
A factory class that provides implementations of
Record
based on the current state
of an AbstractParser
(via its ParsingContext
), and raw input records.An iterator of
Record
s.Metadata with information about
Record
s parsed from the input.Replaces contents of a given input String, identified by a regular expression, with a replacement String.
Indicates the String value of a field must have some of its contents replaced using
RegexConversion
.An
Iterator
that provides the current parsing context
through the ResultIterator.getContext()
methodA
ProcessorErrorHandler
implementation that gives the user a chance to provide a default value for
columns that could not be processed due to an exception, through the method RetryableErrorHandler.setDefaultValue(Object)
.An iterator of
String[]
.A convenience
RowProcessor
implementation for storing all rows parsed into a list.An indicator of where the input a row is placed in relation to others.
The essential callback interface to handle records parsed by any parser that extends
AbstractParser
.The
RowProcessorErrorHandler
is a callback used by the parser/writer to handle non-fatal DataProcessingException
s that may occur when
processing rows using a RowProcessor
or RowWriterProcessor
.A special
RowProcessor
implementation that combines and allows switching among different
RowProcessors.The essential callback interface to convert input objects into a manageable format for writing.
A special
RowWriterProcessor
implementation that combines and allows switching among different
RowWriterProcessors.Converts Strings to Shorts and vice versa
A simple cache of values associated with strings.
Exception type used provide information about any issue that might happen while parsing from a given input.
Exception type used provide information about any issue that might happen while writing to a given output.
Converts any non-null object to its String representation.
A pair associating a Field of an annotated class to an optional
HeaderTransformer
obtained from
Nested.headerTransformer()
when nested classes are used to process beans.Indicates the String value of a field must be trimmed using
TrimConversion
.Removes leading and trailing white spaces from an input String
The
TrimConversion.revert(String)
implements the same behavior of TrimConversion.execute(String)
.The TSV format configuration, for tab-separated inputs.
A very fast TSV parser implementation.
This is the configuration class used by the TSV parser (
TsvParser
)A collection of common routines involving the processing of TSV data.
A powerful and flexible TSV writer implementation.
This is the configuration class used by the TSV writer (
TsvWriter
)This enumeration is used to determine how the (
CsvParser
) will handle values with unescaped quotes.Indicates the String value of a field must be converted to uppercase using
UpperCaseConversion
.Converts an input String to its upper case representation
The
UpperCaseConversion.revert(String)
implements the same behavior of UpperCaseConversion.execute(String)
.Performs basic validations against the String representation of the value found in the annotated field.
Performs one or more validations against the values of a given record.
Defines a custom validation process to be executed when reading or writing
values into a field of a java bean that is annotated with
Validate
Extension of the
DefaultCharAppender
class to include facilities for writing to an output.