/* | |
* Licensed to the Apache Software Foundation (ASF) under one or more | |
* contributor license agreements. See the NOTICE file distributed with | |
* this work for additional information regarding copyright ownership. | |
* The ASF licenses this file to You under the Apache License, Version 2.0 | |
* (the "License"); you may not use this file except in compliance with | |
* the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
package org.apache.commons.csv; | |
import static org.apache.commons.csv.Constants.BACKSLASH; | |
import static org.apache.commons.csv.Constants.COMMA; | |
import static org.apache.commons.csv.Constants.COMMENT; | |
import static org.apache.commons.csv.Constants.CR; | |
import static org.apache.commons.csv.Constants.CRLF; | |
import static org.apache.commons.csv.Constants.DOUBLE_QUOTE_CHAR; | |
import static org.apache.commons.csv.Constants.EMPTY; | |
import static org.apache.commons.csv.Constants.LF; | |
import static org.apache.commons.csv.Constants.PIPE; | |
import static org.apache.commons.csv.Constants.SP; | |
import static org.apache.commons.csv.Constants.TAB; | |
import java.io.File; | |
import java.io.FileOutputStream; | |
import java.io.IOException; | |
import java.io.OutputStreamWriter; | |
import java.io.Reader; | |
import java.io.Serializable; | |
import java.io.StringWriter; | |
import java.io.Writer; | |
import java.nio.charset.Charset; | |
import java.nio.file.Files; | |
import java.nio.file.Path; | |
import java.sql.ResultSet; | |
import java.sql.ResultSetMetaData; | |
import java.sql.SQLException; | |
import java.util.Arrays; | |
import java.util.HashSet; | |
import java.util.Objects; | |
import java.util.Set; | |
/** | |
* Specifies the format of a CSV file and parses input. | |
* | |
* <h2>Using predefined formats</h2> | |
* | |
* <p> | |
* You can use one of the predefined formats: | |
* </p> | |
* | |
* <ul> | |
* <li>{@link #DEFAULT}</li> | |
* <li>{@link #EXCEL}</li> | |
* <li>{@link #INFORMIX_UNLOAD}</li> | |
* <li>{@link #INFORMIX_UNLOAD_CSV}</li> | |
* <li>{@link #MYSQL}</li> | |
* <li>{@link #RFC4180}</li> | |
* <li>{@link #ORACLE}</li> | |
* <li>{@link #POSTGRESQL_CSV}</li> | |
* <li>{@link #POSTGRESQL_TEXT}</li> | |
* <li>{@link #TDF}</li> | |
* </ul> | |
* | |
* <p> | |
* For example: | |
* </p> | |
* | |
* <pre> | |
* CSVParser parser = CSVFormat.EXCEL.parse(reader); | |
* </pre> | |
* | |
* <p> | |
* The {@link CSVParser} provides static methods to parse other input types, for example: | |
* </p> | |
* | |
* <pre> | |
* CSVParser parser = CSVParser.parse(file, StandardCharsets.US_ASCII, CSVFormat.EXCEL); | |
* </pre> | |
* | |
* <h2>Defining formats</h2> | |
* | |
* <p> | |
* You can extend a format by calling the {@code set} methods. For example: | |
* </p> | |
* | |
* <pre> | |
* CSVFormat.EXCEL.withNullString("N/A").withIgnoreSurroundingSpaces(true); | |
* </pre> | |
* | |
* <h2>Defining column names</h2> | |
* | |
* <p> | |
* To define the column names you want to use to access records, write: | |
* </p> | |
* | |
* <pre> | |
* CSVFormat.EXCEL.withHeader("Col1", "Col2", "Col3"); | |
* </pre> | |
* | |
* <p> | |
* Calling {@link Builder#setHeader(String...)} lets you use the given names to address values in a {@link CSVRecord}, and assumes that your CSV source does not | |
* contain a first record that also defines column names. | |
* | |
* If it does, then you are overriding this metadata with your names and you should skip the first record by calling | |
* {@link Builder#setSkipHeaderRecord(boolean)} with {@code true}. | |
* </p> | |
* | |
* <h2>Parsing</h2> | |
* | |
* <p> | |
* You can use a format directly to parse a reader. For example, to parse an Excel file with columns header, write: | |
* </p> | |
* | |
* <pre> | |
* Reader in = ...; | |
* CSVFormat.EXCEL.withHeader("Col1", "Col2", "Col3").parse(in); | |
* </pre> | |
* | |
* <p> | |
* For other input types, like resources, files, and URLs, use the static methods on {@link CSVParser}. | |
* </p> | |
* | |
* <h2>Referencing columns safely</h2> | |
* | |
* <p> | |
* If your source contains a header record, you can simplify your code and safely reference columns, by using {@link Builder#setHeader(String...)} with no | |
* arguments: | |
* </p> | |
* | |
* <pre> | |
* CSVFormat.EXCEL.withHeader(); | |
* </pre> | |
* | |
* <p> | |
* This causes the parser to read the first record and use its values as column names. | |
* | |
* Then, call one of the {@link CSVRecord} get method that takes a String column name argument: | |
* </p> | |
* | |
* <pre> | |
* String value = record.get("Col1"); | |
* </pre> | |
* | |
* <p> | |
* This makes your code impervious to changes in column order in the CSV file. | |
* </p> | |
* | |
* <h2>Notes</h2> | |
* | |
* <p> | |
* This class is immutable. | |
* </p> | |
*/ | |
public final class CSVFormat implements Serializable { | |
/** | |
* Builds CSVFormat instances. | |
* | |
* @since 1.9.0 | |
*/ | |
public static class Builder { | |
/** | |
* Creates a new default builder. | |
* | |
* @return a copy of the builder | |
*/ | |
public static Builder create() { | |
return new Builder(CSVFormat.DEFAULT); | |
} | |
/** | |
* Creates a new builder for the given format. | |
* | |
* @param csvFormat the source format. | |
* @return a copy of the builder | |
*/ | |
public static Builder create(final CSVFormat csvFormat) { | |
return new Builder(csvFormat); | |
} | |
private boolean allowMissingColumnNames; | |
private boolean autoFlush; | |
private Character commentMarker; | |
private String delimiter; | |
private DuplicateHeaderMode duplicateHeaderMode; | |
private Character escapeCharacter; | |
private String[] headerComments; | |
private String[] headers; | |
private boolean ignoreEmptyLines; | |
private boolean ignoreHeaderCase; | |
private boolean ignoreSurroundingSpaces; | |
private String nullString; | |
private Character quoteCharacter; | |
private String quotedNullString; | |
private QuoteMode quoteMode; | |
private String recordSeparator; | |
private boolean skipHeaderRecord; | |
private boolean trailingDelimiter; | |
private boolean trim; | |
private Builder(final CSVFormat csvFormat) { | |
this.delimiter = csvFormat.delimiter; | |
this.quoteCharacter = csvFormat.quoteCharacter; | |
this.quoteMode = csvFormat.quoteMode; | |
this.commentMarker = csvFormat.commentMarker; | |
this.escapeCharacter = csvFormat.escapeCharacter; | |
this.ignoreSurroundingSpaces = csvFormat.ignoreSurroundingSpaces; | |
this.allowMissingColumnNames = csvFormat.allowMissingColumnNames; | |
this.ignoreEmptyLines = csvFormat.ignoreEmptyLines; | |
this.recordSeparator = csvFormat.recordSeparator; | |
this.nullString = csvFormat.nullString; | |
this.headerComments = csvFormat.headerComments; | |
this.headers = csvFormat.header; | |
this.skipHeaderRecord = csvFormat.skipHeaderRecord; | |
this.ignoreHeaderCase = csvFormat.ignoreHeaderCase; | |
this.trailingDelimiter = csvFormat.trailingDelimiter; | |
this.trim = csvFormat.trim; | |
this.autoFlush = csvFormat.autoFlush; | |
this.quotedNullString = csvFormat.quotedNullString; | |
this.duplicateHeaderMode = csvFormat.duplicateHeaderMode; | |
} | |
/** | |
* Builds a new CSVFormat instance. | |
* | |
* @return a new CSVFormat instance. | |
*/ | |
public CSVFormat build() { | |
return new CSVFormat(this); | |
} | |
/** | |
* Sets the duplicate header names behavior, true to allow, false to disallow. | |
* | |
* @param allowDuplicateHeaderNames the duplicate header names behavior, true to allow, false to disallow. | |
* @return This instance. | |
* @deprecated Use {@link #setDuplicateHeaderMode(DuplicateHeaderMode)}. | |
*/ | |
@Deprecated | |
public Builder setAllowDuplicateHeaderNames(final boolean allowDuplicateHeaderNames) { | |
final DuplicateHeaderMode mode = allowDuplicateHeaderNames ? DuplicateHeaderMode.ALLOW_ALL : DuplicateHeaderMode.ALLOW_EMPTY; | |
setDuplicateHeaderMode(mode); | |
return this; | |
} | |
/** | |
* Sets the missing column names behavior, {@code true} to allow missing column names in the header line, {@code false} to cause an | |
* {@link IllegalArgumentException} to be thrown. | |
* | |
* @param allowMissingColumnNames the missing column names behavior, {@code true} to allow missing column names in the header line, {@code false} to | |
* cause an {@link IllegalArgumentException} to be thrown. | |
* @return This instance. | |
*/ | |
public Builder setAllowMissingColumnNames(final boolean allowMissingColumnNames) { | |
this.allowMissingColumnNames = allowMissingColumnNames; | |
return this; | |
} | |
/** | |
* Sets whether to flush on close. | |
* | |
* @param autoFlush whether to flush on close. | |
* @return This instance. | |
*/ | |
public Builder setAutoFlush(final boolean autoFlush) { | |
this.autoFlush = autoFlush; | |
return this; | |
} | |
/** | |
* Sets the comment start marker, use {@code null} to disable. | |
* | |
* Note that the comment start character is only recognized at the start of a line. | |
* | |
* @param commentMarker the comment start marker, use {@code null} to disable. | |
* @return This instance. | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
*/ | |
public Builder setCommentMarker(final char commentMarker) { | |
setCommentMarker(Character.valueOf(commentMarker)); | |
return this; | |
} | |
/** | |
* Sets the comment start marker, use {@code null} to disable. | |
* | |
* Note that the comment start character is only recognized at the start of a line. | |
* | |
* @param commentMarker the comment start marker, use {@code null} to disable. | |
* @return This instance. | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
*/ | |
public Builder setCommentMarker(final Character commentMarker) { | |
if (isLineBreak(commentMarker)) { | |
throw new IllegalArgumentException("The comment start marker character cannot be a line break"); | |
} | |
this.commentMarker = commentMarker; | |
return this; | |
} | |
/** | |
* Sets the delimiter character. | |
* | |
* @param delimiter the delimiter character. | |
* @return This instance. | |
*/ | |
public Builder setDelimiter(final char delimiter) { | |
return setDelimiter(String.valueOf(delimiter)); | |
} | |
/** | |
* Sets the delimiter character. | |
* | |
* @param delimiter the delimiter character. | |
* @return This instance. | |
*/ | |
public Builder setDelimiter(final String delimiter) { | |
if (containsLineBreak(delimiter)) { | |
throw new IllegalArgumentException("The delimiter cannot be a line break"); | |
} | |
this.delimiter = delimiter; | |
return this; | |
} | |
/** | |
* Sets the duplicate header names behavior. | |
* | |
* @param duplicateHeaderMode the duplicate header names behavior | |
* @return This instance. | |
*/ | |
public Builder setDuplicateHeaderMode(final DuplicateHeaderMode duplicateHeaderMode) { | |
this.duplicateHeaderMode = duplicateHeaderMode; | |
return this; | |
} | |
/** | |
* Sets the escape character. | |
* | |
* @param escapeCharacter the escape character. | |
* @return This instance. | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
*/ | |
public Builder setEscape(final char escapeCharacter) { | |
setEscape(Character.valueOf(escapeCharacter)); | |
return this; | |
} | |
/** | |
* Sets the escape character. | |
* | |
* @param escapeCharacter the escape character. | |
* @return This instance. | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
*/ | |
public Builder setEscape(final Character escapeCharacter) { | |
if (isLineBreak(escapeCharacter)) { | |
throw new IllegalArgumentException("The escape character cannot be a line break"); | |
} | |
this.escapeCharacter = escapeCharacter; | |
return this; | |
} | |
/** | |
* Sets the header defined by the given {@link Enum} class. | |
* | |
* <p> | |
* Example: | |
* </p> | |
* | |
* <pre> | |
* public enum HeaderEnum { | |
* Name, Email, Phone | |
* } | |
* | |
* Builder builder = builder.setHeader(HeaderEnum.class); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param headerEnum the enum defining the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return This instance. | |
*/ | |
public Builder setHeader(final Class<? extends Enum<?>> headerEnum) { | |
String[] header = null; | |
if (headerEnum != null) { | |
final Enum<?>[] enumValues = headerEnum.getEnumConstants(); | |
header = new String[enumValues.length]; | |
for (int i = 0; i < enumValues.length; i++) { | |
header[i] = enumValues[i].name(); | |
} | |
} | |
return setHeader(header); | |
} | |
/** | |
* Sets the header from the result set metadata. The header can either be parsed automatically from the input file with: | |
* | |
* <pre> | |
* builder.setHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* builder.setHeader(resultSet); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param resultSet the resultSet for the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return This instance. | |
* @throws SQLException SQLException if a database access error occurs or this method is called on a closed result set. | |
*/ | |
public Builder setHeader(final ResultSet resultSet) throws SQLException { | |
return setHeader(resultSet != null ? resultSet.getMetaData() : null); | |
} | |
/** | |
* Sets the header from the result set metadata. The header can either be parsed automatically from the input file with: | |
* | |
* <pre> | |
* builder.setHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* builder.setHeader(resultSetMetaData); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param resultSetMetaData the metaData for the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return This instance. | |
* @throws SQLException SQLException if a database access error occurs or this method is called on a closed result set. | |
*/ | |
public Builder setHeader(final ResultSetMetaData resultSetMetaData) throws SQLException { | |
String[] labels = null; | |
if (resultSetMetaData != null) { | |
final int columnCount = resultSetMetaData.getColumnCount(); | |
labels = new String[columnCount]; | |
for (int i = 0; i < columnCount; i++) { | |
labels[i] = resultSetMetaData.getColumnLabel(i + 1); | |
} | |
} | |
return setHeader(labels); | |
} | |
/** | |
* Sets the header to the given values. The header can either be parsed automatically from the input file with: | |
* | |
* <pre> | |
* builder.setHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* builder.setHeader("name", "email", "phone"); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param header the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return This instance. | |
*/ | |
public Builder setHeader(final String... header) { | |
this.headers = CSVFormat.clone(header); | |
return this; | |
} | |
/** | |
* Sets the header comments set to the given values. The comments will be printed first, before the headers. This setting is ignored by the parser. | |
* | |
* <pre> | |
* builder.setHeaderComments("Generated by Apache Commons CSV.", Instant.now()); | |
* </pre> | |
* | |
* @param headerComments the headerComments which will be printed by the Printer before the actual CSV data. | |
* @return This instance. | |
*/ | |
public Builder setHeaderComments(final Object... headerComments) { | |
this.headerComments = CSVFormat.clone(toStringArray(headerComments)); | |
return this; | |
} | |
/** | |
* Sets the header comments set to the given values. The comments will be printed first, before the headers. This setting is ignored by the parser. | |
* | |
* <pre> | |
* Builder.setHeaderComments("Generated by Apache Commons CSV.", Instant.now()); | |
* </pre> | |
* | |
* @param headerComments the headerComments which will be printed by the Printer before the actual CSV data. | |
* @return This instance. | |
*/ | |
public Builder setHeaderComments(final String... headerComments) { | |
this.headerComments = CSVFormat.clone(headerComments); | |
return this; | |
} | |
/** | |
* Sets the empty line skipping behavior, {@code true} to ignore the empty lines between the records, {@code false} to translate empty lines to empty | |
* records. | |
* | |
* @param ignoreEmptyLines the empty line skipping behavior, {@code true} to ignore the empty lines between the records, {@code false} to translate | |
* empty lines to empty records. | |
* @return This instance. | |
*/ | |
public Builder setIgnoreEmptyLines(final boolean ignoreEmptyLines) { | |
this.ignoreEmptyLines = ignoreEmptyLines; | |
return this; | |
} | |
/** | |
* Sets the case mapping behavior, {@code true} to access name/values, {@code false} to leave the mapping as is. | |
* | |
* @param ignoreHeaderCase the case mapping behavior, {@code true} to access name/values, {@code false} to leave the mapping as is. | |
* @return This instance. | |
*/ | |
public Builder setIgnoreHeaderCase(final boolean ignoreHeaderCase) { | |
this.ignoreHeaderCase = ignoreHeaderCase; | |
return this; | |
} | |
/** | |
* Sets the parser trimming behavior, {@code true} to remove the surrounding spaces, {@code false} to leave the spaces as is. | |
* | |
* @param ignoreSurroundingSpaces the parser trimming behavior, {@code true} to remove the surrounding spaces, {@code false} to leave the spaces as is. | |
* @return This instance. | |
*/ | |
public Builder setIgnoreSurroundingSpaces(final boolean ignoreSurroundingSpaces) { | |
this.ignoreSurroundingSpaces = ignoreSurroundingSpaces; | |
return this; | |
} | |
/** | |
* Sets the String to convert to and from {@code null}. No substitution occurs if {@code null}. | |
* | |
* <ul> | |
* <li><strong>Reading:</strong> Converts strings equal to the given {@code nullString} to {@code null} when reading records.</li> | |
* <li><strong>Writing:</strong> Writes {@code null} as the given {@code nullString} when writing records.</li> | |
* </ul> | |
* | |
* @param nullString the String to convert to and from {@code null}. No substitution occurs if {@code null}. | |
* @return This instance. | |
*/ | |
public Builder setNullString(final String nullString) { | |
this.nullString = nullString; | |
this.quotedNullString = quoteCharacter + nullString + quoteCharacter; | |
return this; | |
} | |
/** | |
* Sets the quote character. | |
* | |
* @param quoteCharacter the quote character. | |
* @return This instance. | |
*/ | |
public Builder setQuote(final char quoteCharacter) { | |
setQuote(Character.valueOf(quoteCharacter)); | |
return this; | |
} | |
/** | |
* Sets the quote character, use {@code null} to disable. | |
* | |
* @param quoteCharacter the quote character, use {@code null} to disable. | |
* @return This instance. | |
*/ | |
public Builder setQuote(final Character quoteCharacter) { | |
if (isLineBreak(quoteCharacter)) { | |
throw new IllegalArgumentException("The quoteChar cannot be a line break"); | |
} | |
this.quoteCharacter = quoteCharacter; | |
return this; | |
} | |
/** | |
* Sets the quote policy to use for output. | |
* | |
* @param quoteMode the quote policy to use for output. | |
* @return This instance. | |
*/ | |
public Builder setQuoteMode(final QuoteMode quoteMode) { | |
this.quoteMode = quoteMode; | |
return this; | |
} | |
/** | |
* Sets the record separator to use for output. | |
* | |
* <p> | |
* <strong>Note:</strong> This setting is only used during printing and does not affect parsing. Parsing currently only works for inputs with '\n', '\r' | |
* and "\r\n" | |
* </p> | |
* | |
* @param recordSeparator the record separator to use for output. | |
* @return This instance. | |
*/ | |
public Builder setRecordSeparator(final char recordSeparator) { | |
this.recordSeparator = String.valueOf(recordSeparator); | |
return this; | |
} | |
/** | |
* Sets the record separator to use for output. | |
* | |
* <p> | |
* <strong>Note:</strong> This setting is only used during printing and does not affect parsing. Parsing currently only works for inputs with '\n', '\r' | |
* and "\r\n" | |
* </p> | |
* | |
* @param recordSeparator the record separator to use for output. | |
* @return This instance. | |
*/ | |
public Builder setRecordSeparator(final String recordSeparator) { | |
this.recordSeparator = recordSeparator; | |
return this; | |
} | |
/** | |
* Sets whether to skip the header record. | |
* | |
* @param skipHeaderRecord whether to skip the header record. | |
* @return This instance. | |
*/ | |
public Builder setSkipHeaderRecord(final boolean skipHeaderRecord) { | |
this.skipHeaderRecord = skipHeaderRecord; | |
return this; | |
} | |
/** | |
* Sets whether to add a trailing delimiter. | |
* | |
* @param trailingDelimiter whether to add a trailing delimiter. | |
* @return This instance. | |
*/ | |
public Builder setTrailingDelimiter(final boolean trailingDelimiter) { | |
this.trailingDelimiter = trailingDelimiter; | |
return this; | |
} | |
/** | |
* Sets whether to trim leading and trailing blanks. | |
* | |
* @param trim whether to trim leading and trailing blanks. | |
* @return This instance. | |
*/ | |
public Builder setTrim(final boolean trim) { | |
this.trim = trim; | |
return this; | |
} | |
} | |
/** | |
* Predefines formats. | |
* | |
* @since 1.2 | |
*/ | |
public enum Predefined { | |
/** | |
* @see CSVFormat#DEFAULT | |
*/ | |
Default(CSVFormat.DEFAULT), | |
/** | |
* @see CSVFormat#EXCEL | |
*/ | |
Excel(CSVFormat.EXCEL), | |
/** | |
* @see CSVFormat#INFORMIX_UNLOAD | |
* @since 1.3 | |
*/ | |
InformixUnload(CSVFormat.INFORMIX_UNLOAD), | |
/** | |
* @see CSVFormat#INFORMIX_UNLOAD_CSV | |
* @since 1.3 | |
*/ | |
InformixUnloadCsv(CSVFormat.INFORMIX_UNLOAD_CSV), | |
/** | |
* @see CSVFormat#MONGODB_CSV | |
* @since 1.7 | |
*/ | |
MongoDBCsv(CSVFormat.MONGODB_CSV), | |
/** | |
* @see CSVFormat#MONGODB_TSV | |
* @since 1.7 | |
*/ | |
MongoDBTsv(CSVFormat.MONGODB_TSV), | |
/** | |
* @see CSVFormat#MYSQL | |
*/ | |
MySQL(CSVFormat.MYSQL), | |
/** | |
* @see CSVFormat#ORACLE | |
*/ | |
Oracle(CSVFormat.ORACLE), | |
/** | |
* @see CSVFormat#POSTGRESQL_CSV | |
* @since 1.5 | |
*/ | |
PostgreSQLCsv(CSVFormat.POSTGRESQL_CSV), | |
/** | |
* @see CSVFormat#POSTGRESQL_CSV | |
*/ | |
PostgreSQLText(CSVFormat.POSTGRESQL_TEXT), | |
/** | |
* @see CSVFormat#RFC4180 | |
*/ | |
RFC4180(CSVFormat.RFC4180), | |
/** | |
* @see CSVFormat#TDF | |
*/ | |
TDF(CSVFormat.TDF); | |
private final CSVFormat format; | |
Predefined(final CSVFormat format) { | |
this.format = format; | |
} | |
/** | |
* Gets the format. | |
* | |
* @return the format. | |
*/ | |
public CSVFormat getFormat() { | |
return format; | |
} | |
} | |
/** | |
* Standard Comma Separated Value format, as for {@link #RFC4180} but allowing | |
* empty lines. | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator("\r\n")}</li> | |
* <li>{@code setIgnoreEmptyLines(true)}</li> | |
* <li>{@code setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_ALL)}</li> | |
* </ul> | |
* | |
* @see Predefined#Default | |
*/ | |
public static final CSVFormat DEFAULT = new CSVFormat(COMMA, DOUBLE_QUOTE_CHAR, null, null, null, false, true, CRLF, null, null, null, false, false, false, | |
false, false, false, DuplicateHeaderMode.ALLOW_ALL); | |
/** | |
* Excel file format (using a comma as the value delimiter). Note that the actual value delimiter used by Excel is locale dependent, it might be necessary | |
* to customize this format to accommodate to your regional settings. | |
* | |
* <p> | |
* For example for parsing or generating a CSV file on a French system the following format will be used: | |
* </p> | |
* | |
* <pre> | |
* CSVFormat fmt = CSVFormat.EXCEL.withDelimiter(';'); | |
* </pre> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator("\r\n")}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* <li>{@code setAllowMissingColumnNames(true)}</li> | |
* <li>{@code setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_ALL)}</li> | |
* </ul> | |
* <p> | |
* Note: This is currently like {@link #RFC4180} plus {@link Builder#setAllowMissingColumnNames(boolean) Builder#setAllowMissingColumnNames(true)} and | |
* {@link Builder#setIgnoreEmptyLines(boolean) Builder#setIgnoreEmptyLines(false)}. | |
* </p> | |
* | |
* @see Predefined#Excel | |
*/ | |
// @formatter:off | |
public static final CSVFormat EXCEL = DEFAULT.builder() | |
.setIgnoreEmptyLines(false) | |
.setAllowMissingColumnNames(true) | |
.build(); | |
// @formatter:on | |
/** | |
* Default Informix CSV UNLOAD format used by the {@code UNLOAD TO file_name} operation. | |
* | |
* <p> | |
* This is a comma-delimited format with a LF character as the line separator. Values are not quoted and special characters are escaped with {@code '\'}. | |
* The default NULL string is {@code "\\N"}. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setEscape('\\')}</li> | |
* <li>{@code setQuote("\"")}</li> | |
* <li>{@code setRecordSeparator('\n')}</li> | |
* </ul> | |
* | |
* @see Predefined#MySQL | |
* @see <a href= "http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm"> | |
* http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm</a> | |
* @since 1.3 | |
*/ | |
// @formatter:off | |
public static final CSVFormat INFORMIX_UNLOAD = DEFAULT.builder() | |
.setDelimiter(PIPE) | |
.setEscape(BACKSLASH) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setRecordSeparator(LF) | |
.build(); | |
// @formatter:on | |
/** | |
* Default Informix CSV UNLOAD format used by the {@code UNLOAD TO file_name} operation (escaping is disabled.) | |
* | |
* <p> | |
* This is a comma-delimited format with a LF character as the line separator. Values are not quoted and special characters are escaped with {@code '\'}. | |
* The default NULL string is {@code "\\N"}. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setQuote("\"")}</li> | |
* <li>{@code setRecordSeparator('\n')}</li> | |
* </ul> | |
* | |
* @see Predefined#MySQL | |
* @see <a href= "http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm"> | |
* http://www.ibm.com/support/knowledgecenter/SSBJG3_2.5.0/com.ibm.gen_busug.doc/c_fgl_InOutSql_UNLOAD.htm</a> | |
* @since 1.3 | |
*/ | |
// @formatter:off | |
public static final CSVFormat INFORMIX_UNLOAD_CSV = DEFAULT.builder() | |
.setDelimiter(COMMA) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setRecordSeparator(LF) | |
.build(); | |
// @formatter:on | |
/** | |
* Default MongoDB CSV format used by the {@code mongoexport} operation. | |
* <p> | |
* <b>Parsing is not supported yet.</b> | |
* </p> | |
* | |
* <p> | |
* This is a comma-delimited format. Values are double quoted only if needed and special characters are escaped with {@code '"'}. A header line with field | |
* names is expected. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setEscape('"')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setQuoteMode(QuoteMode.ALL_NON_NULL)}</li> | |
* <li>{@code setSkipHeaderRecord(false)}</li> | |
* </ul> | |
* | |
* @see Predefined#MongoDBCsv | |
* @see <a href="https://docs.mongodb.com/manual/reference/program/mongoexport/">MongoDB mongoexport command documentation</a> | |
* @since 1.7 | |
*/ | |
// @formatter:off | |
public static final CSVFormat MONGODB_CSV = DEFAULT.builder() | |
.setDelimiter(COMMA) | |
.setEscape(DOUBLE_QUOTE_CHAR) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setQuoteMode(QuoteMode.MINIMAL) | |
.setSkipHeaderRecord(false) | |
.build(); | |
// @formatter:off | |
/** | |
* Default MongoDB TSV format used by the {@code mongoexport} operation. | |
* <p> | |
* <b>Parsing is not supported yet.</b> | |
* </p> | |
* | |
* <p> | |
* This is a tab-delimited format. Values are double quoted only if needed and special | |
* characters are escaped with {@code '"'}. A header line with field names is expected. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter('\t')}</li> | |
* <li>{@code setEscape('"')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setQuoteMode(QuoteMode.ALL_NON_NULL)}</li> | |
* <li>{@code setSkipHeaderRecord(false)}</li> | |
* </ul> | |
* | |
* @see Predefined#MongoDBCsv | |
* @see <a href="https://docs.mongodb.com/manual/reference/program/mongoexport/">MongoDB mongoexport command | |
* documentation</a> | |
* @since 1.7 | |
*/ | |
// @formatter:off | |
public static final CSVFormat MONGODB_TSV = DEFAULT.builder() | |
.setDelimiter(TAB) | |
.setEscape(DOUBLE_QUOTE_CHAR) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setQuoteMode(QuoteMode.MINIMAL) | |
.setSkipHeaderRecord(false) | |
.build(); | |
// @formatter:off | |
/** | |
* Default MySQL format used by the {@code SELECT INTO OUTFILE} and {@code LOAD DATA INFILE} operations. | |
* | |
* <p> | |
* This is a tab-delimited format with a LF character as the line separator. Values are not quoted and special | |
* characters are escaped with {@code '\'}. The default NULL string is {@code "\\N"}. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter('\t')}</li> | |
* <li>{@code setEscape('\\')}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* <li>{@code setQuote(null)}</li> | |
* <li>{@code setRecordSeparator('\n')}</li> | |
* <li>{@code setNullString("\\N")}</li> | |
* <li>{@code setQuoteMode(QuoteMode.ALL_NON_NULL)}</li> | |
* </ul> | |
* | |
* @see Predefined#MySQL | |
* @see <a href="http://dev.mysql.com/doc/refman/5.1/en/load-data.html"> http://dev.mysql.com/doc/refman/5.1/en/load | |
* -data.html</a> | |
*/ | |
// @formatter:off | |
public static final CSVFormat MYSQL = DEFAULT.builder() | |
.setDelimiter(TAB) | |
.setEscape(BACKSLASH) | |
.setIgnoreEmptyLines(false) | |
.setQuote(null) | |
.setRecordSeparator(LF) | |
.setNullString("\\N") | |
.setQuoteMode(QuoteMode.ALL_NON_NULL) | |
.build(); | |
// @formatter:off | |
/** | |
* Default Oracle format used by the SQL*Loader utility. | |
* | |
* <p> | |
* This is a comma-delimited format with the system line separator character as the record separator.Values are | |
* double quoted when needed and special characters are escaped with {@code '"'}. The default NULL string is | |
* {@code ""}. Values are trimmed. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',') // default is {@code FIELDS TERMINATED BY ','}}</li> | |
* <li>{@code setEscape('\\')}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* <li>{@code setQuote('"') // default is {@code OPTIONALLY ENCLOSED BY '"'}}</li> | |
* <li>{@code setNullString("\\N")}</li> | |
* <li>{@code setTrim()}</li> | |
* <li>{@code setSystemRecordSeparator()}</li> | |
* <li>{@code setQuoteMode(QuoteMode.MINIMAL)}</li> | |
* </ul> | |
* | |
* @see Predefined#Oracle | |
* @see <a href="https://s.apache.org/CGXG">Oracle CSV Format Specification</a> | |
* @since 1.6 | |
*/ | |
// @formatter:off | |
public static final CSVFormat ORACLE = DEFAULT.builder() | |
.setDelimiter(COMMA) | |
.setEscape(BACKSLASH) | |
.setIgnoreEmptyLines(false) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setNullString("\\N") | |
.setTrim(true) | |
.setRecordSeparator(System.lineSeparator()) | |
.setQuoteMode(QuoteMode.MINIMAL) | |
.build(); | |
// @formatter:off | |
/** | |
* Default PostgreSQL CSV format used by the {@code COPY} operation. | |
* | |
* <p> | |
* This is a comma-delimited format with a LF character as the line separator. Values are double quoted and special | |
* characters are escaped with {@code '"'}. The default NULL string is {@code ""}. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setEscape('"')}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator('\n')}</li> | |
* <li>{@code setNullString("")}</li> | |
* <li>{@code setQuoteMode(QuoteMode.ALL_NON_NULL)}</li> | |
* </ul> | |
* | |
* @see Predefined#MySQL | |
* @see <a href="https://www.postgresql.org/docs/current/static/sql-copy.html">PostgreSQL COPY command | |
* documentation</a> | |
* @since 1.5 | |
*/ | |
// @formatter:off | |
public static final CSVFormat POSTGRESQL_CSV = DEFAULT.builder() | |
.setDelimiter(COMMA) | |
.setEscape(DOUBLE_QUOTE_CHAR) | |
.setIgnoreEmptyLines(false) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setRecordSeparator(LF) | |
.setNullString(EMPTY) | |
.setQuoteMode(QuoteMode.ALL_NON_NULL) | |
.build(); | |
// @formatter:off | |
/** | |
* Default PostgreSQL text format used by the {@code COPY} operation. | |
* | |
* <p> | |
* This is a tab-delimited format with a LF character as the line separator. Values are double quoted and special | |
* characters are escaped with {@code '"'}. The default NULL string is {@code "\\N"}. | |
* </p> | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter('\t')}</li> | |
* <li>{@code setEscape('\\')}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator('\n')}</li> | |
* <li>{@code setNullString("\\N")}</li> | |
* <li>{@code setQuoteMode(QuoteMode.ALL_NON_NULL)}</li> | |
* </ul> | |
* | |
* @see Predefined#MySQL | |
* @see <a href="https://www.postgresql.org/docs/current/static/sql-copy.html">PostgreSQL COPY command | |
* documentation</a> | |
* @since 1.5 | |
*/ | |
// @formatter:off | |
public static final CSVFormat POSTGRESQL_TEXT = DEFAULT.builder() | |
.setDelimiter(TAB) | |
.setEscape(BACKSLASH) | |
.setIgnoreEmptyLines(false) | |
.setQuote(DOUBLE_QUOTE_CHAR) | |
.setRecordSeparator(LF) | |
.setNullString("\\N") | |
.setQuoteMode(QuoteMode.ALL_NON_NULL) | |
.build(); | |
// @formatter:off | |
/** | |
* Comma separated format as defined by <a href="http://tools.ietf.org/html/rfc4180">RFC 4180</a>. | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter(',')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator("\r\n")}</li> | |
* <li>{@code setIgnoreEmptyLines(false)}</li> | |
* </ul> | |
* | |
* @see Predefined#RFC4180 | |
*/ | |
public static final CSVFormat RFC4180 = DEFAULT.builder().setIgnoreEmptyLines(false).build(); | |
private static final long serialVersionUID = 1L; | |
/** | |
* Tab-delimited format. | |
* | |
* <p> | |
* The {@link Builder} settings are: | |
* </p> | |
* <ul> | |
* <li>{@code setDelimiter('\t')}</li> | |
* <li>{@code setQuote('"')}</li> | |
* <li>{@code setRecordSeparator("\r\n")}</li> | |
* <li>{@code setIgnoreSurroundingSpaces(true)}</li> | |
* </ul> | |
* | |
* @see Predefined#TDF | |
*/ | |
// @formatter:off | |
public static final CSVFormat TDF = DEFAULT.builder() | |
.setDelimiter(TAB) | |
.setIgnoreSurroundingSpaces(true) | |
.build(); | |
// @formatter:on | |
/** | |
* Null-safe clone of an array. | |
* | |
* @param <T> The array element type. | |
* @param values the source array | |
* @return the cloned array. | |
*/ | |
@SafeVarargs | |
static <T> T[] clone(final T... values) { | |
return values == null ? null : values.clone(); | |
} | |
/** | |
* Returns true if the given string contains the search char. | |
* | |
* @param source the string to check. | |
* @param searchCh the character to search. | |
* | |
* @return true if {@code c} contains a line break character | |
*/ | |
private static boolean contains(final String source, final char searchCh) { | |
return Objects.requireNonNull(source, "source").indexOf(searchCh) >= 0; | |
} | |
/** | |
* Returns true if the given string contains a line break character. | |
* | |
* @param source the string to check. | |
* | |
* @return true if {@code c} contains a line break character. | |
*/ | |
private static boolean containsLineBreak(final String source) { | |
return contains(source, CR) || contains(source, LF); | |
} | |
/** | |
* Returns true if the given character is a line break character. | |
* | |
* @param c the character to check. | |
* | |
* @return true if {@code c} is a line break character. | |
*/ | |
private static boolean isLineBreak(final char c) { | |
return c == LF || c == CR; | |
} | |
/** | |
* Returns true if the given character is a line break character. | |
* | |
* @param c the character to check, may be null. | |
* | |
* @return true if {@code c} is a line break character (and not null). | |
*/ | |
private static boolean isLineBreak(final Character c) { | |
return c != null && isLineBreak(c.charValue()); | |
} | |
/** | |
* Creates a new CSV format with the specified delimiter. | |
* | |
* <p> | |
* Use this method if you want to create a CSVFormat from scratch. All fields but the delimiter will be initialized with null/false. | |
* </p> | |
* | |
* @param delimiter the char used for value separation, must not be a line break character | |
* @return a new CSV format. | |
* @throws IllegalArgumentException if the delimiter is a line break character | |
* | |
* @see #DEFAULT | |
* @see #RFC4180 | |
* @see #MYSQL | |
* @see #EXCEL | |
* @see #TDF | |
*/ | |
public static CSVFormat newFormat(final char delimiter) { | |
return new CSVFormat(String.valueOf(delimiter), null, null, null, null, false, false, null, null, null, null, false, false, false, false, false, false, | |
DuplicateHeaderMode.ALLOW_ALL); | |
} | |
static String[] toStringArray(final Object[] values) { | |
if (values == null) { | |
return null; | |
} | |
final String[] strings = new String[values.length]; | |
for (int i = 0; i < values.length; i++) { | |
strings[i] = Objects.toString(values[i], null); | |
} | |
return strings; | |
} | |
static CharSequence trim(final CharSequence charSequence) { | |
if (charSequence instanceof String) { | |
return ((String) charSequence).trim(); | |
} | |
final int count = charSequence.length(); | |
int len = count; | |
int pos = 0; | |
while (pos < len && charSequence.charAt(pos) <= SP) { | |
pos++; | |
} | |
while (pos < len && charSequence.charAt(len - 1) <= SP) { | |
len--; | |
} | |
return pos > 0 || len < count ? charSequence.subSequence(pos, len) : charSequence; | |
} | |
/** | |
* Gets one of the predefined formats from {@link CSVFormat.Predefined}. | |
* | |
* @param format name | |
* @return one of the predefined formats | |
* @since 1.2 | |
*/ | |
public static CSVFormat valueOf(final String format) { | |
return CSVFormat.Predefined.valueOf(format).getFormat(); | |
} | |
private final DuplicateHeaderMode duplicateHeaderMode; | |
private final boolean allowMissingColumnNames; | |
private final boolean autoFlush; | |
private final Character commentMarker; // null if commenting is disabled | |
private final String delimiter; | |
private final Character escapeCharacter; // null if escaping is disabled | |
private final String[] header; // array of header column names | |
private final String[] headerComments; // array of header comment lines | |
private final boolean ignoreEmptyLines; | |
private final boolean ignoreHeaderCase; // should ignore header names case | |
private final boolean ignoreSurroundingSpaces; // Should leading/trailing spaces be ignored around values? | |
private final String nullString; // the string to be used for null values | |
private final Character quoteCharacter; // null if quoting is disabled | |
private final String quotedNullString; | |
private final QuoteMode quoteMode; | |
private final String recordSeparator; // for outputs | |
private final boolean skipHeaderRecord; | |
private final boolean trailingDelimiter; | |
private final boolean trim; | |
private CSVFormat(final Builder builder) { | |
this.delimiter = builder.delimiter; | |
this.quoteCharacter = builder.quoteCharacter; | |
this.quoteMode = builder.quoteMode; | |
this.commentMarker = builder.commentMarker; | |
this.escapeCharacter = builder.escapeCharacter; | |
this.ignoreSurroundingSpaces = builder.ignoreSurroundingSpaces; | |
this.allowMissingColumnNames = builder.allowMissingColumnNames; | |
this.ignoreEmptyLines = builder.ignoreEmptyLines; | |
this.recordSeparator = builder.recordSeparator; | |
this.nullString = builder.nullString; | |
this.headerComments = builder.headerComments; | |
this.header = builder.headers; | |
this.skipHeaderRecord = builder.skipHeaderRecord; | |
this.ignoreHeaderCase = builder.ignoreHeaderCase; | |
this.trailingDelimiter = builder.trailingDelimiter; | |
this.trim = builder.trim; | |
this.autoFlush = builder.autoFlush; | |
this.quotedNullString = builder.quotedNullString; | |
this.duplicateHeaderMode = builder.duplicateHeaderMode; | |
validate(); | |
} | |
/** | |
* Creates a customized CSV format. | |
* | |
* @param delimiter the char used for value separation, must not be a line break character. | |
* @param quoteChar the Character used as value encapsulation marker, may be {@code null} to disable. | |
* @param quoteMode the quote mode. | |
* @param commentStart the Character used for comment identification, may be {@code null} to disable. | |
* @param escape the Character used to escape special characters in values, may be {@code null} to disable. | |
* @param ignoreSurroundingSpaces {@code true} when whitespaces enclosing values should be ignored. | |
* @param ignoreEmptyLines {@code true} when the parser should skip empty lines. | |
* @param recordSeparator the line separator to use for output. | |
* @param nullString the line separator to use for output. | |
* @param headerComments the comments to be printed by the Printer before the actual CSV data. | |
* @param header the header | |
* @param skipHeaderRecord TODO Doc me. | |
* @param allowMissingColumnNames TODO Doc me. | |
* @param ignoreHeaderCase TODO Doc me. | |
* @param trim TODO Doc me. | |
* @param trailingDelimiter TODO Doc me. | |
* @param autoFlush TODO Doc me. | |
* @param duplicateHeaderMode the behavior when handling duplicate headers | |
* @throws IllegalArgumentException if the delimiter is a line break character. | |
*/ | |
private CSVFormat(final String delimiter, final Character quoteChar, final QuoteMode quoteMode, final Character commentStart, final Character escape, | |
final boolean ignoreSurroundingSpaces, final boolean ignoreEmptyLines, final String recordSeparator, final String nullString, | |
final Object[] headerComments, final String[] header, final boolean skipHeaderRecord, final boolean allowMissingColumnNames, | |
final boolean ignoreHeaderCase, final boolean trim, final boolean trailingDelimiter, final boolean autoFlush, | |
final DuplicateHeaderMode duplicateHeaderMode) { | |
this.delimiter = delimiter; | |
this.quoteCharacter = quoteChar; | |
this.quoteMode = quoteMode; | |
this.commentMarker = commentStart; | |
this.escapeCharacter = escape; | |
this.ignoreSurroundingSpaces = ignoreSurroundingSpaces; | |
this.allowMissingColumnNames = allowMissingColumnNames; | |
this.ignoreEmptyLines = ignoreEmptyLines; | |
this.recordSeparator = recordSeparator; | |
this.nullString = nullString; | |
this.headerComments = toStringArray(headerComments); | |
this.header = clone(header); | |
this.skipHeaderRecord = skipHeaderRecord; | |
this.ignoreHeaderCase = ignoreHeaderCase; | |
this.trailingDelimiter = trailingDelimiter; | |
this.trim = trim; | |
this.autoFlush = autoFlush; | |
this.quotedNullString = quoteCharacter + nullString + quoteCharacter; | |
this.duplicateHeaderMode = duplicateHeaderMode; | |
validate(); | |
} | |
private void append(final char c, final Appendable appendable) throws IOException { | |
//try { | |
appendable.append(c); | |
//} catch (final IOException e) { | |
// throw new UncheckedIOException(e); | |
//} | |
} | |
private void append(final CharSequence csq, final Appendable appendable) throws IOException { | |
//try { | |
appendable.append(csq); | |
//} catch (final IOException e) { | |
// throw new UncheckedIOException(e); | |
//} | |
} | |
/** | |
* Creates a new Builder for this instance. | |
* | |
* @return a new Builder. | |
*/ | |
public Builder builder() { | |
return Builder.create(this); | |
} | |
/** | |
* Creates a copy of this instance. | |
* | |
* @return a copy of this instance. | |
*/ | |
CSVFormat copy() { | |
return builder().build(); | |
} | |
@Override | |
public boolean equals(final Object obj) { | |
if (this == obj) { | |
return true; | |
} | |
if (obj == null || getClass() != obj.getClass()) { | |
return false; | |
} | |
final CSVFormat other = (CSVFormat) obj; | |
return duplicateHeaderMode == other.duplicateHeaderMode && allowMissingColumnNames == other.allowMissingColumnNames && | |
autoFlush == other.autoFlush && Objects.equals(commentMarker, other.commentMarker) && Objects.equals(delimiter, other.delimiter) && | |
Objects.equals(escapeCharacter, other.escapeCharacter) && Arrays.equals(header, other.header) && | |
Arrays.equals(headerComments, other.headerComments) && ignoreEmptyLines == other.ignoreEmptyLines && | |
ignoreHeaderCase == other.ignoreHeaderCase && ignoreSurroundingSpaces == other.ignoreSurroundingSpaces && | |
Objects.equals(nullString, other.nullString) && Objects.equals(quoteCharacter, other.quoteCharacter) && quoteMode == other.quoteMode && | |
Objects.equals(quotedNullString, other.quotedNullString) && Objects.equals(recordSeparator, other.recordSeparator) && | |
skipHeaderRecord == other.skipHeaderRecord && trailingDelimiter == other.trailingDelimiter && trim == other.trim; | |
} | |
/** | |
* Formats the specified values. | |
* | |
* @param values the values to format | |
* @return the formatted values | |
*/ | |
public String format(final Object... values) { | |
final StringWriter out = new StringWriter(); | |
try (CSVPrinter csvPrinter = new CSVPrinter(out, this)) { | |
csvPrinter.printRecord(values); | |
final String res = out.toString(); | |
final int len = recordSeparator != null ? res.length() - recordSeparator.length() : res.length(); | |
return res.substring(0, len); | |
} catch (final IOException e) { | |
// should not happen because a StringWriter does not do IO. | |
throw new IllegalStateException(e); | |
} | |
} | |
/** | |
* Returns true if and only if duplicate names are allowed in the headers. | |
* | |
* @return whether duplicate header names are allowed | |
* @since 1.7 | |
* @deprecated Use {@link #getDuplicateHeaderMode()}. | |
*/ | |
@Deprecated | |
public boolean getAllowDuplicateHeaderNames() { | |
return duplicateHeaderMode == DuplicateHeaderMode.ALLOW_ALL; | |
} | |
/** | |
* Specifies whether missing column names are allowed when parsing the header line. | |
* | |
* @return {@code true} if missing column names are allowed when parsing the header line, {@code false} to throw an {@link IllegalArgumentException}. | |
*/ | |
public boolean getAllowMissingColumnNames() { | |
return allowMissingColumnNames; | |
} | |
/** | |
* Returns whether to flush on close. | |
* | |
* @return whether to flush on close. | |
* @since 1.6 | |
*/ | |
public boolean getAutoFlush() { | |
return autoFlush; | |
} | |
/** | |
* Returns the character marking the start of a line comment. | |
* | |
* @return the comment start marker, may be {@code null} | |
*/ | |
public Character getCommentMarker() { | |
return commentMarker; | |
} | |
/** | |
* Returns the first character delimiting the values (typically ';', ',' or '\t'). | |
* | |
* @return the first delimiter character. | |
* @deprecated Use {@link #getDelimiterString()}. | |
*/ | |
@Deprecated | |
public char getDelimiter() { | |
return delimiter.charAt(0); | |
} | |
/** | |
* Returns the character delimiting the values (typically ";", "," or "\t"). | |
* | |
* @return the delimiter. | |
*/ | |
public String getDelimiterString() { | |
return delimiter; | |
} | |
/** | |
* Gets how duplicate headers are handled. | |
* | |
* @return if duplicate header values are allowed, allowed conditionally, or disallowed. | |
* @since 1.9.0 | |
*/ | |
public DuplicateHeaderMode getDuplicateHeaderMode() { | |
return duplicateHeaderMode; | |
} | |
/** | |
* Returns the escape character. | |
* | |
* @return the escape character, may be {@code null} | |
*/ | |
public Character getEscapeCharacter() { | |
return escapeCharacter; | |
} | |
/** | |
* Returns a copy of the header array. | |
* | |
* @return a copy of the header array; {@code null} if disabled, the empty array if to be read from the file | |
*/ | |
public String[] getHeader() { | |
return header != null ? header.clone() : null; | |
} | |
/** | |
* Returns a copy of the header comment array. | |
* | |
* @return a copy of the header comment array; {@code null} if disabled. | |
*/ | |
public String[] getHeaderComments() { | |
return headerComments != null ? headerComments.clone() : null; | |
} | |
/** | |
* Specifies whether empty lines between records are ignored when parsing input. | |
* | |
* @return {@code true} if empty lines between records are ignored, {@code false} if they are turned into empty records. | |
*/ | |
public boolean getIgnoreEmptyLines() { | |
return ignoreEmptyLines; | |
} | |
/** | |
* Specifies whether header names will be accessed ignoring case. | |
* | |
* @return {@code true} if header names cases are ignored, {@code false} if they are case sensitive. | |
* @since 1.3 | |
*/ | |
public boolean getIgnoreHeaderCase() { | |
return ignoreHeaderCase; | |
} | |
/** | |
* Specifies whether spaces around values are ignored when parsing input. | |
* | |
* @return {@code true} if spaces around values are ignored, {@code false} if they are treated as part of the value. | |
*/ | |
public boolean getIgnoreSurroundingSpaces() { | |
return ignoreSurroundingSpaces; | |
} | |
/** | |
* Gets the String to convert to and from {@code null}. | |
* <ul> | |
* <li><strong>Reading:</strong> Converts strings equal to the given {@code nullString} to {@code null} when reading records.</li> | |
* <li><strong>Writing:</strong> Writes {@code null} as the given {@code nullString} when writing records.</li> | |
* </ul> | |
* | |
* @return the String to convert to and from {@code null}. No substitution occurs if {@code null} | |
*/ | |
public String getNullString() { | |
return nullString; | |
} | |
/** | |
* Returns the character used to encapsulate values containing special characters. | |
* | |
* @return the quoteChar character, may be {@code null} | |
*/ | |
public Character getQuoteCharacter() { | |
return quoteCharacter; | |
} | |
/** | |
* Returns the quote policy output fields. | |
* | |
* @return the quote policy | |
*/ | |
public QuoteMode getQuoteMode() { | |
return quoteMode; | |
} | |
/** | |
* Returns the record separator delimiting output records. | |
* | |
* @return the record separator | |
*/ | |
public String getRecordSeparator() { | |
return recordSeparator; | |
} | |
/** | |
* Returns whether to skip the header record. | |
* | |
* @return whether to skip the header record. | |
*/ | |
public boolean getSkipHeaderRecord() { | |
return skipHeaderRecord; | |
} | |
/** | |
* Returns whether to add a trailing delimiter. | |
* | |
* @return whether to add a trailing delimiter. | |
* @since 1.3 | |
*/ | |
public boolean getTrailingDelimiter() { | |
return trailingDelimiter; | |
} | |
/** | |
* Returns whether to trim leading and trailing blanks. This is used by {@link #print(Object, Appendable, boolean)} Also by | |
* {CSVParser#addRecordValue(boolean)} | |
* | |
* @return whether to trim leading and trailing blanks. | |
*/ | |
public boolean getTrim() { | |
return trim; | |
} | |
@Override | |
public int hashCode() { | |
final int prime = 31; | |
int result = 1; | |
result = prime * result + Arrays.hashCode(header); | |
result = prime * result + Arrays.hashCode(headerComments); | |
return prime * result + Objects.hash(duplicateHeaderMode, allowMissingColumnNames, autoFlush, commentMarker, delimiter, escapeCharacter, | |
ignoreEmptyLines, ignoreHeaderCase, ignoreSurroundingSpaces, nullString, quoteCharacter, quoteMode, quotedNullString, recordSeparator, | |
skipHeaderRecord, trailingDelimiter, trim); | |
} | |
/** | |
* Specifies whether comments are supported by this format. | |
* | |
* Note that the comment introducer character is only recognized at the start of a line. | |
* | |
* @return {@code true} is comments are supported, {@code false} otherwise | |
*/ | |
public boolean isCommentMarkerSet() { | |
return commentMarker != null; | |
} | |
/** | |
* Matches whether the next characters constitute a delimiter | |
* | |
* @param ch | |
* the current char | |
* @param charSeq | |
* the match char sequence | |
* @param startIndex | |
* where start to match | |
* @param delimiter | |
* the delimiter | |
* @param delimiterLength | |
* the delimiter length | |
* @return true if the match is successful | |
*/ | |
private boolean isDelimiter(final char ch, final CharSequence charSeq, final int startIndex, final char[] delimiter, final int delimiterLength) { | |
if (ch != delimiter[0]) { | |
return false; | |
} | |
final int len = charSeq.length(); | |
if (startIndex + delimiterLength > len) { | |
return false; | |
} | |
for (int i = 1; i < delimiterLength; i++) { | |
if (charSeq.charAt(startIndex + i) != delimiter[i]) { | |
return false; | |
} | |
} | |
return true; | |
} | |
/** | |
* Returns whether escape are being processed. | |
* | |
* @return {@code true} if escapes are processed | |
*/ | |
public boolean isEscapeCharacterSet() { | |
return escapeCharacter != null; | |
} | |
/** | |
* Returns whether a nullString has been defined. | |
* | |
* @return {@code true} if a nullString is defined | |
*/ | |
public boolean isNullStringSet() { | |
return nullString != null; | |
} | |
/** | |
* Returns whether a quoteChar has been defined. | |
* | |
* @return {@code true} if a quoteChar is defined | |
*/ | |
public boolean isQuoteCharacterSet() { | |
return quoteCharacter != null; | |
} | |
/** | |
* Parses the specified content. | |
* | |
* <p> | |
* See also the various static parse methods on {@link CSVParser}. | |
* </p> | |
* | |
* @param reader the input stream | |
* @return a parser over a stream of {@link CSVRecord}s. | |
* @throws IOException If an I/O error occurs | |
*/ | |
public CSVParser parse(final Reader reader) throws IOException { | |
return new CSVParser(reader, this); | |
} | |
/** | |
* Prints to the specified output. | |
* | |
* <p> | |
* See also {@link CSVPrinter}. | |
* </p> | |
* | |
* @param out the output. | |
* @return a printer to an output. | |
* @throws IOException thrown if the optional header cannot be printed. | |
*/ | |
public CSVPrinter print(final Appendable out) throws IOException { | |
return new CSVPrinter(out, this); | |
} | |
/** | |
* Prints to the specified output. | |
* | |
* <p> | |
* See also {@link CSVPrinter}. | |
* </p> | |
* | |
* @param out the output. | |
* @param charset A charset. | |
* @return a printer to an output. | |
* @throws IOException thrown if the optional header cannot be printed. | |
* @since 1.5 | |
*/ | |
@SuppressWarnings("resource") | |
public CSVPrinter print(final File out, final Charset charset) throws IOException { | |
// The writer will be closed when close() is called. | |
return new CSVPrinter(new OutputStreamWriter(new FileOutputStream(out), charset), this); | |
} | |
/** | |
* Prints the {@code value} as the next value on the line to {@code out}. The value will be escaped or encapsulated as needed. Useful when one wants to | |
* avoid creating CSVPrinters. Trims the value if {@link #getTrim()} is true. | |
* | |
* @param value value to output. | |
* @param out where to print the value. | |
* @param newRecord if this a new record. | |
* @throws IOException If an I/O error occurs. | |
* @since 1.4 | |
*/ | |
public synchronized void print(final Object value, final Appendable out, final boolean newRecord) throws IOException { | |
// null values are considered empty | |
// Only call CharSequence.toString() if you have to, helps GC-free use cases. | |
CharSequence charSequence; | |
if (value == null) { | |
// https://issues.apache.org/jira/browse/CSV-203 | |
if (null == nullString) { | |
charSequence = EMPTY; | |
} else if (QuoteMode.ALL == quoteMode) { | |
charSequence = quotedNullString; | |
} else { | |
charSequence = nullString; | |
} | |
} else if (value instanceof CharSequence) { | |
charSequence = (CharSequence) value; | |
} else if (value instanceof Reader) { | |
print((Reader) value, out, newRecord); | |
return; | |
} else { | |
charSequence = value.toString(); | |
} | |
charSequence = getTrim() ? trim(charSequence) : charSequence; | |
print(value, charSequence, out, newRecord); | |
} | |
private synchronized void print(final Object object, final CharSequence value, final Appendable out, final boolean newRecord) throws IOException { | |
final int offset = 0; | |
final int len = value.length(); | |
if (!newRecord) { | |
out.append(getDelimiterString()); | |
} | |
if (object == null) { | |
out.append(value); | |
} else if (isQuoteCharacterSet()) { | |
// the original object is needed so can check for Number | |
printWithQuotes(object, value, out, newRecord); | |
} else if (isEscapeCharacterSet()) { | |
printWithEscapes(value, out); | |
} else { | |
out.append(value, offset, len); | |
} | |
} | |
/** | |
* Prints to the specified output, returns a {@code CSVPrinter} which the caller MUST close. | |
* | |
* <p> | |
* See also {@link CSVPrinter}. | |
* </p> | |
* | |
* @param out the output. | |
* @param charset A charset. | |
* @return a printer to an output. | |
* @throws IOException thrown if the optional header cannot be printed. | |
* @since 1.5 | |
*/ | |
@SuppressWarnings("resource") | |
public CSVPrinter print(final Path out, final Charset charset) throws IOException { | |
return print(Files.newBufferedWriter(out, charset)); | |
} | |
private void print(final Reader reader, final Appendable out, final boolean newRecord) throws IOException { | |
// Reader is never null | |
if (!newRecord) { | |
append(getDelimiterString(), out); | |
} | |
if (isQuoteCharacterSet()) { | |
printWithQuotes(reader, out); | |
} else if (isEscapeCharacterSet()) { | |
printWithEscapes(reader, out); | |
} else if (out instanceof Writer) { | |
IOUtils.copyLarge(reader, (Writer) out); | |
} else { | |
IOUtils.copy(reader, out); | |
} | |
} | |
/** | |
* Prints to the {@link System#out}. | |
* | |
* <p> | |
* See also {@link CSVPrinter}. | |
* </p> | |
* | |
* @return a printer to {@link System#out}. | |
* @throws IOException thrown if the optional header cannot be printed. | |
* @since 1.5 | |
*/ | |
public CSVPrinter printer() throws IOException { | |
return new CSVPrinter(System.out, this); | |
} | |
/** | |
* Outputs the trailing delimiter (if set) followed by the record separator (if set). | |
* | |
* @param appendable where to write | |
* @throws IOException If an I/O error occurs. | |
* @since 1.4 | |
*/ | |
public synchronized void println(final Appendable appendable) throws IOException { | |
if (getTrailingDelimiter()) { | |
append(getDelimiterString(), appendable); | |
} | |
if (recordSeparator != null) { | |
append(recordSeparator, appendable); | |
} | |
} | |
/** | |
* Prints the given {@code values} to {@code out} as a single record of delimiter separated values followed by the record separator. | |
* | |
* <p> | |
* The values will be quoted if needed. Quotes and new-line characters will be escaped. This method adds the record separator to the output after printing | |
* the record, so there is no need to call {@link #println(Appendable)}. | |
* </p> | |
* | |
* @param appendable where to write. | |
* @param values values to output. | |
* @throws IOException If an I/O error occurs. | |
* @since 1.4 | |
*/ | |
public synchronized void printRecord(final Appendable appendable, final Object... values) throws IOException { | |
for (int i = 0; i < values.length; i++) { | |
print(values[i], appendable, i == 0); | |
} | |
println(appendable); | |
} | |
/* | |
* Note: Must only be called if escaping is enabled, otherwise will generate NPE. | |
*/ | |
private void printWithEscapes(final CharSequence charSeq, final Appendable appendable) throws IOException { | |
int start = 0; | |
int pos = 0; | |
final int end = charSeq.length(); | |
final char[] delim = getDelimiterString().toCharArray(); | |
final int delimLength = delim.length; | |
final char escape = getEscapeCharacter().charValue(); | |
while (pos < end) { | |
char c = charSeq.charAt(pos); | |
final boolean isDelimiterStart = isDelimiter(c, charSeq, pos, delim, delimLength); | |
if (c == CR || c == LF || c == escape || isDelimiterStart) { | |
// write out segment up until this char | |
if (pos > start) { | |
appendable.append(charSeq, start, pos); | |
} | |
if (c == LF) { | |
c = 'n'; | |
} else if (c == CR) { | |
c = 'r'; | |
} | |
appendable.append(escape); | |
appendable.append(c); | |
if (isDelimiterStart) { | |
for (int i = 1; i < delimLength; i++) { | |
pos++; | |
c = charSeq.charAt(pos); | |
appendable.append(escape); | |
appendable.append(c); | |
} | |
} | |
start = pos + 1; // start on the current char after this one | |
} | |
pos++; | |
} | |
// write last segment | |
if (pos > start) { | |
appendable.append(charSeq, start, pos); | |
} | |
} | |
private void printWithEscapes(final Reader reader, final Appendable appendable) throws IOException { | |
int start = 0; | |
int pos = 0; | |
@SuppressWarnings("resource") // Temp reader on input reader. | |
final ExtendedBufferedReader bufferedReader = new ExtendedBufferedReader(reader); | |
final char[] delim = getDelimiterString().toCharArray(); | |
final int delimLength = delim.length; | |
final char escape = getEscapeCharacter().charValue(); | |
final StringBuilder builder = new StringBuilder(IOUtils.DEFAULT_BUFFER_SIZE); | |
int c; | |
while (-1 != (c = bufferedReader.read())) { | |
builder.append((char) c); | |
final boolean isDelimiterStart = isDelimiter((char) c, builder.toString() + new String(bufferedReader.lookAhead(delimLength - 1)), pos, delim, | |
delimLength); | |
if (c == CR || c == LF || c == escape || isDelimiterStart) { | |
// write out segment up until this char | |
if (pos > start) { | |
append(builder.substring(start, pos), appendable); | |
builder.setLength(0); | |
pos = -1; | |
} | |
if (c == LF) { | |
c = 'n'; | |
} else if (c == CR) { | |
c = 'r'; | |
} | |
append(escape, appendable); | |
append((char) c, appendable); | |
if (isDelimiterStart) { | |
for (int i = 1; i < delimLength; i++) { | |
c = bufferedReader.read(); | |
append(escape, appendable); | |
append((char) c, appendable); | |
} | |
} | |
start = pos + 1; // start on the current char after this one | |
} | |
pos++; | |
} | |
// write last segment | |
if (pos > start) { | |
append(builder.substring(start, pos), appendable); | |
} | |
} | |
/* | |
* Note: must only be called if quoting is enabled, otherwise will generate NPE | |
*/ | |
// the original object is needed so can check for Number | |
private void printWithQuotes(final Object object, final CharSequence charSeq, final Appendable out, final boolean newRecord) throws IOException { | |
boolean quote = false; | |
int start = 0; | |
int pos = 0; | |
final int len = charSeq.length(); | |
final char[] delim = getDelimiterString().toCharArray(); | |
final int delimLength = delim.length; | |
final char quoteChar = getQuoteCharacter().charValue(); | |
// If escape char not specified, default to the quote char | |
// This avoids having to keep checking whether there is an escape character | |
// at the cost of checking against quote twice | |
final char escapeChar = isEscapeCharacterSet() ? getEscapeCharacter().charValue() : quoteChar; | |
QuoteMode quoteModePolicy = getQuoteMode(); | |
if (quoteModePolicy == null) { | |
quoteModePolicy = QuoteMode.MINIMAL; | |
} | |
switch (quoteModePolicy) { | |
case ALL: | |
case ALL_NON_NULL: | |
quote = true; | |
break; | |
case NON_NUMERIC: | |
quote = !(object instanceof Number); | |
break; | |
case NONE: | |
// Use the existing escaping code | |
printWithEscapes(charSeq, out); | |
return; | |
case MINIMAL: | |
if (len <= 0) { | |
// always quote an empty token that is the first | |
// on the line, as it may be the only thing on the | |
// line. If it were not quoted in that case, | |
// an empty line has no tokens. | |
if (newRecord) { | |
quote = true; | |
} | |
} else { | |
char c = charSeq.charAt(pos); | |
if (c <= COMMENT) { | |
// Some other chars at the start of a value caused the parser to fail, so for now | |
// encapsulate if we start in anything less than '#'. We are being conservative | |
// by including the default comment char too. | |
quote = true; | |
} else { | |
while (pos < len) { | |
c = charSeq.charAt(pos); | |
if (c == LF || c == CR || c == quoteChar || c == escapeChar || isDelimiter(c, charSeq, pos, delim, delimLength)) { | |
quote = true; | |
break; | |
} | |
pos++; | |
} | |
if (!quote) { | |
pos = len - 1; | |
c = charSeq.charAt(pos); | |
// Some other chars at the end caused the parser to fail, so for now | |
// encapsulate if we end in anything less than ' ' | |
if (c <= SP) { | |
quote = true; | |
} | |
} | |
} | |
} | |
if (!quote) { | |
// no encapsulation needed - write out the original value | |
out.append(charSeq, start, len); | |
return; | |
} | |
break; | |
default: | |
throw new IllegalStateException("Unexpected Quote value: " + quoteModePolicy); | |
} | |
if (!quote) { | |
// no encapsulation needed - write out the original value | |
out.append(charSeq, start, len); | |
return; | |
} | |
// we hit something that needed encapsulation | |
out.append(quoteChar); | |
// Pick up where we left off: pos should be positioned on the first character that caused | |
// the need for encapsulation. | |
while (pos < len) { | |
final char c = charSeq.charAt(pos); | |
if (c == quoteChar || c == escapeChar) { | |
// write out the chunk up until this point | |
out.append(charSeq, start, pos); | |
out.append(escapeChar); // now output the escape | |
start = pos; // and restart with the matched char | |
} | |
pos++; | |
} | |
// write the last segment | |
out.append(charSeq, start, pos); | |
out.append(quoteChar); | |
} | |
/** | |
* Always use quotes unless QuoteMode is NONE, so we not have to look ahead. | |
* | |
* @param reader What to print | |
* @param appendable Where to print it | |
* @throws IOException If an I/O error occurs | |
*/ | |
private void printWithQuotes(final Reader reader, final Appendable appendable) throws IOException { | |
if (getQuoteMode() == QuoteMode.NONE) { | |
printWithEscapes(reader, appendable); | |
return; | |
} | |
int pos = 0; | |
final char quote = getQuoteCharacter().charValue(); | |
final StringBuilder builder = new StringBuilder(IOUtils.DEFAULT_BUFFER_SIZE); | |
append(quote, appendable); | |
int c; | |
while (-1 != (c = reader.read())) { | |
builder.append((char) c); | |
if (c == quote) { | |
// write out segment up until this char | |
if (pos > 0) { | |
append(builder.substring(0, pos), appendable); | |
append(quote, appendable); | |
builder.setLength(0); | |
pos = -1; | |
} | |
append((char) c, appendable); | |
} | |
pos++; | |
} | |
// write last segment | |
if (pos > 0) { | |
append(builder.substring(0, pos), appendable); | |
} | |
append(quote, appendable); | |
} | |
@Override | |
public String toString() { | |
final StringBuilder sb = new StringBuilder(); | |
sb.append("Delimiter=<").append(delimiter).append('>'); | |
if (isEscapeCharacterSet()) { | |
sb.append(' '); | |
sb.append("Escape=<").append(escapeCharacter).append('>'); | |
} | |
if (isQuoteCharacterSet()) { | |
sb.append(' '); | |
sb.append("QuoteChar=<").append(quoteCharacter).append('>'); | |
} | |
if (quoteMode != null) { | |
sb.append(' '); | |
sb.append("QuoteMode=<").append(quoteMode).append('>'); | |
} | |
if (isCommentMarkerSet()) { | |
sb.append(' '); | |
sb.append("CommentStart=<").append(commentMarker).append('>'); | |
} | |
if (isNullStringSet()) { | |
sb.append(' '); | |
sb.append("NullString=<").append(nullString).append('>'); | |
} | |
if (recordSeparator != null) { | |
sb.append(' '); | |
sb.append("RecordSeparator=<").append(recordSeparator).append('>'); | |
} | |
if (getIgnoreEmptyLines()) { | |
sb.append(" EmptyLines:ignored"); | |
} | |
if (getIgnoreSurroundingSpaces()) { | |
sb.append(" SurroundingSpaces:ignored"); | |
} | |
if (getIgnoreHeaderCase()) { | |
sb.append(" IgnoreHeaderCase:ignored"); | |
} | |
sb.append(" SkipHeaderRecord:").append(skipHeaderRecord); | |
if (headerComments != null) { | |
sb.append(' '); | |
sb.append("HeaderComments:").append(Arrays.toString(headerComments)); | |
} | |
if (header != null) { | |
sb.append(' '); | |
sb.append("Header:").append(Arrays.toString(header)); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Verifies the validity and consistency of the attributes, and throws an IllegalArgumentException if necessary. | |
* | |
* @throws IllegalArgumentException Throw when any attribute is invalid or inconsistent with other attributes. | |
*/ | |
private void validate() throws IllegalArgumentException { | |
if (containsLineBreak(delimiter)) { | |
throw new IllegalArgumentException("The delimiter cannot be a line break"); | |
} | |
if (quoteCharacter != null && contains(delimiter, quoteCharacter.charValue())) { | |
throw new IllegalArgumentException("The quoteChar character and the delimiter cannot be the same ('" + quoteCharacter + "')"); | |
} | |
if (escapeCharacter != null && contains(delimiter, escapeCharacter.charValue())) { | |
throw new IllegalArgumentException("The escape character and the delimiter cannot be the same ('" + escapeCharacter + "')"); | |
} | |
if (commentMarker != null && contains(delimiter, commentMarker.charValue())) { | |
throw new IllegalArgumentException("The comment start character and the delimiter cannot be the same ('" + commentMarker + "')"); | |
} | |
if (quoteCharacter != null && quoteCharacter.equals(commentMarker)) { | |
throw new IllegalArgumentException("The comment start character and the quoteChar cannot be the same ('" + commentMarker + "')"); | |
} | |
if (escapeCharacter != null && escapeCharacter.equals(commentMarker)) { | |
throw new IllegalArgumentException("The comment start and the escape character cannot be the same ('" + commentMarker + "')"); | |
} | |
if (escapeCharacter == null && quoteMode == QuoteMode.NONE) { | |
throw new IllegalArgumentException("No quotes mode set but no escape character is set"); | |
} | |
// validate header | |
if (header != null && duplicateHeaderMode != DuplicateHeaderMode.ALLOW_ALL) { | |
final Set<String> dupCheck = new HashSet<>(); | |
for (final String hdr : header) { | |
if (!dupCheck.add(hdr)) { | |
throw new IllegalArgumentException("The header contains a duplicate entry: '" + hdr + "' in " + Arrays.toString(header)); | |
} | |
} | |
} | |
} | |
/** | |
* Returns a new {@code CSVFormat} that allows duplicate header names. | |
* | |
* @return a new {@code CSVFormat} that allows duplicate header names | |
* @since 1.7 | |
* @deprecated Use {@link Builder#setAllowDuplicateHeaderNames(boolean) Builder#setAllowDuplicateHeaderNames(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withAllowDuplicateHeaderNames() { | |
return builder().setDuplicateHeaderMode(DuplicateHeaderMode.ALLOW_ALL).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with duplicate header names behavior set to the given value. | |
* | |
* @param allowDuplicateHeaderNames the duplicate header names behavior, true to allow, false to disallow. | |
* @return a new {@code CSVFormat} with duplicate header names behavior set to the given value. | |
* @since 1.7 | |
* @deprecated Use {@link Builder#setAllowDuplicateHeaderNames(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withAllowDuplicateHeaderNames(final boolean allowDuplicateHeaderNames) { | |
final DuplicateHeaderMode mode = allowDuplicateHeaderNames ? DuplicateHeaderMode.ALLOW_ALL : DuplicateHeaderMode.ALLOW_EMPTY; | |
return builder().setDuplicateHeaderMode(mode).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the missing column names behavior of the format set to {@code true}. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified missing column names behavior. | |
* @see Builder#setAllowMissingColumnNames(boolean) | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setAllowMissingColumnNames(boolean) Builder#setAllowMissingColumnNames(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withAllowMissingColumnNames() { | |
return builder().setAllowMissingColumnNames(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the missing column names behavior of the format set to the given value. | |
* | |
* @param allowMissingColumnNames the missing column names behavior, {@code true} to allow missing column names in the header line, {@code false} to cause | |
* an {@link IllegalArgumentException} to be thrown. | |
* @return A new CSVFormat that is equal to this but with the specified missing column names behavior. | |
* @deprecated Use {@link Builder#setAllowMissingColumnNames(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withAllowMissingColumnNames(final boolean allowMissingColumnNames) { | |
return builder().setAllowMissingColumnNames(allowMissingColumnNames).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with whether to flush on close. | |
* | |
* @param autoFlush whether to flush on close. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified autoFlush setting. | |
* @since 1.6 | |
* @deprecated Use {@link Builder#setAutoFlush(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withAutoFlush(final boolean autoFlush) { | |
return builder().setAutoFlush(autoFlush).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the comment start marker of the format set to the specified character. | |
* | |
* Note that the comment start character is only recognized at the start of a line. | |
* | |
* @param commentMarker the comment start marker | |
* @return A new CSVFormat that is equal to this one but with the specified character as the comment start marker | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setCommentMarker(char)} | |
*/ | |
@Deprecated | |
public CSVFormat withCommentMarker(final char commentMarker) { | |
return builder().setCommentMarker(commentMarker).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the comment start marker of the format set to the specified character. | |
* | |
* Note that the comment start character is only recognized at the start of a line. | |
* | |
* @param commentMarker the comment start marker, use {@code null} to disable | |
* @return A new CSVFormat that is equal to this one but with the specified character as the comment start marker | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setCommentMarker(Character)} | |
*/ | |
@Deprecated | |
public CSVFormat withCommentMarker(final Character commentMarker) { | |
return builder().setCommentMarker(commentMarker).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the delimiter of the format set to the specified character. | |
* | |
* @param delimiter the delimiter character | |
* @return A new CSVFormat that is equal to this with the specified character as delimiter | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setDelimiter(char)} | |
*/ | |
@Deprecated | |
public CSVFormat withDelimiter(final char delimiter) { | |
return builder().setDelimiter(delimiter).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the escape character of the format set to the specified character. | |
* | |
* @param escape the escape character | |
* @return A new CSVFormat that is equal to this but with the specified character as the escape character | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setEscape(char)} | |
*/ | |
@Deprecated | |
public CSVFormat withEscape(final char escape) { | |
return builder().setEscape(escape).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the escape character of the format set to the specified character. | |
* | |
* @param escape the escape character, use {@code null} to disable | |
* @return A new CSVFormat that is equal to this but with the specified character as the escape character | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setEscape(Character)} | |
*/ | |
@Deprecated | |
public CSVFormat withEscape(final Character escape) { | |
return builder().setEscape(escape).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} using the first record as header. | |
* | |
* <p> | |
* Calling this method is equivalent to calling: | |
* </p> | |
* | |
* <pre> | |
* CSVFormat format = aFormat.withHeader().withSkipHeaderRecord(); | |
* </pre> | |
* | |
* @return A new CSVFormat that is equal to this but using the first record as header. | |
* @see Builder#setSkipHeaderRecord(boolean) | |
* @see Builder#setHeader(String...) | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setHeader(String...) Builder#setHeader()}.{@link Builder#setSkipHeaderRecord(boolean) setSkipHeaderRecord(true)}. | |
*/ | |
@Deprecated | |
public CSVFormat withFirstRecordAsHeader() { | |
// @formatter:off | |
return builder() | |
.setHeader() | |
.setSkipHeaderRecord(true) | |
.build(); | |
// @formatter:on | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header of the format defined by the enum class. | |
* | |
* <p> | |
* Example: | |
* </p> | |
* | |
* <pre> | |
* public enum Header { | |
* Name, Email, Phone | |
* } | |
* | |
* CSVFormat format = aformat.withHeader(Header.class); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param headerEnum the enum defining the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return A new CSVFormat that is equal to this but with the specified header | |
* @see Builder#setHeader(String...) | |
* @see Builder#setSkipHeaderRecord(boolean) | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setHeader(Class)} | |
*/ | |
@Deprecated | |
public CSVFormat withHeader(final Class<? extends Enum<?>> headerEnum) { | |
return builder().setHeader(headerEnum).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header of the format set from the result set metadata. The header can either be parsed automatically from the | |
* input file with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader(resultSet); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param resultSet the resultSet for the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return A new CSVFormat that is equal to this but with the specified header | |
* @throws SQLException SQLException if a database access error occurs or this method is called on a closed result set. | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setHeader(ResultSet)} | |
*/ | |
@Deprecated | |
public CSVFormat withHeader(final ResultSet resultSet) throws SQLException { | |
return builder().setHeader(resultSet).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header of the format set from the result set metadata. The header can either be parsed automatically from the | |
* input file with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader(metaData); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param resultSetMetaData the metaData for the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return A new CSVFormat that is equal to this but with the specified header | |
* @throws SQLException SQLException if a database access error occurs or this method is called on a closed result set. | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setHeader(ResultSetMetaData)} | |
*/ | |
@Deprecated | |
public CSVFormat withHeader(final ResultSetMetaData resultSetMetaData) throws SQLException { | |
return builder().setHeader(resultSetMetaData).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header of the format set to the given values. The header can either be parsed automatically from the input file | |
* with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader(); | |
* </pre> | |
* | |
* or specified manually with: | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeader("name", "email", "phone"); | |
* </pre> | |
* <p> | |
* The header is also used by the {@link CSVPrinter}. | |
* </p> | |
* | |
* @param header the header, {@code null} if disabled, empty if parsed automatically, user specified otherwise. | |
* @return A new CSVFormat that is equal to this but with the specified header | |
* @see Builder#setSkipHeaderRecord(boolean) | |
* @deprecated Use {@link Builder#setHeader(String...)} | |
*/ | |
@Deprecated | |
public CSVFormat withHeader(final String... header) { | |
return builder().setHeader(header).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header comments of the format set to the given values. The comments will be printed first, before the headers. | |
* This setting is ignored by the parser. | |
* | |
* <pre> | |
* CSVFormat format = aformat.withHeaderComments("Generated by Apache Commons CSV.", Instant.now()); | |
* </pre> | |
* | |
* @param headerComments the headerComments which will be printed by the Printer before the actual CSV data. | |
* @return A new CSVFormat that is equal to this but with the specified header | |
* @see Builder#setSkipHeaderRecord(boolean) | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setHeaderComments(Object...)} | |
*/ | |
@Deprecated | |
public CSVFormat withHeaderComments(final Object... headerComments) { | |
return builder().setHeaderComments(headerComments).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the empty line skipping behavior of the format set to {@code true}. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified empty line skipping behavior. | |
* @see Builder#setIgnoreEmptyLines(boolean) | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setIgnoreEmptyLines(boolean) Builder#setIgnoreEmptyLines(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreEmptyLines() { | |
return builder().setIgnoreEmptyLines(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the empty line skipping behavior of the format set to the given value. | |
* | |
* @param ignoreEmptyLines the empty line skipping behavior, {@code true} to ignore the empty lines between the records, {@code false} to translate empty | |
* lines to empty records. | |
* @return A new CSVFormat that is equal to this but with the specified empty line skipping behavior. | |
* @deprecated Use {@link Builder#setIgnoreEmptyLines(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreEmptyLines(final boolean ignoreEmptyLines) { | |
return builder().setIgnoreEmptyLines(ignoreEmptyLines).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the header ignore case behavior set to {@code true}. | |
* | |
* @return A new CSVFormat that will ignore case header name. | |
* @see Builder#setIgnoreHeaderCase(boolean) | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setIgnoreHeaderCase(boolean) Builder#setIgnoreHeaderCase(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreHeaderCase() { | |
return builder().setIgnoreHeaderCase(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with whether header names should be accessed ignoring case. | |
* | |
* @param ignoreHeaderCase the case mapping behavior, {@code true} to access name/values, {@code false} to leave the mapping as is. | |
* @return A new CSVFormat that will ignore case header name if specified as {@code true} | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setIgnoreHeaderCase(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreHeaderCase(final boolean ignoreHeaderCase) { | |
return builder().setIgnoreHeaderCase(ignoreHeaderCase).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the parser trimming behavior of the format set to {@code true}. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified parser trimming behavior. | |
* @see Builder#setIgnoreSurroundingSpaces(boolean) | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setIgnoreSurroundingSpaces(boolean) Builder#setIgnoreSurroundingSpaces(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreSurroundingSpaces() { | |
return builder().setIgnoreSurroundingSpaces(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the parser trimming behavior of the format set to the given value. | |
* | |
* @param ignoreSurroundingSpaces the parser trimming behavior, {@code true} to remove the surrounding spaces, {@code false} to leave the spaces as is. | |
* @return A new CSVFormat that is equal to this but with the specified trimming behavior. | |
* @deprecated Use {@link Builder#setIgnoreSurroundingSpaces(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withIgnoreSurroundingSpaces(final boolean ignoreSurroundingSpaces) { | |
return builder().setIgnoreSurroundingSpaces(ignoreSurroundingSpaces).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with conversions to and from null for strings on input and output. | |
* <ul> | |
* <li><strong>Reading:</strong> Converts strings equal to the given {@code nullString} to {@code null} when reading records.</li> | |
* <li><strong>Writing:</strong> Writes {@code null} as the given {@code nullString} when writing records.</li> | |
* </ul> | |
* | |
* @param nullString the String to convert to and from {@code null}. No substitution occurs if {@code null} | |
* @return A new CSVFormat that is equal to this but with the specified null conversion string. | |
* @deprecated Use {@link Builder#setNullString(String)} | |
*/ | |
@Deprecated | |
public CSVFormat withNullString(final String nullString) { | |
return builder().setNullString(nullString).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the quoteChar of the format set to the specified character. | |
* | |
* @param quoteChar the quote character | |
* @return A new CSVFormat that is equal to this but with the specified character as quoteChar | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setQuote(char)} | |
*/ | |
@Deprecated | |
public CSVFormat withQuote(final char quoteChar) { | |
return builder().setQuote(quoteChar).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the quoteChar of the format set to the specified character. | |
* | |
* @param quoteChar the quote character, use {@code null} to disable. | |
* @return A new CSVFormat that is equal to this but with the specified character as quoteChar | |
* @throws IllegalArgumentException thrown if the specified character is a line break | |
* @deprecated Use {@link Builder#setQuote(Character)} | |
*/ | |
@Deprecated | |
public CSVFormat withQuote(final Character quoteChar) { | |
return builder().setQuote(quoteChar).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the output quote policy of the format set to the specified value. | |
* | |
* @param quoteMode the quote policy to use for output. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified quote policy | |
* @deprecated Use {@link Builder#setQuoteMode(QuoteMode)} | |
*/ | |
@Deprecated | |
public CSVFormat withQuoteMode(final QuoteMode quoteMode) { | |
return builder().setQuoteMode(quoteMode).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the record separator of the format set to the specified character. | |
* | |
* <p> | |
* <strong>Note:</strong> This setting is only used during printing and does not affect parsing. Parsing currently only works for inputs with '\n', '\r' and | |
* "\r\n" | |
* </p> | |
* | |
* @param recordSeparator the record separator to use for output. | |
* @return A new CSVFormat that is equal to this but with the specified output record separator | |
* @deprecated Use {@link Builder#setRecordSeparator(char)} | |
*/ | |
@Deprecated | |
public CSVFormat withRecordSeparator(final char recordSeparator) { | |
return builder().setRecordSeparator(recordSeparator).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the record separator of the format set to the specified String. | |
* | |
* <p> | |
* <strong>Note:</strong> This setting is only used during printing and does not affect parsing. Parsing currently only works for inputs with '\n', '\r' and | |
* "\r\n" | |
* </p> | |
* | |
* @param recordSeparator the record separator to use for output. | |
* @return A new CSVFormat that is equal to this but with the specified output record separator | |
* @throws IllegalArgumentException if recordSeparator is none of CR, LF or CRLF | |
* @deprecated Use {@link Builder#setRecordSeparator(String)} | |
*/ | |
@Deprecated | |
public CSVFormat withRecordSeparator(final String recordSeparator) { | |
return builder().setRecordSeparator(recordSeparator).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with skipping the header record set to {@code true}. | |
* | |
* @return A new CSVFormat that is equal to this but with the specified skipHeaderRecord setting. | |
* @see Builder#setSkipHeaderRecord(boolean) | |
* @see Builder#setHeader(String...) | |
* @since 1.1 | |
* @deprecated Use {@link Builder#setSkipHeaderRecord(boolean) Builder#setSkipHeaderRecord(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withSkipHeaderRecord() { | |
return builder().setSkipHeaderRecord(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with whether to skip the header record. | |
* | |
* @param skipHeaderRecord whether to skip the header record. | |
* @return A new CSVFormat that is equal to this but with the specified skipHeaderRecord setting. | |
* @see Builder#setHeader(String...) | |
* @deprecated Use {@link Builder#setSkipHeaderRecord(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withSkipHeaderRecord(final boolean skipHeaderRecord) { | |
return builder().setSkipHeaderRecord(skipHeaderRecord).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with the record separator of the format set to the operating system's line separator string, typically CR+LF on Windows | |
* and LF on Linux. | |
* | |
* <p> | |
* <strong>Note:</strong> This setting is only used during printing and does not affect parsing. Parsing currently only works for inputs with '\n', '\r' and | |
* "\r\n" | |
* </p> | |
* | |
* @return A new CSVFormat that is equal to this but with the operating system's line separator string. | |
* @since 1.6 | |
* @deprecated Use {@link Builder#setRecordSeparator(String) setRecordSeparator(System.lineSeparator())} | |
*/ | |
@Deprecated | |
public CSVFormat withSystemRecordSeparator() { | |
return builder().setRecordSeparator(System.lineSeparator()).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} to add a trailing delimiter. | |
* | |
* @return A new CSVFormat that is equal to this but with the trailing delimiter setting. | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setTrailingDelimiter(boolean) Builder#setTrailingDelimiter(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withTrailingDelimiter() { | |
return builder().setTrailingDelimiter(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with whether to add a trailing delimiter. | |
* | |
* @param trailingDelimiter whether to add a trailing delimiter. | |
* @return A new CSVFormat that is equal to this but with the specified trailing delimiter setting. | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setTrailingDelimiter(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withTrailingDelimiter(final boolean trailingDelimiter) { | |
return builder().setTrailingDelimiter(trailingDelimiter).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} to trim leading and trailing blanks. See {@link #getTrim()} for details of where this is used. | |
* | |
* @return A new CSVFormat that is equal to this but with the trim setting on. | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setTrim(boolean) Builder#setTrim(true)} | |
*/ | |
@Deprecated | |
public CSVFormat withTrim() { | |
return builder().setTrim(true).build(); | |
} | |
/** | |
* Returns a new {@code CSVFormat} with whether to trim leading and trailing blanks. See {@link #getTrim()} for details of where this is used. | |
* | |
* @param trim whether to trim leading and trailing blanks. | |
* @return A new CSVFormat that is equal to this but with the specified trim setting. | |
* @since 1.3 | |
* @deprecated Use {@link Builder#setTrim(boolean)} | |
*/ | |
@Deprecated | |
public CSVFormat withTrim(final boolean trim) { | |
return builder().setTrim(trim).build(); | |
} | |
} |