org.supercsv.io.AbstractCsvWriter Maven / Gradle / Ivy
/*
* Copyright 2007 Kasper B. Graversen
*
* Licensed 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.supercsv.io;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.List;
import org.supercsv.encoder.CsvEncoder;
import org.supercsv.prefs.CsvPreference;
import org.supercsv.util.CsvContext;
import org.supercsv.util.Util;
/**
* Defines the standard behaviour of a CSV writer.
*
* @author Kasper B. Graversen
* @author James Bassett
*/
public abstract class AbstractCsvWriter implements ICsvWriter {
private final Writer writer;
private final CsvPreference preference;
private final CsvEncoder encoder;
// the line number being written / just written
private int lineNumber = 0;
// the row being written / just written
private int rowNumber = 0;
// the column being written / just written
private int columnNumber = 0;
/**
* Constructs a new AbstractCsvWriter with the supplied writer and preferences.
*
* @param writer
* the stream to write to
* @param preference
* the CSV preferences
* @throws NullPointerException
* if writer or preference are null
*/
public AbstractCsvWriter(final Writer writer, final CsvPreference preference) {
this(writer, preference, true);
}
/**
* Constructs a new AbstractCsvWriter with the supplied writer, preferences and option
* to wrap the writer.
*
* @param writer
* the stream to write to
* @param preference
* the CSV preferences
* @param bufferizeWriter
* indicates if the writer should be wrapped internally with a BufferedWriter
* @throws NullPointerException
* if writer or preference are null
*/
public AbstractCsvWriter(final Writer writer, final CsvPreference preference, boolean bufferizeWriter) {
if( writer == null ) {
throw new NullPointerException("writer should not be null");
} else if( preference == null ) {
throw new NullPointerException("preference should not be null");
}
this.writer = bufferizeWriter ? new BufferedWriter(writer) : writer;
this.preference = preference;
this.encoder = preference.getEncoder();
}
/**
* Closes the underlying writer, flushing it first.
*/
public void close() throws IOException {
writer.close();
}
/**
* Flushes the underlying writer.
*/
public void flush() throws IOException {
writer.flush();
}
/**
* In order to maintain the current row and line numbers, this method must be called at the very
* beginning of every write method implemented in concrete CSV writers. This will allow the correct row/line numbers
* to be used in any exceptions thrown before writing occurs (e.g. during CellProcessor execution), and means that
* {@link #getLineNumber()} and {@link #getRowNumber()} can be called after writing to return the line/row just
* written.
*/
protected void incrementRowAndLineNo() {
lineNumber++;
rowNumber++;
}
/**
* {@inheritDoc}
*/
public int getLineNumber() {
return lineNumber;
}
/**
* {@inheritDoc}
*/
public int getRowNumber() {
return rowNumber;
}
/**
* Writes a List of columns as a line to the CsvWriter.
*
* @param columns
* the columns to write
* @throws IllegalArgumentException
* if columns.size == 0
* @throws IOException
* If an I/O error occurs
* @throws NullPointerException
* if columns is null
*/
protected void writeRow(final List columns) throws IOException {
writeRow(Util.objectListToStringArray(columns));
}
/**
* Writes one or more Object columns as a line to the CsvWriter.
*
* @param columns
* the columns to write
* @throws IllegalArgumentException
* if columns.length == 0
* @throws IOException
* If an I/O error occurs
* @throws NullPointerException
* if columns is null
*/
protected void writeRow(final Object... columns) throws IOException {
writeRow(Util.objectArrayToStringArray(columns));
}
/**
* Writes one or more String columns as a line to the CsvWriter.
*
* @param columns
* the columns to write
* @throws IllegalArgumentException
* if columns.length == 0
* @throws IOException
* If an I/O error occurs
* @throws NullPointerException
* if columns is null
*/
protected void writeRow(final String... columns) throws IOException {
if( columns == null ) {
throw new NullPointerException(String.format("columns to write should not be null on line %d", lineNumber));
} else if( columns.length == 0 ) {
throw new IllegalArgumentException(String.format("columns to write should not be empty on line %d",
lineNumber));
}
StringBuilder builder = new StringBuilder();
for( int i = 0; i < columns.length; i++ ) {
columnNumber = i + 1; // column no used by CsvEncoder
if( i > 0 ) {
builder.append((char) preference.getDelimiterChar()); // delimiter
}
final String csvElement = columns[i];
if( csvElement != null ) {
final CsvContext context = new CsvContext(lineNumber, rowNumber, columnNumber);
final String escapedCsv = encoder.encode(csvElement, context, preference);
builder.append(escapedCsv);
lineNumber = context.getLineNumber(); // line number can increment when encoding multi-line columns
}
}
builder.append(preference.getEndOfLineSymbols()); // EOL
writer.write(builder.toString());
}
/**
* {@inheritDoc}
*/
public void writeComment(final String comment) throws IOException {
lineNumber++; // we're not catering for embedded newlines (must be a single-line comment)
if( comment == null ) {
throw new NullPointerException(String.format("comment to write should not be null on line %d", lineNumber));
}
writer.write(comment + preference.getEndOfLineSymbols());
}
/**
* {@inheritDoc}
*/
public void writeHeader(final String... header) throws IOException {
// update the current row/line numbers
incrementRowAndLineNo();
writeRow(header);
}
}