nxs_stream.h

#ifndef NXS_HEADERS_STREAM
#define NXS_HEADERS_STREAM

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

/* TYPES */
typedef struct nxs_stream nxs_stream;

typedef union {
    fpos_t file;
    size_t memory;
} nxs_stream_pos;

/* PUBLIC FUNCTION PROTOTYPES */
static inline
nxs_stream *    nxs_stream_create                   (void);

nxs_stream *    nxs_stream_createFromConstMemory    (const void *mem, size_t length);

static inline
nxs_stream *    nxs_stream_createFromFile           (const char *path, const char *mode);

nxs_stream *    nxs_stream_createFromFP             (FILE *fp, bool shouldClose);

nxs_stream *    nxs_stream_createFromMemory         (      void *mem, size_t length, bool autorelease, bool shouldExpand);

static inline
nxs_stream *    nxs_stream_createFromNewMemory      (                 size_t length,                   bool shouldExpand);

void            nxs_stream_close                    (      nxs_stream *ptr);

size_t  nxs_stream_copy         (nxs_stream * restrict src, nxs_stream * restrict dst, size_t size);

size_t  nxs_stream_copy_full    (nxs_stream * restrict src, nxs_stream * restrict dst);

bool    nxs_stream_eof          (const nxs_stream *ptr);

bool    nxs_stream_flush        (      nxs_stream *ptr);

int     nxs_stream_getc         (      nxs_stream *ptr);

char *  nxs_stream_gets         (      nxs_stream * restrict ptr,       char * restrict str, size_t size);

static inline
int     nxs_stream_printf       (      nxs_stream * restrict ptr, const char * restrict format, ...);

int     nxs_stream_putc         (      nxs_stream *ptr, int c);

bool    nxs_stream_puts         (      nxs_stream * restrict ptr, const char * restrict str);

size_t  nxs_stream_read         (      nxs_stream * restrict ptr,       void * restrict buffer, size_t size);

bool    nxs_stream_seek         (      nxs_stream * restrict ptr, const nxs_stream_pos * restrict pos);

bool    nxs_stream_seekEnd      (      nxs_stream *ptr);

bool    nxs_stream_seekStart    (      nxs_stream *ptr);

bool    nxs_stream_tell         (const nxs_stream * restrict ptr,       nxs_stream_pos * restrict pos);

int     nxs_stream_ungetc       (      nxs_stream *ptr, int c);

int     nxs_stream_vprintf      (      nxs_stream * restrict ptr, const char * restrict format, va_list arg);

size_t  nxs_stream_write        (      nxs_stream * restrict ptr, const void * restrict buffer, size_t size);

/* INLINE FUNCTION DEFINITIONS */
static inline
nxs_stream *    nxs_stream_create                   (void) {
    return nxs_stream_createFromMemory(NULL, 0, true, true);
}

static inline
nxs_stream *    nxs_stream_createFromFile           (const char *path, const char *mode) {
    assert(path != NULL);
    assert(mode != NULL);
    
    FILE *fp = fopen(path, mode);
    nxs_stream *ret = nxs_stream_createFromFP(fp, true);
    if (ret == NULL) {
        if (fp)
            fclose(fp);
        
        return NULL;
    }
    
    return ret;
}

static inline
nxs_stream *    nxs_stream_createFromNewMemory      (                 size_t length,                   bool shouldExpand) {
    assert(length > 0);

    void *mem = malloc(length);
    if (mem == NULL)
        return NULL;
    
    nxs_stream *ret = nxs_stream_createFromMemory(mem, length, true,
        shouldExpand);
    if (ret == NULL) {
        free(mem);
        return NULL;
    }
    
    return ret;
}

static inline
int     nxs_stream_printf       (      nxs_stream * restrict ptr, const char * restrict format, ...) {
    assert(ptr != NULL);
    assert(format != NULL);

    va_list args;
    
    va_start(args, format);
    int result = nxs_stream_vprintf(ptr, format, args);
    va_end(args);

    return result;
}

#endif

---