All Classes and Interfaces

Class	Description
AbstractBatchedColumnProcessor<T extends Context>	A Processor implementation that stores values of columns in batches.
AbstractBatchedObjectColumnProcessor<T extends Context>	A Processor implementation for converting batches of rows extracted from any implementation of AbstractParser into columns of objects.
AbstractBeanListProcessor<T,C extends Context>	A convenience Processor implementation for storing all java objects generated form the parsed input into a list.
AbstractBeanProcessor<T,C extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
AbstractCharInputReader	The base class for implementing different flavours of CharInputReader.
AbstractColumnProcessor<T extends Context>	A simple Processor implementation that stores values of columns.
AbstractConcurrentProcessor<T extends Context>	A Processor implementation to perform row processing tasks in parallel.
AbstractInputValueSwitch<T extends Context>	A concrete implementation of Processor that allows switching among different implementations of Processor based on values found on the rows parsed from the input.
AbstractListProcessor<T extends Context>	A convenience Processor implementation for storing all rows parsed into a list.
AbstractMasterDetailListProcessor<T extends Context>	A convenience Processor implementation for storing all MasterDetailRecord generated form the parsed input into a list.
AbstractMasterDetailProcessor<T extends Context>	A Processor implementation for associating rows extracted from any implementation of AbstractParser into MasterDetailRecord instances.
AbstractMultiBeanListProcessor<C extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into java objects, storing them into lists.
AbstractMultiBeanProcessor<C extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
AbstractMultiBeanRowProcessor<C extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
AbstractObjectColumnProcessor<T extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into columns of objects.
AbstractObjectListProcessor<T extends Context>	A convenience Processor implementation for storing all rows parsed and converted to Object arrays into a list.
AbstractObjectProcessor<T extends Context>	A Processor implementation for converting rows extracted from any implementation of AbstractParser into arrays of objects.
AbstractParser<T extends CommonParserSettings<?>>	The AbstractParser class provides a common ground for all parsers in univocity-parsers.
AbstractProcessor<T extends Context>	A Processor implementation that just implements all methods defined by the interface.
AbstractProcessorSwitch<T extends Context>	A special Processor implementation that combines and allows switching among different Processors.
AbstractRecordFactory<R extends Record,M extends RecordMetaData>	An abstract factory class which allows subclasses to provide implementations of Record
AbstractRoutines<P extends CommonParserSettings<?>,W extends CommonWriterSettings<?>>	Basic implementation of commonly used routines around parsing/writing of data that can be reused and extended by parsers/writers of any supported format.
AbstractRowProcessor	A RowProcessor implementation that just implements all methods defined by the interface.
AbstractWriter<S extends CommonWriterSettings<?>>	The AbstractWriter class provides a common ground for all writers in univocity-parsers.
AllIndexesSelector	A FieldSelector that selects all indexes of a record.
AnnotationHelper	Helper class to process fields annotated with Parsed
AnnotationRegistry	An internal registry of annotated elements and their properties that have been set via a Copy annotation.
ArgumentUtils	An utility class for validating inputs.
BatchedColumnProcessor	A RowProcessor implementation that stores values of columns in batches.
BatchedObjectColumnProcessor	A RowProcessor implementation for converting batches of rows extracted from any implementation of AbstractParser into columns of objects.
BeanConversionProcessor<T>	The base class for Processor and RowWriterProcessor implementations that support java beans annotated with the annotations provided in com.univocity.parsers.annotations.
BeanHelper	Helper class used to obtain property descriptors from annotated java beans whose values are set via reflection.
BeanListProcessor<T>	A convenience BeanProcessor implementation for storing all java objects generated form the parsed input into a list.
BeanProcessor<T>	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
BeanWriterProcessor<T>	A RowWriterProcessor implementation for converting annotated java objects into object arrays suitable for writing in any implementation of AbstractWriter.
BigDecimalConversion	Converts Strings to BigDecimals and vice versa
BigIntegerConversion	Converts Strings to BigIntegers and vice versa
BomInput	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.
BomInput.BytesProcessedNotification	Internal notification exception used to re-wrap the original InputStream into a Reader.
BooleanConversion	Converts Strings to Booleans and vice versa
BooleanString	Indicates that parsed values such as "y", "No" or "null" should be interpreted as boolean values.
ByteConversion	Converts Strings to Bytes and vice versa
CalendarConversion	Converts Strings to instances of Calendar and vice versa.
CharacterConversion	Converts Strings to Characters and vice versa
CharAppender	The general interface for classes responsible for appending characters efficiently while handling whitespaces and padding characters.
CharInput	A (very) basic character input definition.
CharInputReader	The definition of a character input reader used by all univocity-parsers that extend AbstractParser.
ColumnMap	Class responsible for calculating and storing the position of fields parsed from the input.
ColumnMapper	A utility that allows users to manually define mappings from attributes/methods of a given class to columns to be parsed or written.
ColumnMapping	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.
ColumnOrderDependent	A marker interface used by special implementations of RowProcessor to indicate columns should not be reordered by the parser.
ColumnProcessor	A simple RowProcessor implementation that stores values of columns.
CommonParserSettings<F extends Format>	This is the parent class for all configuration classes used by parsers (AbstractParser)
CommonSettings<F extends Format>	This is the parent class for all configuration classes used by parsers (AbstractParser) and writers (AbstractWriter)
CommonWriterSettings<F extends Format>	This is the parent class for all configuration classes used by writers (AbstractWriter)
CompositeProcessor<C extends Context>	A utility Processor implementation that facilitates using multiple implementations of Processor at the same time.
CompositeRowProcessor	A utility RowProcessor implementation that facilitates using multiple implementations of RowProcessor at the same time.
ConcurrentCharInputReader	A concurrent CharInputReader that loads batches of characters in a separate thread and assigns them to buffer in AbstractCharInputReader when requested.
ConcurrentRowProcessor	A RowProcessor implementation to perform row processing tasks in parallel.
Context	Basic context information used internally by instances of Processor and Record.
ContextSnapshot<T extends Context>	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.
ContextWrapper<T extends Context>	A simple a wrapper for a Context.
Conversion<I,O>	The interface that defines the conversion from one type of value to another, and vice versa.
ConversionProcessor	A basic interface for classes that associate Conversion implementations with fields of a given input/output.
Conversions	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.
Convert	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.
Copy	Allows copying values of meta-annotation properties into the properties of an annotation that composes it.
Csv	This class provides default configurations using CSV formats commonly used for parsing/writing.
CsvFormat	The CSV format configuration.
CsvFormatDetector	An InputAnalysisProcess to detect column delimiters, quotes and quote escapes in a CSV input.
CsvParser	A very fast CSV parser implementation.
CsvParserSettings	This is the configuration class used by the CSV parser (CsvParser)
CsvRoutines	A collection of common routines involving the processing of CSV data.
CsvWriter	A powerful and flexible CSV writer implementation.
CsvWriterSettings	This is the configuration class used by the CSV writer (CsvWriter)
CustomMatcher	Interface used by InputValueSwitch to allow users to to provide custom matching rules against input values.
DataProcessingException	A DataProcessingException is an error thrown during the processing of a record successfully parsed.
DataValidationException	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
DateConversion	Converts Strings to instances of Date and vice versa.
DefaultCharAppender	Default implementation of the CharAppender interface
DefaultCharInputReader	A default CharInputReader which only loads batches of characters when requested by the AbstractCharInputReader through the DefaultCharInputReader.reloadBuffer() method.
DefaultContext	Default implementation of the Context interface with essential information about the output being produced.
DefaultConversionProcessor	The base class for RowProcessor and RowWriterProcessor implementations that support value conversions provided by Conversion instances.
DefaultParsingContext	The default ParsingContext implementation used internally by AbstractParser to expose information about a parsing process in execution.
DoubleConversion	Converts Strings to Doubles and vice versa
ElasticCharAppender	A character appender that restores its internal buffer size after expanding to accommodate larger contents.
EnumConversion<T extends Enum<T>>	Converts Strings to enumeration constants and vice versa.
EnumOptions	The EnumSelector annotation is meant to be used in conjunction with enumeration attributes.
EnumSelector	Identifies a property of an enumeration that should be used by EnumOptions to identify an input value.
EOFException	Internal exception marker to signalize the end of the input.
ExcludeFieldEnumSelector	A FieldSelector capable of deselecting fields in a record.
ExcludeFieldIndexSelector	A FieldSelector capable of deselecting fields by their position in a record.
ExcludeFieldNameSelector	A FieldSelector capable of deselecting fields by their name in a record.
ExpandingCharAppender	An implementation CharAppender that expands the internal buffer of characters as required.
FieldAlignment	Alignment of text in a fixed-width field.
FieldConversionMapping	A class for mapping field selections to sequences of Conversion objects
FieldEnumSelector	A FieldSelector capable of selecting fields represented by values of an enumeration type.
FieldIndexSelector	A FieldSelector capable of selecting fields by their position in a record.
FieldMapping	A helper class with information about the location of an field annotated with Parsed in a record.
FieldNameSelector	A FieldSelector capable of selecting fields by their name.
FieldSelector	Interface used to identify classes capable of selecting fields and returning their positions in a given sequence.
FieldSet<T>	A set of selected fields.
FixedWidth	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
FixedWidthFieldLengths	Deprecated. This class has been modified over time and its name became misleading.
FixedWidthFields	This class provides the name, length, alignment and padding of each field in a fixed-width record.
FixedWidthFormat	The Fixed-Width format configuration.
FixedWidthParser	A fast and flexible fixed-with parser implementation.
FixedWidthParserSettings	This is the configuration class used by the Fixed-Width parser (FixedWidthParser)
FixedWidthRoutines	A collection of common routines involving the processing of Fixed-Width data.
FixedWidthWriter	A fast and flexible fixed-with writer implementation.
FixedWidthWriterSettings	This is the configuration class used by the Fixed-Width writer (FixedWidthWriter)
FloatConversion	Converts Strings to Floats and vice versa
Format	Indicates that a parsed value is formatted and must be parsed before being assigned.
Format	This is the parent class for all configuration classes that define a text format.
FormattedBigDecimalConversion	Converts formatted Strings to instances of BigDecimal and vice versa.
FormattedConversion<T>	This interface identifies conversions associated with the Format annotation.
FormattedDateConversion	Converts objects of different date types (java.util.Date and java.util.Calendar) to a formatted date String.
Headers	The Headers annotation allows java beans to configure how to handle field names in a given input/output
HeaderTransformer	A transformer of headers used in Nested attributes.
InputAnalysisProcess	A process to be executed over a sample of data being parsed.
InputDimension	A simple class to hold information about the dimensions of a given input, which are calculated using AbstractRoutines.getInputDimension(File)
InputValueSwitch	A concrete implementation of RowProcessorSwitch that allows switching among different implementations of RowProcessor based on values found on the rows parsed from the input.
IntegerConversion	Converts Strings to Integers and vice versa
IterableResult<T,C extends Context>	An Iterable result that provides the current parsing context through the IterableResult.getContext() method
LineSeparatorDetector	An InputAnalysisProcess to detect the line separators used in the input.
LongConversion	Converts Strings to Longs and vice versa
LookaheadCharInputReader	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.
LowerCase	Indicates the String value of a field must be converted to lower case using LowerCaseConversion.
LowerCaseConversion	Converts an input String to its lower case representation The LowerCaseConversion.revert(String) implements the same behavior of LowerCaseConversion.execute(String).
MasterDetailListProcessor	A convenience MasterDetailProcessor implementation for storing all MasterDetailRecord generated form the parsed input into a list.
MasterDetailProcessor	A RowProcessor implementation for associating rows extracted from any implementation of AbstractParser into MasterDetailRecord instances.
MasterDetailRecord	An utility class to store data of a master row and its detail records.
MethodDescriptor	A very basic descriptor or getter/setter methods
MethodFilter	A filter for annotated methods.
MultiBeanListProcessor	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into java objects, storing them into lists.
MultiBeanProcessor	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
MultiBeanRowProcessor	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into java objects.
Nested	Marks a field as a nested object to be constructed with the values of the current row.
NoopCharAppender	An implementation of CharAppender that does nothing.
NoopProcessor	A singleton instance of a Processor that does nothing.
NoopProcessorErrorHandler<T extends Context>	An (singleton) implementation of ProcessorErrorHandler that simply rethrows any DataProcessingException that comes into its NoopProcessorErrorHandler.handleError(DataProcessingException, Object[], Context)} method
NoopRowProcessor	A singleton instance of a RowProcessor that does nothing.
NormalizedString	A NormalizedString allows representing text in a normalized fashion.
NullConversion<I,O>	Default implementation for conversions from input Objects of type I to output Objects of type O
NullString	Indicates that parsed values such as "", "?" or "null" should be interpreted as null.
NullStringConversion	Converts Strings to null and vice versa
NumericConversion<T extends Number>	Converts Strings to instances of Number and vice versa.
ObjectColumnProcessor	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into columns of objects.
ObjectConversion<T>	Default implementation for conversions from an input String to Objects of a given type T
ObjectRowListProcessor	A convenience RowProcessor implementation for storing all rows parsed and converted to Object arrays into a list.
ObjectRowProcessor	A RowProcessor implementation for converting rows extracted from any implementation of AbstractParser into arrays of objects.
ObjectRowWriterProcessor	A RowWriterProcessor implementation for executing conversion sequences in object arrays before for writing them using any implementation of AbstractWriter.
OutputValueSwitch	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
Parsed	Indicates the field is parsed.
ParserOutput	The ParserOutput is the component that manages records parsed by AbstractParser and their values.
ParsingContext	Parsing context information available to instances of RowProcessor.
ParsingContextSnapshot	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.
ParsingContextWrapper	A simple a wrapper for a ParsingContext.
Processor<T extends Context>	The essential callback interface to handle records parsed by any parser that extends AbstractParser.
ProcessorErrorHandler<T extends Context>	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.
PropertyWrapper	Wrapper for a implementation of PropertyDescriptor from either java.beans.PropertyDescriptor or com.googlecode.openbeans.PropertyDescriptor.
Record	A record parsed from the input, with convenience methods for easier data manipulation.
RecordFactory	A factory class that provides implementations of Record based on the current state of an AbstractParser(via its ParsingContext), and raw input records.
RecordIterator	An iterator of Records.
RecordMetaData	Metadata with information about Records parsed from the input.
RegexConversion	Replaces contents of a given input String, identified by a regular expression, with a replacement String.
Replace	Indicates the String value of a field must have some of its contents replaced using RegexConversion.
ResultIterator<T,C extends Context>	An Iterator that provides the current parsing context through the ResultIterator.getContext() method
RetryableErrorHandler<T extends Context>	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).
RowIterator	An iterator of String[].
RowListProcessor	A convenience RowProcessor implementation for storing all rows parsed into a list.
RowPlacement	An indicator of where the input a row is placed in relation to others.
RowProcessor	The essential callback interface to handle records parsed by any parser that extends AbstractParser.
RowProcessorErrorHandler	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.
RowProcessorSwitch	A special RowProcessor implementation that combines and allows switching among different RowProcessors.
RowWriterProcessor<T>	The essential callback interface to convert input objects into a manageable format for writing.
RowWriterProcessorSwitch	A special RowWriterProcessor implementation that combines and allows switching among different RowWriterProcessors.
ShortConversion	Converts Strings to Shorts and vice versa
StringCache<T>	A simple cache of values associated with strings.
TextParsingException	Exception type used provide information about any issue that might happen while parsing from a given input.
TextWritingException	Exception type used provide information about any issue that might happen while writing to a given output.
ToStringConversion	Converts any non-null object to its String representation.
TransformedHeader	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.
Trim	Indicates the String value of a field must be trimmed using TrimConversion.
TrimConversion	Removes leading and trailing white spaces from an input String The TrimConversion.revert(String) implements the same behavior of TrimConversion.execute(String).
TsvFormat	The TSV format configuration, for tab-separated inputs.
TsvParser	A very fast TSV parser implementation.
TsvParserSettings	This is the configuration class used by the TSV parser (TsvParser)
TsvRoutines	A collection of common routines involving the processing of TSV data.
TsvWriter	A powerful and flexible TSV writer implementation.
TsvWriterSettings	This is the configuration class used by the TSV writer (TsvWriter)
UnescapedQuoteHandling	This enumeration is used to determine how the (CsvParser) will handle values with unescaped quotes.
UpperCase	Indicates the String value of a field must be converted to uppercase using UpperCaseConversion.
UpperCaseConversion	Converts an input String to its upper case representation The UpperCaseConversion.revert(String) implements the same behavior of UpperCaseConversion.execute(String).
Validate	Performs basic validations against the String representation of the value found in the annotated field.
ValidatedConversion	Performs one or more validations against the values of a given record.
Validator<T>	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
WriterCharAppender	Extension of the DefaultCharAppender class to include facilities for writing to an output.