Make it possible to use a dynamic buffer with mpack writer about mpack HOT 2 CLOSED

#include "mpack/mpack.h"
#include "sds.h"

static void flush_mpack_writer_sds(mpack_writer_t* writer, const char* data, size_t length) {
    size_t current_length; // number of bytes already in the string
    const char* extra_data; // extra bytes to be copied to the string
    size_t extra_length; // number of extra bytes to be copied to the string

    if (data == writer->buffer) {
        if (mpack_writer_buffer_used(writer) == length) {
            // in the special case that we're flushing during teardown, we
            // don't want to grow; we want to do nothing at all.
            fprintf(stderr, "flushing teardown\n");
            return;
        }

        // the data to be flushed is already in our string. we don't actually
        // want to copy anything; just grow.
        fprintf(stderr, "flushing buffer\n");
        current_length = length;
        extra_data = NULL;
        extra_length = 0;

    } else {
        // the data to be flushed is coming from aside. it's not yet in our
        // string, so we'll need to grow the string, then copy it in.
        fprintf(stderr, "flushing extra data\n");
        current_length = mpack_writer_buffer_used(writer);
        extra_data = data;
        extra_length = length;
    }

    // calculate the new length of the string
    sds* s = (sds*)mpack_writer_context(writer);
    size_t new_length = sdslen(*s) * 2;
    if (new_length < current_length + extra_length)
        new_length = current_length + extra_length;

    // grow the string
    fprintf(stderr, "growing to %zi bytes\n", new_length);
    *s = sdsgrowzero(*s, new_length);

    // reset writer variables
    writer->buffer = *s;
    writer->position = *s + current_length;
    writer->end = *s + new_length;

    // append the extra data, if any
    if (extra_length > 0) {
        memcpy(writer->position, extra_data, extra_length);
        writer->position += extra_length;
    }
}

static void teardown_mpack_writer_sds(mpack_writer_t* writer) {
    sds* s = (sds*)mpack_writer_context(writer);

    if (mpack_writer_error(writer) != mpack_ok) {
        // free the string
        sdsfree(*s);
        *s = NULL;
    } else {
        // trim the string to the correct length
        size_t len = mpack_writer_buffer_used(writer);
        sdsrange(*s, 0, len);
        fprintf(stderr, "trimming to %zi bytes\n", len);
    }

    // clear writer variables for safety
    writer->buffer = NULL;
    writer->position = NULL;
    writer->end = NULL;
    writer->context = NULL;

}

static void init_mpack_writer_sds(mpack_writer_t* writer, sds* s) {
    *s = sdsempty();
    *s = sdsgrowzero(*s, MPACK_WRITER_MINIMUM_BUFFER_SIZE);
    mpack_writer_init(writer, *s, sdslen(*s));
    mpack_writer_set_context(writer, s);
    mpack_writer_set_flush(writer, flush_mpack_writer_sds);
    mpack_writer_set_teardown(writer, teardown_mpack_writer_sds);
}

int main(void) {
    sds s;
    mpack_writer_t writer;
    init_mpack_writer_sds(&writer, &s);

    mpack_start_map(&writer, 4);
        // the example on the msgpack homepage
        mpack_write_cstr(&writer, "compact");
        mpack_write_bool(&writer, true);
        mpack_write_cstr(&writer, "schema");
        mpack_write_uint(&writer, 0);
        // a big write to test writing extra data (mpack wants to bypass the buffer)
        mpack_write_cstr(&writer, "lipsum");
        mpack_write_cstr(&writer, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec tempor arcu. Suspendisse potenti. Aliquam sit amet tortor vehicula magna efficitur consequat molestie vitae eros. Proin molestie vel nunc at pharetra. Nulla dapibus nunc at pharetra vestibulum. Etiam elit elit, imperdiet nec neque et, auctor sagittis est. Ut sed tincidunt sapien, non malesuada ligula.");
        // lots more data to test growing again
        mpack_write_cstr(&writer, "array");
        mpack_start_array(&writer, 200);
            for (int i = 0; i < 200; ++i)
                mpack_write_int(&writer, i);
        mpack_finish_array(&writer);
    mpack_finish_map(&writer);

    mpack_error_t error = mpack_writer_destroy(&writer);
    if (error != mpack_ok) {
        fprintf(stderr, "error %i writing data!\n", error);
        // don't free the sds string; the writer freed it due to the error
        return EXIT_FAILURE;
    }

    // write the resulting data to a file, view it with e.g. msgpack2json -di out.mp
    FILE* file = fopen("out.mp", "wb");
    fwrite(s, 1, sdslen(s), file);
    fclose(file);

    sdsfree(s);
    return EXIT_SUCCESS;
}