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.
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.
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.
Expands on HeaderColumnNameMappingStrategy by allowing the user to pass in a map of column names to bean names.
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.
This is the interface for validators for a String read by the Reader in the CSVReader before it is processed.
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.
This is the interface for processors for an array of Strings read by the CSVReader before they are validated.
This is the interface for validators for an array of Strings read by the CSVReader after it is processed.
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.