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
ColumnMapperA 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
RecordBasic 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
ParsedAn 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
Processors 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
Processors 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 ValidateConverts 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
FixedInstancePoolConverts 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 FixedWidthWriterDeprecated.
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 InputStreams and Readers) 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 DataProcessingExceptions 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
Records.Metadata with information about
Records 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 DataProcessingExceptions 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
ValidateExtension of the
DefaultCharAppender class to include facilities for writing to an output.