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 concrete implementation of Processor that allows switching among different implementations of Processor based on values found on the rows parsed from the input.
 
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 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 Processor implementation that facilitates using multiple implementations of Processor at the same time.
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 thread
A RowProcessor implementation to perform row processing tasks in parallel.
Basic context information used internally by instances of Processor and Record.
A snapshot of a Context which retains copies of variable attributes of a given Context to store the state of the parsing process at a given point in time.
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 interface
A 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 objects
A 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/output
A 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() method
A 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)} method
A singleton instance of a RowProcessor that does nothing.
A 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 output
 
Indicates 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() method
A 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 Validate
Extension of the DefaultCharAppender class to include facilities for writing to an output.