All Classes and Interfaces
Class
Description
This base bean takes over the responsibility of converting the supplied
string to the proper type for the destination field and setting the
destination field.
This implementation of
CsvConverter provides a reasonable default
for CsvConverter.convertToWrite(java.lang.Object) as well as a couple
of common fields.The purpose of the AbstractCSVParser is to consolidate the duplicate code amongst the
parsers.
The AbstractCSVWriter was created to prevent duplication of code between the CSVWriter and the
CSVParserWriter classes.
A base class to collect all generalized components of a
FieldMap.Collects common aspects of a
ComplexFieldMapEntry.This class collects as many generally useful parts of the implementation
of a mapping strategy as possible.
Encapsulates a bean type and all of the member variables that need to be
recursed into.
Functional interface for accessing a value from a field.
The accumulator takes two queues of results of transforming text input
into bean output or bean input into text output (output and exceptions)
and orders them for later consumption.
Functional interface for assigning a value to a field.
A specific derivative of
IntolerantThreadPoolExecutor intended for
submitting beans to be converted to Strings for writing.Used to extend the
Field class to include
functionality that opencsv requires.This class is used for combining multiple columns of the input, possibly
with multiple identically named columns, into one field.
Implements a
BeanFieldJoin with a Integer for an
index.Implements a
BeanFieldJoin with a String for an
index.This class concerns itself with handling single-valued bean fields.
This class concerns itself with handling collection-valued bean fields.
Classes implementing this interface may be used to verify and filter beans
after creation, but before being passed back to the calling application.
Allows for the mapping of columns with their positions.
Builder for a
ColumnPositionMappingStrategy.Implements a separate thread for reading input and siphoning it to a
LineExecutor.Defines the basic functionality necessary for using a many-to-one mapping
between columns of a CSV file and bean fields.
StringProcessor that converts the empty or blank strings to a desired value string.
StringProcessor that converts the empty or blank strings to a literal null string.
This class converts an input ISO 4217 currency code to a
Currency
instance.This class converts an input to a date type.
This class converts an input to an enumeration type and vice versa.
A base class for any converter to and from booleans when the string
values have been or should be localized to a specific language.
This converter class is used in combination with
CsvNumber, that is,
when number inputs and outputs should be formatted.This class wraps fields from the reflection API in order to handle
translation of primitive types and to add a "required" flag.
This class converts an String to a
UUID
instance.This class converts common French representations of boolean values into a
Boolean.This class converts common German representations of boolean values into a
Boolean.StringProcessor that converts the string value "null" to a literal null string.
This exception indicates that the converter did not behave as expected in
some way.
This exception is to be thrown when anything goes bad during introspection of
beans given to opencsv.
Joins the values of multiple columns from the input into one bean field based
on a pattern for the column names.
This annotation is the container annotation for
CsvBindAndJoinByName.Joins the values of multiple columns from the input into one bean field based
on a selection of column positions.
This annotation is the container annotation for
CsvBindAndJoinByPosition.This annotation interprets one field of the input as a collection that will
be split up into its components and assigned to a collection-based bean field.
This annotation is the container annotation for
CsvBindAndSplitByName.This annotation interprets one field of the input as a collection that will
be split up into its components and assigned to a collection-based bean field.
This annotation is the container annotation for
CsvBindAndSplitByPosition.Specifies a binding between a column name of the CSV input and a field in a
bean.
This annotation is the container annotation for
CsvBindByName.Specifies a binding between a column number of the CSV input and a field in
a bean.
This annotation is the container annotation for
CsvBindByPosition.An exception class for collecting multiple exceptions.
This exception is thrown when logical connections between data fields would
be violated by the imported data.
Classes implementing this interface perform a conversion from String to
some type on reading and some type to String on writing.
Allows us to specify a class that will perform the translation from source
to destination.
This annotation is the container annotation for
CsvCustomBindByName.Allows us to specify a class that will perform the translation from source
to destination.
This annotation is the container annotation for
CsvCustomBindByPosition.This exception should be thrown when the provided string value for conversion
cannot be converted to the required type of the destination field.
This annotation indicates that the destination field is an expression of time.
This annotation is the container annotation for
CsvDate.This is the base class for all exceptions for opencsv.
This interface defines a generic way of dealing with exceptions thrown
during the creation of beans or their conversion to CSV output.
Superclass for checked exceptions that can be thrown while trying to decode
and assign a single field.
Instructs opencsv to ignore a field and any annotations present.
Provides an Iterator over the data found in opencsv.
Exception that is thrown when the
CSVReader cannot process a line.Exception when you break the line limit of a multiline field.
This annotation indicates that the destination field is a number that is
specially formatted.
This annotation is the container annotation for
CsvNumber.A very simple CSV parser released under a commercial-friendly license.
This class serves to optimize
AbstractCSVParser.parseLine(java.lang.String),
which is the hot inner loop of opencsv.Builder for creating a CSVParser.
The CSVParserWriter is a replacement for the CSVWriter that allows you to pass in a ICSVParser
to handle the task of converting a string array to a line of CSV data.
A very simple CSV reader released under a commercial-friendly license.
Base class for the builders of various incarnations of CSVReaders.
Builder for creating a
CSVReader.Handy reader when there's insufficient motivation to use the bean binding but
the header mapping is still desired.
Builder for
CSVReaderHeaderAware.Enumeration used to tell the CSVParser what to consider null.
Instructs a mapping strategy to look inside a member variable for further
mapping annotations.
This exception is thrown on initiation of field mapping if
CsvRecurse has been improperly used.This exception should be thrown when a field marked as required is empty in
the CSV file.
The base class for all unchecked exceptions in opencsv.
Converts CSV data to objects.
This class makes it possible to bypass all the intermediate steps and classes
in setting up to read from a CSV source to a list of beans.
Filters allow lines of input to be ignored before a bean is created.
Exception thrown by a
LineValidator or
LineValidatorAggregator when a single line is invalid.A very simple CSV writer released under a commercial-friendly license.
Builder for creating the CSVWriter.
An exception handler that always ignores exceptions raised.
An exception handler that ignores the first x exceptions, then throws any
further exceptions.
An exception handler that always queues exceptions raised.
An exception handler that queues the first x exceptions, then throws any
further exceptions.
An exception handler that always throws exceptions raised.
Encapsulates the logic for accessing member variables of classes.
Defines the basic characteristics of a map between field identifiers and
their associated
BeanFields.This class maintains a mapping from header names out of a CSV file to bean
fields.
Represents one entry in
FieldMapByName.This class maintains a mapping from column position out of a CSV file to bean
fields.
Represents one entry in
FieldMapByPosition.A mapping strategy that tries to make the best match between header names
and non-annotated member variables.
This is a simple class for grouping header name, member variable name,
and the result of fuzzy matching in one sortable place.
Builder for a
FuzzyMappingStrategy.Maps data to objects using the column names in the first row of the CSV file
as reference.
Builder for a
HeaderColumnNameMappingStrategy.Expands on
HeaderColumnNameMappingStrategy by allowing the user to
pass in a map of column names to bean names.Builder for a
HeaderColumnNameMappingStrategy.A bi-directional mapping between column positions and header names.
This class serves as a location to collect code common to a mapping strategy
that maps header names to member variables.
This interface defines all of the behavior
CSVReader
needs from a parser to tokenize an input line for further processing.This interface defines all the behavior of a csv writer class.
This ThreadPoolExecutor automatically shuts down on any failed thread.
A specific derivative of
IntolerantThreadPoolExecutor intended for
submitting lines of input to be converted to beans.This class was created for
issue #106
where carriage returns were being removed.
The aggregator's purpose is to collect multiple
LineValidators and
run them against a single line.Deprecated.
This exact behavior can be had using comparators from Apache
Commons Collections, which opencsv includes as a dependency.
The interface for the classes that handle translating between the columns in
the CSV file to an actual object.
This is a validator that, due to the addition of the parameter, allows the validation of multiple different types
of input.
This class is meant to be a collection of general purpose static methods
useful in internal processing for opencsv.
A simple class for ordering objects.
Maps any column position matching a range definition to a
BeanField.Specifies the binding of a processor to a field in a bean.
Specifies the binding of a validator to a field in a bean.
A class for converting one bean into its string representation for writing to
an output.
A class that encapsulates the job of creating a bean from a line of CSV input
and making it possible to run those jobs in parallel.
Maps any header name matching a regular expression to a
BeanField.Helper class for processing JDBC ResultSet objects allowing the user to
process a subset of columns and set custom header names.
Interface for the ResultSetHelperService.
Helper class for processing JDBC ResultSet objects.
This Parser is meant to parse according to the RFC4180 specification.
Builder for creating a RFC4180Parser.
This validator is best used to validate a specific property of the row - either about a specific
element or information about the array itself.
This validator is used when the number of columns is not neccessarily known but must be consistent.
The aggregator's purpose is to collect multiple
RowValidators and
run them against a single array of strings.This class exists to isolate the logic for reading a single line of input
that is common to
CsvToBean.iterator() and CompleteFileReader.This class writes beans out in CSV format to a
Writer,
keeping state information and making an intelligent guess at the mapping
strategy to be applied.This is a builder for StatefulBeanToCsv, allowing one to set all parameters
necessary for writing a CSV file.
This is the interface for validators for a single
String value.This is the interface for validators for a single
String value.