Polymorphism in C                                                  December 2023

    The other day I was reading the MuPDF source. I noticed an interesting
    implementation of polymorphism, so I wrote the following code to
    demonstrate. Notice that, using this method, no struct may implement more
    than one interface.

    When you use a polymorphic interface, you can't reason about the performance
    implications of your function calls, as you do not know what the underlying
    implementation is. In addition, polymorphic support makes the implementation
    of a datastructure more complex. Polymorphism is only a good idea when the
    flexibility granted outweighs the performance and complexity cost.

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct writer;

typedef void (writer_put_char_fn)(struct writer *, char);
typedef void (writer_printf_fn)(struct writer *, const char *format, va_list args);
typedef void (writer_destroy_fn)(struct writer *);

struct writer {
    /* Shared attributes can be declared here. */
    writer_put_char_fn *put_char;
    writer_printf_fn *printf;
    writer_destroy_fn *destroy;
};

struct file_writer {
    struct writer super;
    FILE *file;
};

struct string_writer {
    struct writer super;
    long length, allocated;
    char *string;
};

void writer_put_char(struct writer *writer, char c);
void writer_printf(struct writer *writer, const char *format, ...);
void writer_destroy(struct writer *writer);
struct file_writer create_file_writer(const char *fname);
void file_writer_put_char(struct file_writer *writer, char c);
void file_writer_printf(struct file_writer *writer, const char *format, va_list args);
void file_writer_destroy(struct file_writer *writer);
struct string_writer create_string_writer(long allocate);
void string_writer_put_char(struct string_writer *writer, char c);
void string_writer_printf(struct string_writer *writer, const char *format, va_list args);
void string_writer_destroy(struct string_writer *writer);
void write_unix_time(struct writer *writer);

void
writer_put_char(struct writer *writer, char c)
{
    writer->put_char(writer, c);
}

void
writer_printf(struct writer *writer, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    writer->printf(writer, format, args);
    va_end(args);
}

void
writer_destroy(struct writer *writer)
{
    writer->destroy(writer);
}

struct file_writer
create_file_writer(const char *fname)
{
    struct file_writer writer;
    writer.super.put_char = (writer_put_char_fn *)file_writer_put_char;
    writer.super.printf = (writer_printf_fn *)file_writer_printf;
    writer.super.destroy = (writer_destroy_fn *)file_writer_destroy;
    writer.file = fopen(fname, "w");
    return writer;
}

void
file_writer_put_char(struct file_writer *writer, char c)
{
    fputc(c, writer->file);
}

void
file_writer_printf(struct file_writer *writer, const char *format, va_list args)
{
    fprintf(writer->file, format, args);
}

void
file_writer_destroy(struct file_writer *writer)
{
    fclose(writer->file);
}

struct string_writer
create_string_writer(long allocate)
{
    struct string_writer writer;
    writer.super.put_char = (writer_put_char_fn *)string_writer_put_char;
    writer.super.printf = (writer_printf_fn *)string_writer_printf;
    writer.super.destroy = (writer_destroy_fn *)string_writer_destroy;
    writer.length = 0;
    writer.allocated = allocate;
    writer.string = malloc(allocate);
    return writer;
}

void
string_writer_put_char(struct string_writer *writer, char c)
{
    if (writer->allocated == writer->length) {
        writer->allocated *= 2;
        writer->string = realloc(writer->string, writer->allocated);
    }
    writer->string[writer->length++] = c;
}

void
string_writer_printf(struct string_writer *writer, const char *format, va_list args)
{
    int len;
    len = vsnprintf(writer->string + writer->length,
            writer->allocated - writer->length, format, args);
    if (len >= writer->allocated - writer->length) {
        writer->allocated += len;
        writer->allocated *= 2;
        writer->string = realloc(writer->string, writer->allocated);
        vsprintf(writer->string + writer->length, format, args);
    }
    writer->length += len;
}

void
string_writer_destroy(struct string_writer *writer)
{
    free(writer->string);
}

void
write_unix_time(struct writer *writer)
{
    int t;
    t = (int)time(NULL);
    writer_printf(writer, "seconds since Epoch: %d\n", t);
}

int
main(int argc, char *argv[])
{
    struct file_writer file_writer;
    struct string_writer string_writer;
    file_writer = create_file_writer("time.txt");
    string_writer = create_string_writer(1024);

    write_unix_time((struct writer *)&file_writer);
    write_unix_time((struct writer *)&string_writer);

    printf("%s", string_writer.string);

    writer_destroy((struct writer *)&file_writer);
    writer_destroy((struct writer *)&string_writer);
}