AbstractWriter

java.lang.Object
- com.univocity.parsers.common.AbstractWriter<S>

Type Parameters:

S - The specific writer settings configuration class, which can potentially provide additional configuration options supported by the writer implementation.

Direct Known Subclasses:

CsvWriter, FixedWidthWriter, TsvWriter
```
public abstract class AbstractWriter<S extends CommonWriterSettings<?>>
extends java.lang.Object
```
The AbstractWriter class provides a common ground for all writers in univocity-parsers. It handles all settings defined by CommonWriterSettings, and delegates the writing algorithm implementation to its subclasses through the abstract method processRow(Object[]) The following (absolutely required) attributes are exposed to subclasses:
- appender (WriterCharAppender): the character writer that appends characters from a given input into an internal buffer
See Also:

CsvWriter, CsvWriterSettings, FixedWidthWriter, FixedWidthWriterSettings, TsvWriter, TsvWriterSettings, WriterCharAppender, RowWriterProcessor

Field Summary

Fields
Modifier and Type	Field and Description
`protected WriterCharAppender`	`appender`
`private boolean`	`columnReorderingEnabled`
`protected char`	`comment`
`private NormalizedString[]`	`dummyHeaderRow`
`protected java.lang.String`	`emptyValue`
`private boolean`	`enableNewlineAfterRecord`
`private int`	`errorContentLength`
`protected boolean`	`expandRows`
`private java.util.Map<NormalizedString[],java.util.Map<NormalizedString,java.lang.Integer>>`	`headerIndexes`
`protected NormalizedString[]`	`headers`
`protected boolean[]`	`headerTrimFlags`
`protected boolean`	`ignoreLeading`
`protected boolean`	`ignoreTrailing`
`private int[]`	`indexesToWrite`
`private CommonSettings<DummyFormat>`	`internalSettings`
`private boolean`	`isHeaderWritingEnabled`
`private int`	`largestRowLength`
`private char[]`	`lineSeparator`
`protected java.lang.String`	`nullValue`
`private java.lang.Object[]`	`outputRow`
`private java.lang.Object[]`	`partialLine`
`private int`	`partialLineIndex`
`protected long`	`recordCount`
`private WriterCharAppender`	`rowAppender`
`private boolean`	`skipEmptyLines`
`protected boolean`	`usingNullOrEmptyValue`
`private boolean`	`usingSwitch`
`protected int`	`whitespaceRangeStart`
`private java.io.Writer`	`writer`
`private RowWriterProcessor`	`writerProcessor`
`protected boolean`	`writingHeaders`

Constructor Summary

Constructors
Constructor and Description
`AbstractWriter(java.io.File file, java.nio.charset.Charset encoding, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.File file, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.File file, java.lang.String encoding, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.OutputStream output, java.nio.charset.Charset encoding, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.OutputStream output, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.OutputStream output, java.lang.String encoding, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.
`AbstractWriter(java.io.Writer writer, S settings)` All writers must support, at the very least, the settings provided by `CommonWriterSettings`.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addStringValues(java.util.Collection<java.lang.String> values)` Writes a sequence of Strings to a row in memory.
`void`	`addValue(int index, java.lang.Object value)` Writes a value to a row in memory.
`private void`	`addValue(NormalizedString[] headersInContext, NormalizedString headerName, boolean ignoreOnMismatch, java.lang.Object value)`
`void`	`addValue(java.lang.Object value)` Writes a value to a row in memory.
`void`	`addValue(java.lang.String headerName, java.lang.Object value)` Writes a value to a row in memory.
`void`	`addValues(java.util.Collection<?> values)` Writes a sequence of values to a row in memory.
`void`	`addValues(java.lang.Object... values)` Writes a sequence of values to a row in memory.
`private java.lang.Object[]`	`adjustRowLength(java.lang.Object[] row)`
`protected boolean`	`allowTrim(int fieldIndex)` Checks whether the writer can remove trailing/leading whitespaces from a value being written.
`protected void`	`appendToRow(char ch)` Appends the given character to the output row.
`protected void`	`appendToRow(char[] chars)` Appends the given character sequence to the output row
`protected void`	`appendValueToRow()` Appends the processed sequence of characters in `appender` to the output row.
`void`	`close()` Closes the `Writer` given in this class constructor.
`void`	`commentRow(java.lang.String comment)` Writes a comment row to the output.
`java.lang.String`	`commentRowToString(java.lang.String comment)` Writes a comment row to a `String`
`void`	`discardValues()` Discards the contents written to the internal in-memory row (using `or #writeValue()`.
`protected void`	`enableNewlineAfterRecord(boolean enableNewlineAfterRecord)`
`protected java.lang.Object[]`	`expand(java.lang.Object[] row, int length, java.lang.Integer h2)`
`private <T> void`	`fillOutputRow(T[] row)` Used when fields were selected and the input rows have a different order than the output.
`private void`	`fillPartialLineToMatchHeaders()`
`void`	`flush()` Flushes the `Writer` given in this class constructor.
`private java.lang.String`	`getContent(java.lang.CharSequence tmp)`
`private java.lang.Object[]`	`getContent(java.lang.Object[] tmp)`
`private int`	`getFieldIndex(NormalizedString[] headersInContext, NormalizedString headerName, boolean ignoreOnMismatch)` Calculates the index of a header name in relation to the original `headers` array defined in this writer
`long`	`getRecordCount()` Returns the number of records written to the output so far
`private NormalizedString[]`	`getRowProcessorHeaders()`
`protected java.lang.String`	`getStringValue(java.lang.Object element)` Converts a given object to its String representation for writing to a `String` If the object is null, then `nullValue` is returned. If the String representation of this object is an empty String, then `emptyValue` is returned
`protected abstract void`	`initialize(S settings)` Initializes the concrete implementation of this class with format-specific settings.
`private void`	`internalWriteRow()` Writes the accumulated value of a record to the output, followed by a newline, and increases the record count.
`private java.lang.String`	`internalWriteRowToString()` Writes the accumulated value of a record to the output, followed by a newline, and increases the record count.
`<K> void`	`processObjectRecords(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output .
`<K> void`	`processObjectRecordsAndClose(java.util.Map<K,java.lang.Object[]> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output and closes the writer.
`<K> void`	`processObjectRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output and closes the writer.
`<K> java.util.List<java.lang.String>`	`processObjectRecordsToString(java.util.Map<K,java.lang.Object[]> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a `List` of `String` formatted to according to the specified output format.
`<K> java.util.List<java.lang.String>`	`processObjectRecordsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a `List` of `String` formatted to according to the specified output format.
`void`	`processRecord(java.util.Map<?,?> rowData)` Processes the values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a new output record A `TextWritingException` will be thrown if no `RowWriterProcessor` is provided by `CommonWriterSettings.getRowWriterProcessor()`.
`<K> void`	`processRecord(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,?> rowData)` Processes the values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a new output record A `TextWritingException` will be thrown if no `RowWriterProcessor` is provided by `CommonWriterSettings.getRowWriterProcessor()`.
`void`	`processRecord(java.lang.Object... record)` Processes the data given for an individual record with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes it.
`void`	`processRecord(java.lang.Object record)` Processes the data given for an individual record with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes it.
`<T extends Record> void`	`processRecord(T record)`
`void`	`processRecords(java.lang.Iterable<?> records)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them.
`<K,I extends java.lang.Iterable<?>> void`	`processRecords(java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output .
`<K,I extends java.lang.Iterable<?>> void`	`processRecords(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output .
`void`	`processRecords(java.lang.Object[] records)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them.
`<T extends Record> void`	`processRecords(T[] records)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them.
`void`	`processRecordsAndClose(java.lang.Iterable<?> allRecords)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them, then finally and closes the output A `TextWritingException` will be thrown if no `RowWriterProcessor` is provided by `CommonWriterSettings.getRowWriterProcessor()`.
`<K,I extends java.lang.Iterable<?>> void`	`processRecordsAndClose(java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output and closes the writer.
`<K,I extends java.lang.Iterable<?>> void`	`processRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes all values to the output and closes the writer.
`void`	`processRecordsAndClose(java.lang.Object[] allRecords)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them, then finally and closes the output A `TextWritingException` will be thrown if no `RowWriterProcessor` is provided by `CommonWriterSettings.getRowWriterProcessor()`.
`java.util.List<java.lang.String>`	`processRecordsToString(java.lang.Iterable<?> records)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them to a `List` of `String`.
`<K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String>`	`processRecordsToString(java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a `List` of `String` formatted to according to the specified output format.
`<K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String>`	`processRecordsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Processes the data in all values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into a `List` of `String` formatted to according to the specified output format.
`java.util.List<java.lang.String>`	`processRecordsToString(java.lang.Object[] records)` Iterates over all records, processes each one with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, and writes them them to a `List` of `String`.
`java.lang.String`	`processRecordToString(java.util.Map<?,?> rowData)` Processes the values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into `String` formatted according to the specified output format.
`<K> java.lang.String`	`processRecordToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,?> rowData)` Processes the values of a map using the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()` and writes the result into `String` formatted according to the specified output format.
`java.lang.String`	`processRecordToString(java.lang.Object... record)` Processes the data given for an individual record with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes it to a `String`.
`java.lang.String`	`processRecordToString(java.lang.Object record)` Processes the data given for an individual record with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes it.
`<T extends Record> java.lang.String`	`processRecordToString(T record)` Processes the data given for an individual record with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`, then writes it to a `String`.
`protected abstract void`	`processRow(java.lang.Object[] row)` Format-specific implementation for writing a single record into the output.
`void`	`processValuesToRow()` Writes the contents accumulated in an internal in-memory row (using `or #addValue()` to a new record in the output.
`java.lang.String`	`processValuesToString()` Writes the contents accumulated in an internal in-memory row (using `or #addValue()` to a `String` The objects added to this row will be processed with the `RowWriterProcessor` provided by `CommonWriterSettings.getRowWriterProcessor()`.
`private void`	`setHeadersFromMap(java.util.Map<?,?> map, boolean keys)` Iterates over the keys of a map and builds an internal header row.
`protected static int`	`skipLeadingWhitespace(int whitespaceRangeStart, java.lang.String element)` Identifies the starting character index of a value being written if leading whitespaces are to be discarded.
`private void`	`submitRow(java.lang.Object[] row)` Submits a row for processing by the format-specific implementation.
`private TextWritingException`	`throwExceptionAndClose(java.lang.String message)` In case of any exceptions, a `TextWritingException` is thrown, and the output `Writer` is closed.
`private TextWritingException`	`throwExceptionAndClose(java.lang.String message, java.lang.Object[] recordValues, java.lang.Throwable cause)` In case of any exceptions, a `TextWritingException` is thrown, and the output `Writer` is closed.
`private TextWritingException`	`throwExceptionAndClose(java.lang.String message, java.lang.String recordCharacters, java.lang.Throwable cause)` In case of any exceptions, a `TextWritingException` is thrown, and the output `Writer` is closed.
`private TextWritingException`	`throwExceptionAndClose(java.lang.String message, java.lang.Throwable cause)` In case of any exceptions, a `TextWritingException` is thrown, and the output `Writer` is closed.
`void`	`updateFieldExclusion(java.lang.Integer... fieldIndexesToExclude)` Updates the selection of fields to exclude when writing.
`void`	`updateFieldExclusion(java.lang.String... fieldsToExclude)` Updates the selection of fields to exclude when writing.
`void`	`updateFieldSelection(java.lang.Integer... newFieldSelectionByIndex)` Updates the selection of fields to write.
`void`	`updateFieldSelection(java.lang.String... newFieldSelection)` Updates the selection of fields to write.
`private void`	`updateIndexesToWrite(CommonSettings<?> settings)` Update indexes to write based on the field selection provided by the user.
`private <K> java.util.Map<K,java.lang.Iterable<java.lang.Object>>`	`wrapObjectArray(java.util.Map<K,java.lang.Object[]> rowData)`
`private <K> java.util.Map<K,java.lang.Iterable<java.lang.String>>`	`wrapRecordValues(java.util.Map<K,? extends Record> rowData)`
`private <K> java.util.Map<K,java.lang.Iterable<java.lang.String>>`	`wrapStringArray(java.util.Map<K,java.lang.String[]> rowData)`
`void`	`writeEmptyRow()` Writes an empty line to the output, unless this is a `FixedWidthWriter` whose `FixedWidthWriterSettings.getWriteLineSeparatorAfterRecord()` evaluates to `false`.
`void`	`writeHeaders()` Writes the headers defined in `CommonSettings.getHeaders()` A `TextWritingException` will be thrown if no headers were defined or if records were already written to the output.
`void`	`writeHeaders(java.util.Collection<?> headers)` Writes the given collection of headers to the output.
`void`	`writeHeaders(java.lang.String... headers)` Writes the given collection of headers to the output.
`java.lang.String`	`writeHeadersToString()` Writes the headers defined in `CommonSettings.getHeaders()` to a `String`
`java.lang.String`	`writeHeadersToString(java.util.Collection<?> headers)` Writes the given collection of headers to a `String` A `TextWritingException` will be thrown if no headers were defined.
`java.lang.String`	`writeHeadersToString(java.lang.String... headers)` Writes the given collection of headers to a `String` A `TextWritingException` will be thrown if no headers were defined or if records were already written to a `String`
`<K> void`	`writeObjectRows(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable.
`<K> void`	`writeObjectRowsAndClose(java.util.Map<K,java.lang.Object[]> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`<K> void`	`writeObjectRowsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`<K> java.util.List<java.lang.String>`	`writeObjectRowsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.Object[]> rowData)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`<T extends Record> void`	`writeRecord(T row)` Writes the data given for an individual record.
`void`	`writeRecords(java.util.Collection<? extends Record> rows)` Iterates over all records and writes them to the output.
`<K> void`	`writeRecords(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,? extends Record> rowData)` Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable.
`void`	`writeRecordsAndClose(java.util.Collection<? extends Record> allRows)` Iterates over all records, writes them and closes the output.
`<K> void`	`writeRecordsAndClose(java.util.Map<K,? extends Record> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`<K> void`	`writeRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,? extends Record> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`java.util.List<java.lang.String>`	`writeRecordsToString(java.util.Collection<? extends Record> rows)` Iterates over all records and writes them to a `List` of `String`.
`<K> java.util.List<java.lang.String>`	`writeRecordsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,? extends Record> rowData)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`<T extends Record> java.lang.String`	`writeRecordToString(T row)` Writes the data given for an individual record to a `String`.
`void`	`writeRow(java.util.Collection<?> row)` Writes the data given for an individual record.
`void`	`writeRow(java.util.Map<?,?> rowData)` Writes the values of a given map into new output record Note this method will not use the `RowWriterProcessor`.
`<K> void`	`writeRow(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,?> rowData)` Writes the values of a given map into new output record Note this method will not use the `RowWriterProcessor`.
`void`	`writeRow(java.lang.Object... row)` Writes the data given for an individual record.
`void`	`writeRow(java.lang.String row)` Writes a plain (potentially free-text) String as a line to the output.
`void`	`writeRow(java.lang.String[] row)` Writes the data given for an individual record.
`void`	`writeRows(java.util.Collection<java.lang.Object[]> rows)` Iterates over all records and writes them to the output.
`<C extends java.util.Collection<?>> void`	`writeRows(java.lang.Iterable<C> rows)` Iterates over all records and writes them to the output.
`<K,I extends java.lang.Iterable<?>> void`	`writeRows(java.util.Map<K,I> rowData)` Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable.
`<K,I extends java.lang.Iterable<?>> void`	`writeRows(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable.
`private <K,I extends java.lang.Iterable<?>> void`	`writeRows(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData, java.util.List<java.lang.String> outputList, boolean useRowProcessor)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`void`	`writeRows(java.lang.Object[][] rows)` Iterates over all records and writes them to the output.
`void`	`writeRowsAndClose(java.util.Collection<java.lang.Object[]> allRows)` Iterates over all records, writes them and closes the output.
`<C extends java.util.Collection<?>> void`	`writeRowsAndClose(java.lang.Iterable<C> allRows)` Iterates over all records, writes them and closes the output.
`<K,I extends java.lang.Iterable<?>> void`	`writeRowsAndClose(java.util.Map<K,I> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`<K,I extends java.lang.Iterable<?>> void`	`writeRowsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`void`	`writeRowsAndClose(java.lang.Object[][] allRows)` Iterates over all records, writes them and closes the output.
`java.util.List<java.lang.String>`	`writeRowsToString(java.util.Collection<java.lang.Object[]> rows)` Iterates over all records and writes them to a `List` of `String`.
`<C extends java.util.Collection<?>> java.util.List<java.lang.String>`	`writeRowsToString(java.lang.Iterable<C> rows)` Iterates over all records and writes them to a `List` of `String`.
`<K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String>`	`writeRowsToString(java.util.Map<K,I> rowData)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`<K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String>`	`writeRowsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,I> rowData)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`java.util.List<java.lang.String>`	`writeRowsToString(java.lang.Object[][] rows)` Iterates over all records and writes them to a `List` of `String`.
`java.lang.String`	`writeRowToString(java.util.Collection<?> row)` Writes the data given for an individual record to a `String`.
`java.lang.String`	`writeRowToString(java.util.Map<?,?> rowData)` Writes the values of a given map to a `String` formatted to according to the specified output format.
`<K> java.lang.String`	`writeRowToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,?> rowData)` Writes the values of a given map to a `String` formatted to according to the specified output format.
`java.lang.String`	`writeRowToString(java.lang.Object... row)` Writes the data given for an individual record to a `String`.
`java.lang.String`	`writeRowToString(java.lang.String[] row)` Writes the data given for an individual record to a `String`.
`void`	`writeStringRows(java.util.Collection<java.lang.String[]> rows)` Iterates over all records and writes them to the output.
`<C extends java.util.Collection<?>> void`	`writeStringRows(java.lang.Iterable<C> rows)` Iterates over all records and writes them to the output.
`<K> void`	`writeStringRows(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.String[]> rowData)` Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable.
`void`	`writeStringRowsAndClose(java.util.Collection<java.lang.String[]> allRows)` Iterates over all records, writes them and closes the output.
`<K> void`	`writeStringRowsAndClose(java.util.Map<K,java.lang.String[]> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`<K> void`	`writeStringRowsAndClose(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.String[]> rowData)` Writes the values of a given map to multiple output records and closes the output when finished.
`java.util.List<java.lang.String>`	`writeStringRowsToString(java.util.Collection<java.lang.String[]> rows)` Iterates over all records and writes them to a `List` of `String`.
`<C extends java.util.Collection<?>> java.util.List<java.lang.String>`	`writeStringRowsToString(java.lang.Iterable<C> rows)` Iterates over all records and writes them to a `List` of `String`.
`<K> java.util.List<java.lang.String>`	`writeStringRowsToString(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,java.lang.String[]> rowData)` Writes the values of a given map to a `List` of `String` formatted to according to the specified output format.
`private <K> void`	`writeValuesFromMap(java.util.Map<K,java.lang.String> headerMapping, java.util.Map<K,?> rowData)` Writes values from an implementation of `Map` to a partial output record, ready to be written to the output.
`void`	`writeValuesToRow()` Writes the contents accumulated in an internal in-memory row (using `or #writeValue()` to a new record in the output.
`java.lang.String`	`writeValuesToString()` Writes the contents accumulated in an internal in-memory row (using `or #addValue()` as a `String`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - writerProcessor
```
private final RowWriterProcessor writerProcessor
```
  - writer
```
private java.io.Writer writer
```
  - skipEmptyLines
```
private final boolean skipEmptyLines
```
  - comment
```
protected final char comment
```
  - rowAppender
```
private final WriterCharAppender rowAppender
```
  - isHeaderWritingEnabled
```
private final boolean isHeaderWritingEnabled
```
  - outputRow
```
private java.lang.Object[] outputRow
```
  - indexesToWrite
```
private int[] indexesToWrite
```
  - lineSeparator
```
private final char[] lineSeparator
```
  - headers
```
protected NormalizedString[] headers
```
  - recordCount
```
protected long recordCount
```
  - nullValue
```
protected final java.lang.String nullValue
```
  - emptyValue
```
protected final java.lang.String emptyValue
```
  - appender
```
protected final WriterCharAppender appender
```
  - partialLine
```
private final java.lang.Object[] partialLine
```
  - partialLineIndex
```
private int partialLineIndex
```
  - headerIndexes
```
private java.util.Map<NormalizedString[],java.util.Map<NormalizedString,java.lang.Integer>> headerIndexes
```
  - largestRowLength
```
private int largestRowLength
```
  - writingHeaders
```
protected boolean writingHeaders
```
  - headerTrimFlags
```
protected boolean[] headerTrimFlags
```
  - dummyHeaderRow
```
private NormalizedString[] dummyHeaderRow
```
  - expandRows
```
protected boolean expandRows
```
  - usingSwitch
```
private boolean usingSwitch
```
  - enableNewlineAfterRecord
```
private boolean enableNewlineAfterRecord
```
  - usingNullOrEmptyValue
```
protected boolean usingNullOrEmptyValue
```
  - whitespaceRangeStart
```
protected final int whitespaceRangeStart
```
  - columnReorderingEnabled
```
private final boolean columnReorderingEnabled
```
  - ignoreLeading
```
protected boolean ignoreLeading
```
  - ignoreTrailing
```
protected boolean ignoreTrailing
```
  - internalSettings
```
private final CommonSettings<DummyFormat> internalSettings
```
  - errorContentLength
```
private final int errorContentLength
```
- Constructor Detail
  - AbstractWriter
```
public AbstractWriter(S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized. Important: by not providing an instance of Writer to this constructor, only the operations that write to Strings are available.
    
    Parameters:
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.File file,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    file - the output file that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.File file,
                      java.lang.String encoding,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    file - the output file that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    encoding - the encoding of the file
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.File file,
                      java.nio.charset.Charset encoding,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    file - the output file that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    encoding - the encoding of the file
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.OutputStream output,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    output - the output stream that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.OutputStream output,
                      java.lang.String encoding,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    output - the output stream that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    encoding - the encoding of the stream
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.OutputStream output,
                      java.nio.charset.Charset encoding,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    output - the output stream that will be written with the format-specific records as defined by subclasses of AbstractWriter.
    
    encoding - the encoding of the stream
    
    settings - the writer configuration
  - AbstractWriter
```
public AbstractWriter(java.io.Writer writer,
                      S settings)
```
    All writers must support, at the very least, the settings provided by CommonWriterSettings. The AbstractWriter requires its configuration to be properly initialized.
    
    Parameters:
    
    writer - the output resource that will receive the format-specific records as defined by subclasses of AbstractWriter.
    
    settings - the writer configuration
- Method Detail
  - enableNewlineAfterRecord
```
protected void enableNewlineAfterRecord(boolean enableNewlineAfterRecord)
```
  - initialize
```
protected abstract void initialize(S settings)
```
    Initializes the concrete implementation of this class with format-specific settings.
    
    Parameters:
    
    settings - the settings object specific to the format being written.
  - updateIndexesToWrite
```
private void updateIndexesToWrite(CommonSettings<?> settings)
```
    Update indexes to write based on the field selection provided by the user.
  - updateFieldSelection
```
public void updateFieldSelection(java.lang.String... newFieldSelection)
```
    Updates the selection of fields to write. This is useful if the input rows change during the writing process and their values need be allocated to specific columns.
    
    Parameters:
    
    newFieldSelection - the new selection of fields to write.
  - updateFieldSelection
```
public void updateFieldSelection(java.lang.Integer... newFieldSelectionByIndex)
```
    Updates the selection of fields to write. This is useful if the input rows change during the writing process and their values need be allocated to specific columns.
    
    Parameters:
    
    newFieldSelectionByIndex - the new selection of fields to write.
  - updateFieldExclusion
```
public void updateFieldExclusion(java.lang.String... fieldsToExclude)
```
    Updates the selection of fields to exclude when writing. This is useful if the input rows change during the writing process and their values need be allocated to specific columns.
    
    Parameters:
    
    fieldsToExclude - the selection of fields to exclude from the output.
  - updateFieldExclusion
```
public void updateFieldExclusion(java.lang.Integer... fieldIndexesToExclude)
```
    Updates the selection of fields to exclude when writing. This is useful if the input rows change during the writing process and their values need be allocated to specific columns.
    
    Parameters:
    
    fieldIndexesToExclude - the selection of fields to exclude from the output.
  - submitRow
```
private void submitRow(java.lang.Object[] row)
```
    Submits a row for processing by the format-specific implementation.
    
    Parameters:
    
    row - the data to be written for a single record in the output.
  - processRow
```
protected abstract void processRow(java.lang.Object[] row)
```
    Format-specific implementation for writing a single record into the output. The AbstractWriter handles the initialization and processing of the output until it is ready to be written (generally, reorganizing it and passing it on to a RowWriterProcessor). It then delegates the record to the writer-specific implementation defined by processRow(Object[]). In general, an implementation of processRow(Object[]) will perform the following steps:
    - Iterate over each object in the given input and convert it to the expected String representation.
    - The conversion must happen using the provided appender object. The an individual value is processed, the appendValueToRow() method must be called. This will clear the accumulated value in appender and add it to the output row.
    - Format specific separators and other characters must be introduced to the output row using appendToRow(char)
    Once the processRow(Object[]) method returns, a row will be written to the output with the processed information, and a newline will be automatically written after the given contents, unless this is a FixedWidthWriter whose FixedWidthWriterSettings.getWriteLineSeparatorAfterRecord() evaluates to false. The newline character sequence will conform to what is specified in Format.getLineSeparator() This cycle repeats until the writing process is stopped by the user or an error happens. In case of errors, the unchecked exception TextWritingException will be thrown and all resources in use will be closed automatically. The exception should contain the cause and more information about the output state when the error happened.
    Parameters:
    
    row - the data to be written to the output in the expected format.
    
    See Also:
    
    CharAppender, CommonWriterSettings
  - appendValueToRow
```
protected final void appendValueToRow()
```
    Appends the processed sequence of characters in appender to the output row.
  - appendToRow
```
protected final void appendToRow(char ch)
```
    Appends the given character to the output row.
    
    Parameters:
    
    ch - the character to append to the output row
  - appendToRow
```
protected final void appendToRow(char[] chars)
```
    Appends the given character sequence to the output row
    
    Parameters:
    
    chars - the sequence of characters to append to the output row
  - writeHeaders
```
public final void writeHeaders()
```
    Writes the headers defined in CommonSettings.getHeaders() A TextWritingException will be thrown if no headers were defined or if records were already written to the output.
  - writeHeaders
```
public final void writeHeaders(java.util.Collection<?> headers)
```
    Writes the given collection of headers to the output. A TextWritingException will be thrown if no headers were defined or if records were already written to the output.
    
    Parameters:
    
    headers - the headers to write to the output.
  - writeHeaders
```
public final void writeHeaders(java.lang.String... headers)
```
    Writes the given collection of headers to the output. A TextWritingException will be thrown if no headers were defined or if records were already written to the output.
    
    Parameters:
    
    headers - the headers to write to the output.
  - processRecordsAndClose
```
public final void processRecordsAndClose(java.lang.Iterable<?> allRecords)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them, then finally and closes the output A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    allRecords - the records to be transformed by a RowWriterProcessor and then written to the output
  - processRecordsAndClose
```
public final void processRecordsAndClose(java.lang.Object[] allRecords)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them, then finally and closes the output A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    allRecords - the records to be transformed by a RowWriterProcessor and then written to the output
  - processRecords
```
public final void processRecords(java.lang.Iterable<?> records)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them. The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    records - the records to be transformed by a RowWriterProcessor and then written to the output
  - processRecords
```
public final void processRecords(java.lang.Object[] records)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them. The output will remain open for further writing. * A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    records - the records to transformed by a RowWriterProcessor and then written to the output
  - processRecords
```
public final <T extends Record> void processRecords(T[] records)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them. The output will remain open for further writing. * A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    records - the records to transformed by a RowWriterProcessor and then written to the output
  - processRecord
```
public final void processRecord(java.lang.Object... record)
```
    Processes the data given for an individual record with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes it. The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    record - the information of a single record to be transformed by a RowWriterProcessor and then written to the output
  - processRecord
```
public final <T extends Record> void processRecord(T record)
```
  - processRecord
```
public final void processRecord(java.lang.Object record)
```
    Processes the data given for an individual record with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes it. The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    record - the information of a single record to be transformed by a RowWriterProcessor and then written to the output
  - getRowProcessorHeaders
```
private NormalizedString[] getRowProcessorHeaders()
```
  - writeRowsAndClose
```
public final <C extends java.util.Collection<?>> void writeRowsAndClose(java.lang.Iterable<C> allRows)
```
    Iterates over all records, writes them and closes the output. Note this method will not use the RowWriterProcessor. Use processRecordsAndClose(Iterable) for that.
    
    Type Parameters:
    
    C - Collection of objects containing values of a row
    
    Parameters:
    
    allRows - the rows to be written to the output
  - writeRowsAndClose
```
public final void writeRowsAndClose(java.util.Collection<java.lang.Object[]> allRows)
```
    Iterates over all records, writes them and closes the output. Note this method will not use the RowWriterProcessor. Use processRecordsAndClose(Object[]) for that.
    
    Parameters:
    
    allRows - the rows to be written to the output
  - writeStringRowsAndClose
```
public final void writeStringRowsAndClose(java.util.Collection<java.lang.String[]> allRows)
```
    Iterates over all records, writes them and closes the output. Note this method will not use the RowWriterProcessor. Use processRecordsAndClose(Iterable) for that.
    
    Parameters:
    
    allRows - the rows to be written to the output
  - writeRecordsAndClose
```
public final void writeRecordsAndClose(java.util.Collection<? extends Record> allRows)
```
    Iterates over all records, writes them and closes the output. Note this method will not use the RowWriterProcessor. Use processRecordsAndClose(Iterable) for that.
    
    Parameters:
    
    allRows - the rows to be written to the output
  - writeRowsAndClose
```
public final void writeRowsAndClose(java.lang.Object[][] allRows)
```
    Iterates over all records, writes them and closes the output. Note this method will not use the RowWriterProcessor. Use processRecordsAndClose(Object[]) for that.
    
    Parameters:
    
    allRows - the rows to be written to the output
  - writeRows
```
public final void writeRows(java.lang.Object[][] rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Object[]) for that.
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeRows
```
public final <C extends java.util.Collection<?>> void writeRows(java.lang.Iterable<C> rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Type Parameters:
    
    C - Collection of objects containing values of a row
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeStringRows
```
public final void writeStringRows(java.util.Collection<java.lang.String[]> rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeRecords
```
public final void writeRecords(java.util.Collection<? extends Record> rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeStringRows
```
public final <C extends java.util.Collection<?>> void writeStringRows(java.lang.Iterable<C> rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Type Parameters:
    
    C - Collection of objects containing values of a row
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeRows
```
public final void writeRows(java.util.Collection<java.lang.Object[]> rows)
```
    Iterates over all records and writes them to the output. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to the output
  - writeRow
```
public final void writeRow(java.util.Collection<?> row)
```
    Writes the data given for an individual record. The output will remain open for further writing. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to the output
  - writeRow
```
public final void writeRow(java.lang.String[] row)
```
    Writes the data given for an individual record. The output will remain open for further writing. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, the input will be just ignored. If CommonSettings.getSkipEmptyLines() is false, then an empty row will be written to the output (as specified by writeEmptyRow()). In case of any errors, a TextWritingException will be thrown and the Writer given in the constructor will be closed. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to the output
  - writeRecord
```
public final <T extends Record> void writeRecord(T row)
```
    Writes the data given for an individual record. The output will remain open for further writing. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, the input will be just ignored. If CommonSettings.getSkipEmptyLines() is false, then an empty row will be written to the output (as specified by writeEmptyRow()). In case of any errors, a TextWritingException will be thrown and the Writer given in the constructor will be closed. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to the output
  - writeRow
```
public final void writeRow(java.lang.Object... row)
```
    Writes the data given for an individual record. The output will remain open for further writing. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, the input will be just ignored. If CommonSettings.getSkipEmptyLines() is false, then an empty row will be written to the output (as specified by writeEmptyRow()). In case of any errors, a TextWritingException will be thrown and the Writer given in the constructor will be closed. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to the output
  - expand
```
protected java.lang.Object[] expand(java.lang.Object[] row,
                                    int length,
                                    java.lang.Integer h2)
```
  - writeRow
```
public final void writeRow(java.lang.String row)
```
    Writes a plain (potentially free-text) String as a line to the output. A newline will automatically written after the given contents, unless this is a FixedWidthWriter whose FixedWidthWriterSettings.getWriteLineSeparatorAfterRecord() evaluates to false. The newline character sequence will conform to what is specified in Format.getLineSeparator() The writer implementation has no control over the format of this content. The output will remain open for further writing.
    
    Parameters:
    
    row - the line to be written to the output
  - writeEmptyRow
```
public final void writeEmptyRow()
```
    Writes an empty line to the output, unless this is a FixedWidthWriter whose FixedWidthWriterSettings.getWriteLineSeparatorAfterRecord() evaluates to false. The newline character sequence will conform to what is specified in Format.getLineSeparator() The output will remain open for further writing.
  - commentRow
```
public final void commentRow(java.lang.String comment)
```
    Writes a comment row to the output. A newline will automatically written after the given contents, unless this is a FixedWidthWriter whose FixedWidthWriterSettings.getWriteLineSeparatorAfterRecord() evaluates to false. The newline character sequence will conform to what is specified in Format.getLineSeparator() The output will remain open for further writing.
    
    Parameters:
    
    comment - the contents to be written as a comment to the output
  - fillOutputRow
```
private <T> void fillOutputRow(T[] row)
```
    Used when fields were selected and the input rows have a different order than the output. This method fills the internal #outputRow array with the values provided by the user in the correct order.
    
    Parameters:
    
    row - user-provided data which has to be rearranged to the expected record sequence before writing to the output.
  - internalWriteRow
```
private void internalWriteRow()
```
    Writes the accumulated value of a record to the output, followed by a newline, and increases the record count. The newline character sequence will conform to what is specified in Format.getLineSeparator() The contents of rowAppender depend on the concrete implementation of processRow(Object[])
  - skipLeadingWhitespace
```
protected static int skipLeadingWhitespace(int whitespaceRangeStart,
                                           java.lang.String element)
```
    Identifies the starting character index of a value being written if leading whitespaces are to be discarded. Implementation note whitespaces are considered all characters where ch <= ' ' evaluates to true
    
    Parameters:
    
    whitespaceRangeStart - starting range after which characters will be considered whitespace
    
    element - the String to be scanned for leading whitespaces.
    
    Returns:
    
    the index of the first non-whitespace character in the given element.
  - flush
```
public final void flush()
```
    Flushes the Writer given in this class constructor. An IllegalStateException will be thrown in case of any errors, and the writer will be closed.
  - close
```
public final void close()
```
    Closes the Writer given in this class constructor. An IllegalStateException will be thrown in case of any errors.
  - throwExceptionAndClose
```
private TextWritingException throwExceptionAndClose(java.lang.String message)
```
    In case of any exceptions, a TextWritingException is thrown, and the output Writer is closed.
    
    Parameters:
    
    message - Description of the error
  - throwExceptionAndClose
```
private TextWritingException throwExceptionAndClose(java.lang.String message,
                                                    java.lang.Throwable cause)
```
    In case of any exceptions, a TextWritingException is thrown, and the output Writer is closed.
    
    Parameters:
    
    message - Description of the error
    
    cause - the exception to be wrapped by a TextWritingException
  - throwExceptionAndClose
```
private TextWritingException throwExceptionAndClose(java.lang.String message,
                                                    java.lang.String recordCharacters,
                                                    java.lang.Throwable cause)
```
    In case of any exceptions, a TextWritingException is thrown, and the output Writer is closed.
    
    Parameters:
    
    message - Description of the error
    
    recordCharacters - characters used to write to the output at the time the exception happened
    
    cause - the exception to be wrapped by a TextWritingException
  - throwExceptionAndClose
```
private TextWritingException throwExceptionAndClose(java.lang.String message,
                                                    java.lang.Object[] recordValues,
                                                    java.lang.Throwable cause)
```
    In case of any exceptions, a TextWritingException is thrown, and the output Writer is closed.
    
    Parameters:
    
    message - Description of the error
    
    recordValues - values used to write to the output at the time the exception happened
    
    cause - the exception to be wrapped by a TextWritingException
  - getStringValue
```
protected java.lang.String getStringValue(java.lang.Object element)
```
    Converts a given object to its String representation for writing to a String
    - If the object is null, then nullValue is returned.
    - If the String representation of this object is an empty String, then emptyValue is returned
    Parameters:
    
    element - the object to be converted into a String.
    
    Returns:
    
    the String representation of the given object
  - addValues
```
public final void addValues(java.lang.Object... values)
```
    Writes a sequence of values to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    values - the values to be written
  - addStringValues
```
public final void addStringValues(java.util.Collection<java.lang.String> values)
```
    Writes a sequence of Strings to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    values - the values to be written
  - addValues
```
public final void addValues(java.util.Collection<?> values)
```
    Writes a sequence of values to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    values - the values to be written
  - addValue
```
public final void addValue(java.lang.Object value)
```
    Writes a value to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    value - the value to be written
  - fillPartialLineToMatchHeaders
```
private void fillPartialLineToMatchHeaders()
```
  - writeValuesToRow
```
public final void writeValuesToRow()
```
    Writes the contents accumulated in an internal in-memory row (using or #writeValue() to a new record in the output.
  - addValue
```
public final void addValue(int index,
                           java.lang.Object value)
```
    Writes a value to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    index - the position in the row that should receive the value.
    
    value - the value to be written
  - addValue
```
public final void addValue(java.lang.String headerName,
                           java.lang.Object value)
```
    Writes a value to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until writeValuesToRow() is called to flush all values accumulated and effectively write a new record to the output
    
    Parameters:
    
    headerName - the name of the column of the new row that should receive the value.
    
    value - the value to be written
  - addValue
```
private final void addValue(NormalizedString[] headersInContext,
                            NormalizedString headerName,
                            boolean ignoreOnMismatch,
                            java.lang.Object value)
```
  - getFieldIndex
```
private int getFieldIndex(NormalizedString[] headersInContext,
                          NormalizedString headerName,
                          boolean ignoreOnMismatch)
```
    Calculates the index of a header name in relation to the original headers array defined in this writer
    
    Parameters:
    
    headersInContext - headers currently in use (they might change).
    
    headerName - the name of the header whose position will be identified
    
    ignoreOnMismatch - flag indicating that if the header is not found, no exception is to be thrown, and -1 should be returned instead.
    
    Returns:
    
    the position of the given header, or -1 if it's not found when ignoreOnMismatch is set to true
  - discardValues
```
public final void discardValues()
```
    Discards the contents written to the internal in-memory row (using or #writeValue().
  - writeHeadersToString
```
public final java.lang.String writeHeadersToString()
```
    Writes the headers defined in CommonSettings.getHeaders() to a String
    
    Returns:
    
    a formatted String containing the headers defined in CommonSettings.getHeaders()
  - writeHeadersToString
```
public final java.lang.String writeHeadersToString(java.util.Collection<?> headers)
```
    Writes the given collection of headers to a String A TextWritingException will be thrown if no headers were defined.
    
    Parameters:
    
    headers - the headers to write to a String
    
    Returns:
    
    a formatted String containing the given headers
  - writeHeadersToString
```
public final java.lang.String writeHeadersToString(java.lang.String... headers)
```
    Writes the given collection of headers to a String A TextWritingException will be thrown if no headers were defined or if records were already written to a String
    
    Parameters:
    
    headers - the headers to write to a String
    
    Returns:
    
    a formatted String containing the given headers
  - processRecordsToString
```
public final java.util.List<java.lang.String> processRecordsToString(java.lang.Iterable<?> records)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them to a List of String. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    records - the records to be transformed by a RowWriterProcessor and then written to a List of String.
    
    Returns:
    
    a List containing the information transformed from the given records as formatted Strings
  - processRecordsToString
```
public final java.util.List<java.lang.String> processRecordsToString(java.lang.Object[] records)
```
    Iterates over all records, processes each one with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), and writes them them to a List of String. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    records - the records to transformed by a RowWriterProcessor and then written a String.
    
    Returns:
    
    a List containing the information transformed from the given records as formatted Strings
  - processRecordToString
```
public final java.lang.String processRecordToString(java.lang.Object... record)
```
    Processes the data given for an individual record with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes it to a String. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    record - the information of a single record to be transformed by a RowWriterProcessor and then written to a String.
    
    Returns:
    
    a formatted String containing the information transformed from the given record
  - processRecordToString
```
public final <T extends Record> java.lang.String processRecordToString(T record)
```
    Processes the data given for an individual record with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes it to a String. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    record - the information of a single record to be transformed by a RowWriterProcessor and then written to a String.
    
    Returns:
    
    a formatted String containing the information transformed from the given record
  - processRecordToString
```
public final java.lang.String processRecordToString(java.lang.Object record)
```
    Processes the data given for an individual record with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes it. The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    record - the information of a single record to be transformed by a RowWriterProcessor and then written to a String.
    
    Returns:
    
    a formatted String containing the information transformed from the given record
  - writeRowsToString
```
public final java.util.List<java.lang.String> writeRowsToString(java.lang.Object[][] rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Object[]) for that.
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeRowsToString
```
public final <C extends java.util.Collection<?>> java.util.List<java.lang.String> writeRowsToString(java.lang.Iterable<C> rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Type Parameters:
    
    C - Collection of objects containing values of a row
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeStringRowsToString
```
public final <C extends java.util.Collection<?>> java.util.List<java.lang.String> writeStringRowsToString(java.lang.Iterable<C> rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Type Parameters:
    
    C - Collection of objects containing values of a row
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeRowsToString
```
public final java.util.List<java.lang.String> writeRowsToString(java.util.Collection<java.lang.Object[]> rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeStringRowsToString
```
public final java.util.List<java.lang.String> writeStringRowsToString(java.util.Collection<java.lang.String[]> rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeRecordsToString
```
public final java.util.List<java.lang.String> writeRecordsToString(java.util.Collection<? extends Record> rows)
```
    Iterates over all records and writes them to a List of String. Note this method will not use the RowWriterProcessor. Use processRecords(Iterable) for that.
    
    Parameters:
    
    rows - the rows to be written to a List of String.
    
    Returns:
    
    a List containing the given rows as formatted Strings
  - writeRowToString
```
public final java.lang.String writeRowToString(java.util.Collection<?> row)
```
    Writes the data given for an individual record to a String. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to a String
    
    Returns:
    
    a formatted String containing the information of the given record
  - writeRowToString
```
public final java.lang.String writeRowToString(java.lang.String[] row)
```
    Writes the data given for an individual record to a String. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, null will be returned In case of any errors, a TextWritingException will be thrown. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to a String.
    
    Returns:
    
    a formatted String containing the information of the given record
  - writeRecordToString
```
public final <T extends Record> java.lang.String writeRecordToString(T row)
```
    Writes the data given for an individual record to a String. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, null will be returned In case of any errors, a TextWritingException will be thrown. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to a String.
    
    Returns:
    
    a formatted String containing the information of the given record
  - writeRowToString
```
public final java.lang.String writeRowToString(java.lang.Object... row)
```
    Writes the data given for an individual record to a String. If the given data is null or empty, and CommonSettings.getSkipEmptyLines() is true, null will be returned In case of any errors, a TextWritingException will be thrown. Note this method will not use the RowWriterProcessor. Use processRecord(Object) for that.
    
    Parameters:
    
    row - the information of a single record to be written to a String.
    
    Returns:
    
    a formatted String containing the information of the given record
  - adjustRowLength
```
private java.lang.Object[] adjustRowLength(java.lang.Object[] row)
```
  - commentRowToString
```
public final java.lang.String commentRowToString(java.lang.String comment)
```
    Writes a comment row to a String
    
    Parameters:
    
    comment - the contents to be written as a comment to a String.
    
    Returns:
    
    a formatted String containing the comment.
  - internalWriteRowToString
```
private java.lang.String internalWriteRowToString()
```
    Writes the accumulated value of a record to the output, followed by a newline, and increases the record count. The newline character sequence will conform to what is specified in Format.getLineSeparator() The contents of rowAppender depend on the concrete implementation of processRow(Object[])
    
    Returns:
    
    a formatted String containing the comment.
  - writeValuesToString
```
public final java.lang.String writeValuesToString()
```
    Writes the contents accumulated in an internal in-memory row (using or #addValue() as a String
    
    Returns:
    
    a formatted String containing the information accumulated in the internal in-memory row.
  - processValuesToRow
```
public final void processValuesToRow()
```
    Writes the contents accumulated in an internal in-memory row (using or #addValue() to a new record in the output. The objects added to this row will be processed with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(). The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
  - processValuesToString
```
public final java.lang.String processValuesToString()
```
    Writes the contents accumulated in an internal in-memory row (using or #addValue() to a String The objects added to this row will be processed with the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(). The output will remain open for further writing. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Returns:
    
    a formatted String containing the result produced by the RowWriterProcessor using the values accumulated in internal in-memory row.
  - getRecordCount
```
public final long getRecordCount()
```
    Returns the number of records written to the output so far
    
    Returns:
    
    the number of records written to the output so far
  - writeValuesFromMap
```
private <K> void writeValuesFromMap(java.util.Map<K,java.lang.String> headerMapping,
                                    java.util.Map<K,?> rowData)
```
    Writes values from an implementation of Map to a partial output record, ready to be written to the output. Values will be stored under a column identified by the headers. If no headers are defined, the keys of the map will be used to initialize an internal header row. A map of headers can be optionally provided to assign a name to the keys of the input map. This is useful when the input map has keys will generate unwanted header names.
    
    Type Parameters:
    
    K - type of the key in both rowData and headerMapping maps.
    
    Parameters:
    
    headerMapping - an optional map associating keys of the rowData map with expected header names
    
    rowData - the data to be written. Its keys will be used to form a header row in case no headers are available.
  - setHeadersFromMap
```
private void setHeadersFromMap(java.util.Map<?,?> map,
                               boolean keys)
```
    Iterates over the keys of a map and builds an internal header row.
    
    Parameters:
    
    map - the input map whose keys will be used to generate headers for the output.
    
    keys - indicates whether to take the map keys or values to build the header rows.
  - writeRowToString
```
public final java.lang.String writeRowToString(java.util.Map<?,?> rowData)
```
    Writes the values of a given map to a String formatted to according to the specified output format. Note this method will not use the RowWriterProcessor.
    
    Parameters:
    
    rowData - the map whose values will be used to generate a String.
    
    Returns:
    
    a String containing the given data as a formatted String
  - writeRow
```
public final void writeRow(java.util.Map<?,?> rowData)
```
    Writes the values of a given map into new output record Note this method will not use the RowWriterProcessor.
    
    Parameters:
    
    rowData - the map whose values will be used to generate a new record
  - writeRowToString
```
public final <K> java.lang.String writeRowToString(java.util.Map<K,java.lang.String> headerMapping,
                                                   java.util.Map<K,?> rowData)
```
    Writes the values of a given map to a String formatted to according to the specified output format. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a String.
    
    Returns:
    
    a String containing the given data as a formatted String
  - writeRow
```
public final <K> void writeRow(java.util.Map<K,java.lang.String> headerMapping,
                               java.util.Map<K,?> rowData)
```
    Writes the values of a given map into new output record Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a new record
  - writeRowsToString
```
public final <K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String> writeRowsToString(java.util.Map<K,I> rowData)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeRows
```
public final <K,I extends java.lang.Iterable<?>> void writeRows(java.util.Map<K,I> rowData)
```
    Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRowsToString
```
public final <K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String> writeRowsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                                                    java.util.Map<K,I> rowData)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeRows
```
public final <K,I extends java.lang.Iterable<?>> void writeRows(java.util.Map<K,java.lang.String> headerMapping,
                                                                java.util.Map<K,I> rowData)
```
    Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRows
```
private <K,I extends java.lang.Iterable<?>> void writeRows(java.util.Map<K,java.lang.String> headerMapping,
                                                           java.util.Map<K,I> rowData,
                                                           java.util.List<java.lang.String> outputList,
                                                           boolean useRowProcessor)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    outputList - an output List to fill with formatted Strings, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeStringRowsToString
```
public final <K> java.util.List<java.lang.String> writeStringRowsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                          java.util.Map<K,java.lang.String[]> rowData)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeRecordsToString
```
public final <K> java.util.List<java.lang.String> writeRecordsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                       java.util.Map<K,? extends Record> rowData)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeStringRows
```
public final <K> void writeStringRows(java.util.Map<K,java.lang.String> headerMapping,
                                      java.util.Map<K,java.lang.String[]> rowData)
```
    Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRecords
```
public final <K> void writeRecords(java.util.Map<K,java.lang.String> headerMapping,
                                   java.util.Map<K,? extends Record> rowData)
```
    Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeObjectRowsToString
```
public final <K> java.util.List<java.lang.String> writeObjectRowsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                          java.util.Map<K,java.lang.Object[]> rowData)
```
    Writes the values of a given map to a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - writeObjectRows
```
public final <K> void writeObjectRows(java.util.Map<K,java.lang.String> headerMapping,
                                      java.util.Map<K,java.lang.Object[]> rowData)
```
    Writes the values of a given map to multiple output records Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - wrapObjectArray
```
private <K> java.util.Map<K,java.lang.Iterable<java.lang.Object>> wrapObjectArray(java.util.Map<K,java.lang.Object[]> rowData)
```
  - wrapStringArray
```
private <K> java.util.Map<K,java.lang.Iterable<java.lang.String>> wrapStringArray(java.util.Map<K,java.lang.String[]> rowData)
```
  - wrapRecordValues
```
private <K> java.util.Map<K,java.lang.Iterable<java.lang.String>> wrapRecordValues(java.util.Map<K,? extends Record> rowData)
```
  - writeObjectRowsAndClose
```
public final <K> void writeObjectRowsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                              java.util.Map<K,java.lang.Object[]> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeStringRowsAndClose
```
public final <K> void writeStringRowsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                              java.util.Map<K,java.lang.String[]> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRecordsAndClose
```
public final <K> void writeRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                           java.util.Map<K,? extends Record> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeObjectRowsAndClose
```
public final <K> void writeObjectRowsAndClose(java.util.Map<K,java.lang.Object[]> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - writeStringRowsAndClose
```
public final <K> void writeStringRowsAndClose(java.util.Map<K,java.lang.String[]> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRecordsAndClose
```
public final <K> void writeRecordsAndClose(java.util.Map<K,? extends Record> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRowsAndClose
```
public final <K,I extends java.lang.Iterable<?>> void writeRowsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                                                        java.util.Map<K,I> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - writeRowsAndClose
```
public final <K,I extends java.lang.Iterable<?>> void writeRowsAndClose(java.util.Map<K,I> rowData)
```
    Writes the values of a given map to multiple output records and closes the output when finished. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. Note this method will not use the RowWriterProcessor.
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - processRecordToString
```
public final java.lang.String processRecordToString(java.util.Map<?,?> rowData)
```
    Processes the values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into String formatted according to the specified output format. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a String containing the given data as a formatted String
  - processRecord
```
public final void processRecord(java.util.Map<?,?> rowData)
```
    Processes the values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a new output record A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Parameters:
    
    rowData - the map whose values will be used to generate a List of String.
  - processRecordToString
```
public final <K> java.lang.String processRecordToString(java.util.Map<K,java.lang.String> headerMapping,
                                                        java.util.Map<K,?> rowData)
```
    Processes the values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into String formatted according to the specified output format. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a String containing the given data as a formatted String
  - processRecord
```
public final <K> void processRecord(java.util.Map<K,java.lang.String> headerMapping,
                                    java.util.Map<K,?> rowData)
```
    Processes the values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a new output record A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
  - processRecordsToString
```
public final <K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String> processRecordsToString(java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - processRecords
```
public final <K,I extends java.lang.Iterable<?>> void processRecords(java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output . The output will remain open for further write operations. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - processRecordsToString
```
public final <K,I extends java.lang.Iterable<?>> java.util.List<java.lang.String> processRecordsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                                                         java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - processRecords
```
public final <K,I extends java.lang.Iterable<?>> void processRecords(java.util.Map<K,java.lang.String> headerMapping,
                                                                     java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output . The output will remain open for further write operations. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - processObjectRecordsToString
```
public final <K> java.util.List<java.lang.String> processObjectRecordsToString(java.util.Map<K,java.lang.Object[]> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - processObjectRecordsToString
```
public final <K> java.util.List<java.lang.String> processObjectRecordsToString(java.util.Map<K,java.lang.String> headerMapping,
                                                                               java.util.Map<K,java.lang.Object[]> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor() and writes the result into a List of String formatted to according to the specified output format. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a List of String.
    
    Returns:
    
    a List of formatted String, each String representing one successful iteration over at least one element of the iterators in the map.
  - processObjectRecords
```
public final <K> void processObjectRecords(java.util.Map<K,java.lang.String> headerMapping,
                                           java.util.Map<K,java.lang.Object[]> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output . The output will remain open for further write operations. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - processObjectRecordsAndClose
```
public final <K> void processObjectRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                                   java.util.Map<K,java.lang.Object[]> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output and closes the writer. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - processObjectRecordsAndClose
```
public final <K> void processObjectRecordsAndClose(java.util.Map<K,java.lang.Object[]> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output and closes the writer. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - processRecordsAndClose
```
public final <K,I extends java.lang.Iterable<?>> void processRecordsAndClose(java.util.Map<K,java.lang.String> headerMapping,
                                                                             java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output and closes the writer. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    headerMapping - a mapping associating the keys of the input map to their corresponding header names.
    
    rowData - the map whose values will be used to generate a number of output records
  - processRecordsAndClose
```
public final <K,I extends java.lang.Iterable<?>> void processRecordsAndClose(java.util.Map<K,I> rowData)
```
    Processes the data in all values of a map using the RowWriterProcessor provided by CommonWriterSettings.getRowWriterProcessor(), then writes all values to the output and closes the writer. Each value is expected to be iterable and the result of this method will produce the number of records equal to the longest iterable. A new record will be created each time at least one Iterator.hasNext() returns true. Null will be written when a iterator has been fully read. A TextWritingException will be thrown if no RowWriterProcessor is provided by CommonWriterSettings.getRowWriterProcessor().
    
    Type Parameters:
    
    K - the key type
    
    I - the iterable type
    
    Parameters:
    
    rowData - the map whose values will be used to generate a number of output records
  - getContent
```
private java.lang.Object[] getContent(java.lang.Object[] tmp)
```
  - getContent
```
private java.lang.String getContent(java.lang.CharSequence tmp)
```
  - allowTrim
```
protected final boolean allowTrim(int fieldIndex)
```
    Checks whether the writer can remove trailing/leading whitespaces from a value being written. Applies to headers where names can be conflicting if trimmed for example ' a ' and 'a' will become the same value if the spaces are removed)
    
    Parameters:
    
    fieldIndex - index of the field to be written.
    
    Returns:
    
    true if the value being written is not a header name, or it is a header name that won't conflict with another header if its surrounding whitespaces are trimmed.

Class AbstractWriter<S extends CommonWriterSettings<?>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

writerProcessor

writer

skipEmptyLines

comment

rowAppender

isHeaderWritingEnabled

outputRow

indexesToWrite

lineSeparator

headers

recordCount

nullValue

emptyValue

appender

partialLine

partialLineIndex

headerIndexes

largestRowLength

writingHeaders

headerTrimFlags

dummyHeaderRow

expandRows

usingSwitch

enableNewlineAfterRecord

usingNullOrEmptyValue

whitespaceRangeStart

columnReorderingEnabled

ignoreLeading

ignoreTrailing

internalSettings

errorContentLength

Constructor Detail

AbstractWriter

AbstractWriter

AbstractWriter

AbstractWriter

AbstractWriter

AbstractWriter

AbstractWriter

AbstractWriter

Method Detail

enableNewlineAfterRecord

initialize

updateIndexesToWrite

updateFieldSelection

updateFieldSelection

updateFieldExclusion

updateFieldExclusion

submitRow

processRow

appendValueToRow

appendToRow

appendToRow

writeHeaders

writeHeaders

writeHeaders

processRecordsAndClose

processRecordsAndClose

processRecords

processRecords

processRecords

processRecord

processRecord

processRecord

getRowProcessorHeaders

writeRowsAndClose

writeRowsAndClose

writeStringRowsAndClose

writeRecordsAndClose

writeRowsAndClose

writeRows

writeRows

writeStringRows

writeRecords