buffering.h

#ifndef BIO_BUFFERING_H
#define BIO_BUFFERING_H
 
#include "bio.h"
#include "file.h"
#include "net.h"
 
typedef union {
    bio_handle_t handle;  
    void* ptr;  
} bio_io_buffer_ctx_t;
 
typedef size_t (*bio_read_fn_t)(
    bio_io_buffer_ctx_t ctx,
    void* buf,
    size_t size,
    bio_error_t* error
);
 
typedef size_t (*bio_write_fn_t)(
    bio_io_buffer_ctx_t ctx,
    const void* buf,
    size_t size,
    bio_error_t* error
);
 
typedef bool (*bio_flush_fn_t)(
    bio_io_buffer_ctx_t ctx,
    bio_error_t* error
);
 
typedef struct {
    bio_io_buffer_ctx_t ctx;
    bio_read_fn_t read_fn;
    bio_write_fn_t write_fn;
    bio_flush_fn_t flush_fn;
    size_t size;
} bio_buffer_options_t;
 
typedef struct {
    bio_handle_t handle;
} bio_io_buffer_t;
 
bio_io_buffer_t
bio_make_buffer(const bio_buffer_options_t* options);
 
void
bio_destroy_buffer(bio_io_buffer_t buffer);
 
bio_io_buffer_t
bio_make_file_read_buffer(bio_file_t file, size_t size);
 
bio_io_buffer_t
bio_make_file_write_buffer(bio_file_t file, size_t size, bool fflush);
 
bio_io_buffer_t
bio_make_socket_read_buffer(bio_socket_t socket, size_t size);
 
bio_io_buffer_t
bio_make_socket_write_buffer(bio_socket_t socket, size_t size);
 
size_t
bio_buffered_read(
    bio_io_buffer_t buffer,
    void* in,
    size_t size,
    bio_error_t* error
);
 
size_t
bio_buffered_write(
    bio_io_buffer_t buffer,
    const void* out,
    size_t size,
    bio_error_t* error
);
 
bool
bio_flush_buffer(bio_io_buffer_t buffer, bio_error_t* error);
 
static inline size_t
bio_buffered_read_exactly(
    bio_io_buffer_t buffer,
    void* in,
    size_t size,
    bio_error_t* error
) {
    size_t total_bytes_read = 0;
    while (total_bytes_read < size) {
        size_t bytes_read = bio_buffered_read(
            buffer,
            (char*)in + total_bytes_read,
            size - total_bytes_read,
            error
        );
        if (bytes_read == 0) { break; }
        total_bytes_read += bytes_read;
    }
 
    return total_bytes_read;
}
 
static inline size_t
bio_buffered_write_exactly(
    bio_io_buffer_t buffer,
    const void* out,
    size_t size,
    bio_error_t* error
) {
    size_t total_bytes_written = 0;
    while (total_bytes_written < size) {
        size_t bytes_written = bio_buffered_write(
            buffer,
            (const char*)out + total_bytes_written,
            size - total_bytes_written,
            error
        );
        if (bytes_written == 0) { break; }
        total_bytes_written += bytes_written;
    }
 
    return total_bytes_written;
}
 
#endif