Fixed size buffer Writer implementation for use with FastCSV

[javafanboy]

Not sure if anybody else have the same need as I had to write as much CSV data as will fit to a fixed size byte buffer - I needed this to create messages for various cloud services that have one or more size increments for sent message (and charge you the same irrespective of how much data you actually send up to that limit).

The design I went for was to create a custom "transactional" Writer implementation that uses a fixed size buffer supporting mark/restore (to remove the effect of some incomplete write operations).

Using it I, before each call to CsvWriter.writeRecord I perform a mark (very inexpensive) and then keep inserting record after record until the buffer is full (this throws an exception that CsvWriter will re-throw as UncheckedIoException) and I then performs a "reset", send the content of the buffer as it was before the failing call to writeRecord, rewind the writer and start writing more CSV data.

An example of how adding a CSV record to this special writer can look like this:

        for (;;) 
                   try {
                       transactionalWriter.mark();
                       writer.writeRecord();
                       break; // Write succeeded - break out of loop 
                   } catch (Exception e) {
                       // Remove any partial data written...
                       transactionalWriter.reset();
                       // Read the data buffered in the writer...
                       sendDataToCloudService(transactionalWriter.getBytes());
                       totalBytesRead += bytes.length;
                       // Rewind the writer to prepare it for more data...
                       transactionalWriter.rewind();
                       // Replace the CSV writer to clean up any partly written data
                       // (issue reported to the author).
                       writer = CsvWriter.builder().build(transactionalWriter);
                   }

I have observed an unexpected behavior of CsvWriter that when an exception is thrown by the underlying Writer keeps the data that failed to be written and outputs this with the next writeRecord call, in my case resulting in a duplicate, that I work-around by re-creating the CswWriter each time the exception is thrown (the buffer is full).

Assuming writeRecord always buffers all produced characters internally and only performs ONE call to the underlying Writer I could actually skip the use of mark/reset as the ByteBuffer will throw the exception before updating the data but I was not 100% sure of this and wanted a "future" proof solution that would also work with other data than that from FastCSV.

The code for this writer I created (that largely builds on standard JDK library classes like ByteBuffer and CharsetEncoder) is provided below under MIT License without any responsibility for its correctness, usability etc. - feel free to use it if you need it or if you spot any errors or improvement proposals please comment!

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.io.IOException;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.*;

public final class TransactionalByteBufferWriter extends Writer {
    /**
     * No matter what charset that is used, all encodings are done using the
     * CharsetEncoder class.
     */
    private final CharsetEncoder encoder;

    /**
     * The fixed size buffer is implemented as a ByteBuffer that out-of-the-box supports
     * needed features like mark/reset och rewind.
     */
    private final ByteBuffer byteBuffer;

    /**
     * In some situations, we do not only have a limit on how many bytes the data may occupy but also one of how many
     * chars it is allowed to occupy if turned into a string that may be lower. To accommodate this requirement, separate
     * char limit and counter is used (and the counter is also saved/restored when performing mark/reset). 
     */
    private final int maxChars;
    private int savedCharsCounter;
    private int charsCounter;

    public TransactionalByteBufferWriter(int bufferSize, int maxChars, Charset charset) {
        this.byteBuffer = ByteBuffer.allocate(bufferSize);
        this.maxChars = maxChars;
        this.charsCounter = this.savedCharsCounter = 0;
        this.encoder = charset.newEncoder();
        encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
    }

    public TransactionalByteBufferWriter(int resultSize, int maxChars){
        this(resultSize, maxChars, Charset.defaultCharset());
    }

    public TransactionalByteBufferWriter(int resultSize){
        this(resultSize, resultSize, Charset.defaultCharset());
    }

    /**
     * Save the state of the writer (except for the encoder that is assumed to
     * never hold any unprocessed characters).
     */
    public void mark(){
        byteBuffer.mark();
        savedCharsCounter = charsCounter;
    }

    /**
     * Restores the state of the writer as it was when "mark" was called.
     */
    public void reset(){
        flush();
        byteBuffer.reset();
        charsCounter = savedCharsCounter;
    }

    /**
     * @return The number of chars processed by the writer.
     */
    public int getCharsCounter() {
        return charsCounter;
    }

    /**
     * @return The number of bytes currently encoded and stored in the writer.
     */
    public int getBytesEncoded() {
        return byteBuffer.position();
    }

    public Charset getCharset() {
        return encoder.charset();
    }
    
    /**
     * Resets the writer, discarding all written data and removing the mark, making it ready for re-use.
     */
    public void rewind(){
        flush();
        byteBuffer.rewind();
        savedCharsCounter = charsCounter = 0;
    }

    @Override
    public void write(char @NotNull [] chars, int off, int len) throws IOException {
       if(charsCounter + len > maxChars || encoder.encode(CharBuffer.wrap(chars, off, len), byteBuffer, false).isOverflow())
           throw new IOException();
       charsCounter += len;
    }

    @Override
    public void write(int c) throws IOException {
        final char[] charValue = {(char) c};
        if(charsCounter + 1 > maxChars || encoder.encode(CharBuffer.wrap(charValue), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter++;
    }

    @Override
    public void write(char @NotNull [] chars) throws IOException {
        if(charsCounter + chars.length > maxChars || encoder.encode(CharBuffer.wrap(chars), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter += chars.length;
    }

    @Override
    public void write(@NotNull String str) throws IOException {
        if(charsCounter + str.length() > maxChars || encoder.encode(CharBuffer.wrap(str), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter += str.length();
    }

    @Override
    public void write(@NotNull String str, int off, int len) throws IOException {
        if(charsCounter + len > maxChars || encoder.encode(CharBuffer.wrap(str, off, off + len), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter += len;
    }

    @Override
    public Writer append(@Nullable CharSequence csq) throws IOException {
        if (csq == null) csq = "null";
        if(charsCounter + csq.length() > maxChars || encoder.encode(CharBuffer.wrap(csq), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter += csq.length();
        return this;
    }

    @Override
    public Writer append(@Nullable CharSequence csq, int start, int end) throws IOException {
        if (csq == null) csq = "null";
        if(charsCounter + (end - start + 1)  > maxChars || encoder.encode(CharBuffer.wrap(csq, start, end), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter += (end - start + 1);
        return this;
    }

    @Override
    public Writer append(char c) throws IOException {
        final char[] charValue = {c};
        if(charsCounter + 1 > maxChars || encoder.encode(CharBuffer.wrap(charValue), byteBuffer, false).isOverflow())
            throw new IOException();
        charsCounter++;
        return this;
    }

    private static final CharBuffer EMPTY_BUFFER = CharBuffer.allocate(0).asReadOnlyBuffer();

    /**
     * Flushes and resets the encoder.
     */
    @Override
    public void flush() {
        // Finish the correct flow of the encoder, first write an empty end-of-input byte buffer...
        encoder.encode(EMPTY_BUFFER, byteBuffer, true);
        // ... then flush the encoder ...
        encoder.flush(byteBuffer);
        // ... and finally rest it.
        encoder.reset();
    }

    /**
     * Same effect as a flush. To free writer resources, remove all references to the writer and
     * let it become garbage collected!
     */
    @Override
    public void close()  {
        flush();
    }

    /**
     * Resets the encoder and returns a read-only view backed by the byte buffer holding the data in the writer that
     * is flipped and ready to read. This method can be called multiple times, each time
     * returning a new view backed by the same data.
     * @return A read-only view of the data written to the writer.
     */
    public ByteBuffer getByteBuffer() {
        // Reset the encoder
        flush();
        // Return a flipped read-only view of the data.
        return byteBuffer.asReadOnlyBuffer().flip();
    }

    /**
     * Resets the encoder and creates a copy of the bytes written to the writer. This method can
     * be called multiple times, each time creating a new copy.
     * @return A copy of the bytes written to the writer.
     */
    public byte[] getBytes(){
        // Reset the encoder
        flush();
        // Create a read-only view of the byte buffer...
        final ByteBuffer readOnlyBuffer = byteBuffer.asReadOnlyBuffer();
        // ... and a result buffer sized to hold the data in the byte buffer...
        final byte[] result = new byte[readOnlyBuffer.position()];
        // ... and make a copy of the data...
        readOnlyBuffer.flip().get(result);
        // ... that is returned,
        return result;
    }
}

[osiegmar]

The mentioned issue is found at #115