From dacbc5e9c22e9d56aea11ab412e2bb44e2af8279 Mon Sep 17 00:00:00 2001 From: Max Wash Date: Sun, 19 Oct 2025 11:03:09 +0100 Subject: [PATCH] ds: buffer: convert to new object system --- ds/buffer.c | 329 ++++++++++++++++++++++++------------ ds/buffer.h | 17 -- ds/include/blue/ds/buffer.h | 28 +-- 3 files changed, 236 insertions(+), 138 deletions(-) delete mode 100644 ds/buffer.h diff --git a/ds/buffer.c b/ds/buffer.c index eb39439..47583bf 100644 --- a/ds/buffer.c +++ b/ds/buffer.c @@ -1,77 +1,23 @@ -#include "buffer.h" - #include #include -#include #include #include -static void buffer_release(struct b_dsref *obj); +/*** PRIVATE DATA *************************************************************/ -static struct b_dsref_type buffer_type = { - .t_flags = B_DSREF_FUNDAMENTAL, - .t_id = B_DSREF_TYPE_BUFFER, - .t_name = "corelib::buffer", - .t_instance_size = sizeof(struct b_buffer), - .t_release = buffer_release, +struct b_buffer_p { + /* number of items in buffer */ + unsigned int buf_len; + /* maximum number of items that can currently be stored in array */ + unsigned int buf_cap; + /* the size of each individual item in the buffer */ + unsigned int buf_itemsz; + void *buf_data; }; -struct b_buffer *b_buffer_create(size_t item_sz) -{ - struct b_buffer *buffer - = (struct b_buffer *)b_dsref_type_instantiate(&buffer_type); - if (!buffer) { - return NULL; - } +/*** PRIVATE FUNCTIONS ********************************************************/ - buffer->buf_itemsz = item_sz; - - return buffer; -} - -struct b_buffer *b_buffer_create_from_bytes(const void *p, size_t len) -{ - struct b_buffer *buffer = b_buffer_create(1); - if (!buffer) { - return NULL; - } - - buffer->buf_len = len; - buffer->buf_cap = len; - buffer->buf_itemsz = 1; - buffer->buf_data = calloc(len, 1); - if (!buffer->buf_data) { - b_buffer_release(buffer); - return NULL; - } - - memcpy(buffer->buf_data, p, len); - - return buffer; -} - -struct b_buffer *b_buffer_create_from_array(const void *p, size_t item_sz, size_t len) -{ - struct b_buffer *buffer = b_buffer_create(1); - if (!buffer) { - return NULL; - } - - buffer->buf_len = len; - buffer->buf_cap = len; - buffer->buf_itemsz = item_sz; - buffer->buf_data = calloc(len, item_sz); - if (!buffer->buf_data) { - b_buffer_release(buffer); - return NULL; - } - - memcpy(buffer->buf_data, p, len * item_sz); - - return buffer; -} - -static b_status resize_buffer(struct b_buffer *buffer, size_t new_capacity) +static b_status resize_buffer(struct b_buffer_p *buffer, size_t new_capacity) { if (buffer->buf_cap < new_capacity) { void *new_data = realloc( @@ -99,7 +45,7 @@ static b_status resize_buffer(struct b_buffer *buffer, size_t new_capacity) return B_SUCCESS; } -void *b_buffer_steal(struct b_buffer *buf) +static void *buffer_steal(struct b_buffer_p *buf) { void *p = buf->buf_data; @@ -110,7 +56,7 @@ void *b_buffer_steal(struct b_buffer *buf) return p; } -enum b_status b_buffer_reserve(struct b_buffer *buf, size_t capacity) +static enum b_status buffer_reserve(struct b_buffer_p *buf, size_t capacity) { if (buf->buf_cap >= capacity) { return B_SUCCESS; @@ -119,7 +65,7 @@ enum b_status b_buffer_reserve(struct b_buffer *buf, size_t capacity) return resize_buffer(buf, capacity); } -enum b_status b_buffer_resize(struct b_buffer *buf, size_t length) +static enum b_status buffer_resize(struct b_buffer_p *buf, size_t length) { enum b_status status = resize_buffer(buf, length); @@ -131,18 +77,8 @@ enum b_status b_buffer_resize(struct b_buffer *buf, size_t length) return B_SUCCESS; } -enum b_status b_buffer_append(struct b_buffer *buffer, const void *p, size_t count) -{ - return b_buffer_insert(buffer, p, count, B_NPOS); -} - -enum b_status b_buffer_prepend(struct b_buffer *buffer, const void *p, size_t count) -{ - return b_buffer_insert(buffer, p, count, 0); -} - -enum b_status b_buffer_insert( - struct b_buffer *buffer, const void *p, size_t count, size_t at) +static enum b_status buffer_insert( + struct b_buffer_p *buffer, const void *p, size_t count, size_t at) { if (at == B_NPOS) { at = buffer->buf_len; @@ -174,7 +110,7 @@ enum b_status b_buffer_insert( return B_SUCCESS; } -enum b_status b_buffer_remove(struct b_buffer *buffer, size_t at, size_t count) +static enum b_status buffer_remove(struct b_buffer_p *buffer, size_t at, size_t count) { if (at >= buffer->buf_len) { return B_ERR_OUT_OF_BOUNDS; @@ -195,12 +131,12 @@ enum b_status b_buffer_remove(struct b_buffer *buffer, size_t at, size_t count) return B_SUCCESS; } -void *b_buffer_ptr(const struct b_buffer *buffer) +static void *buffer_ptr(const struct b_buffer_p *buffer) { return buffer->buf_data; } -void *b_buffer_get(const struct b_buffer *buffer, size_t at) +static void *buffer_get(const struct b_buffer_p *buffer, size_t at) { if (at >= buffer->buf_len) { return NULL; @@ -209,33 +145,24 @@ void *b_buffer_get(const struct b_buffer *buffer, size_t at) return (unsigned char *)buffer->buf_data + (at * buffer->buf_itemsz); } -size_t b_buffer_size(const struct b_buffer *buffer) +static size_t buffer_size(const struct b_buffer_p *buffer) { return buffer->buf_len; } -size_t b_buffer_capacity(const struct b_buffer *buffer) +static size_t buffer_capacity(const struct b_buffer_p *buffer) { return buffer->buf_cap; } -void buffer_release(struct b_dsref *obj) -{ - struct b_buffer *buffer = B_BUFFER(obj); - - if (buffer->buf_data) { - free(buffer->buf_data); - buffer->buf_data = NULL; - } -} - -enum b_status b_buffer_clear(struct b_buffer *buffer) +static enum b_status buffer_clear(struct b_buffer_p *buffer) { buffer->buf_len = 0; return B_SUCCESS; } -enum b_status b_buffer_push_back(struct b_buffer *buf, size_t count, void **p) +static enum b_status buffer_push_back( + struct b_buffer_p *buf, size_t count, void **p) { enum b_status status = B_SUCCESS; @@ -248,12 +175,13 @@ enum b_status b_buffer_push_back(struct b_buffer *buf, size_t count, void **p) } buf->buf_len += count; - *p = b_buffer_get(buf, buf->buf_len - count); + *p = buffer_get(buf, buf->buf_len - count); return B_SUCCESS; } -enum b_status b_buffer_push_front(struct b_buffer *buf, size_t count, void **p) +static enum b_status buffer_push_front( + struct b_buffer_p *buf, size_t count, void **p) { enum b_status status = B_SUCCESS; @@ -272,12 +200,12 @@ enum b_status b_buffer_push_front(struct b_buffer *buf, size_t count, void **p) memmove(dest, src, len); buf->buf_len += count; - *p = b_buffer_get(buf, 0); + *p = buffer_get(buf, 0); return B_SUCCESS; } -enum b_status b_buffer_pop_back(struct b_buffer *buf, size_t count) +static enum b_status buffer_pop_back(struct b_buffer_p *buf, size_t count) { if (count > buf->buf_len) { return B_ERR_OUT_OF_BOUNDS; @@ -288,7 +216,7 @@ enum b_status b_buffer_pop_back(struct b_buffer *buf, size_t count) return B_SUCCESS; } -enum b_status b_buffer_pop_front(struct b_buffer *buf, size_t count) +static enum b_status buffer_pop_front(struct b_buffer_p *buf, size_t count) { if (count > buf->buf_len) { return B_ERR_OUT_OF_BOUNDS; @@ -304,22 +232,209 @@ enum b_status b_buffer_pop_front(struct b_buffer *buf, size_t count) return B_SUCCESS; } -size_t b_buffer_get_size(const struct b_buffer *buf) +static size_t buffer_get_size(const struct b_buffer_p *buf) { return buf->buf_len; } -size_t b_buffer_get_item_size(const struct b_buffer *buf) +static size_t buffer_get_item_size(const struct b_buffer_p *buf) { return buf->buf_itemsz; } -size_t b_buffer_get_capacity(const struct b_buffer *buf) +static size_t buffer_get_capacity(const struct b_buffer_p *buf) { return buf->buf_cap; } -b_dsref_type_id b_buffer_type_id(void) +/*** PUBLIC FUNCTIONS *********************************************************/ + +b_buffer *b_buffer_create(size_t item_sz) { - return (b_dsref_type_id)&buffer_type; + b_buffer *buffer = b_object_create(B_TYPE_BUFFER); + if (!buffer) { + return NULL; + } + + struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER); + + p->buf_itemsz = item_sz; + + return buffer; } + +b_buffer *b_buffer_create_from_bytes(const void *buf, size_t len) +{ + b_buffer *buffer = b_object_create(B_TYPE_BUFFER); + if (!buffer) { + return NULL; + } + + struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER); + + p->buf_len = len; + p->buf_cap = len; + p->buf_itemsz = 1; + p->buf_data = calloc(len, 1); + if (!p->buf_data) { + b_buffer_unref(buffer); + return NULL; + } + + memcpy(p->buf_data, buf, len); + + return buffer; +} + +b_buffer *b_buffer_create_from_array(const void *buf, size_t item_sz, size_t len) +{ + b_buffer *buffer = b_object_create(B_TYPE_BUFFER); + if (!buffer) { + return NULL; + } + + struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER); + + p->buf_len = len; + p->buf_cap = len; + p->buf_itemsz = item_sz; + p->buf_data = calloc(len, item_sz); + if (!p->buf_data) { + b_buffer_unref(buffer); + return NULL; + } + + memcpy(p->buf_data, buf, len * item_sz); + + return buffer; +} + +void *b_buffer_steal(b_buffer *buf) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_steal, buf); +} + +enum b_status b_buffer_reserve(b_buffer *buf, size_t capacity) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_reserve, buf, capacity); +} + +enum b_status b_buffer_resize(b_buffer *buf, size_t length) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_resize, buf, length); +} + +enum b_status b_buffer_insert( + b_buffer *buffer, const void *p, size_t count, size_t at) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_insert, buffer, p, count, at); +} + +enum b_status b_buffer_remove(b_buffer *buffer, size_t at, size_t count) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_remove, buffer, at, count); +} + +void *b_buffer_ptr(const b_buffer *buffer) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_ptr, buffer); +} + +void *b_buffer_get(const b_buffer *buffer, size_t at) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_get, buffer, at); +} + +size_t b_buffer_size(const b_buffer *buffer) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_size, buffer); +} + +size_t b_buffer_capacity(const b_buffer *buffer) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_capacity, buffer); +} + +enum b_status b_buffer_clear(b_buffer *buffer) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_clear, buffer); +} + +enum b_status b_buffer_push_back(b_buffer *buf, size_t count, void **p) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_push_back, buf, count, p); +} + +enum b_status b_buffer_push_front(b_buffer *buf, size_t count, void **p) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_push_front, buf, count, p); +} + +enum b_status b_buffer_pop_back(b_buffer *buf, size_t count) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_pop_back, buf, count); +} + +enum b_status b_buffer_pop_front(b_buffer *buf, size_t count) +{ + B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_pop_front, buf, count); +} + +size_t b_buffer_get_size(const b_buffer *buf) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_size, buf); +} + +size_t b_buffer_get_item_size(const b_buffer *buf) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_item_size, buf); +} + +size_t b_buffer_get_capacity(const b_buffer *buf) +{ + B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_capacity, buf); +} + +/*** PUBLIC ALIAS FUNCTIONS ***************************************************/ + +enum b_status b_buffer_append(b_buffer *buffer, const void *p, size_t count) +{ + return b_buffer_insert(buffer, p, count, B_NPOS); +} + +enum b_status b_buffer_prepend(b_buffer *buffer, const void *p, size_t count) +{ + return b_buffer_insert(buffer, p, count, 0); +} + +/*** VIRTUAL FUNCTIONS ********************************************************/ + +void buffer_init(b_object *obj, void *priv) +{ + struct b_buffer_p *buffer = priv; +} + +void buffer_fini(b_object *obj, void *priv) +{ + struct b_buffer_p *buffer = priv; + + if (buffer->buf_data) { + free(buffer->buf_data); + buffer->buf_data = NULL; + } +} + +/*** CLASS DEFINITION *********************************************************/ + +B_TYPE_CLASS_DEFINITION_BEGIN(b_buffer) + B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT) + B_INTERFACE_ENTRY(to_string) = NULL; + B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT) +B_TYPE_CLASS_DEFINITION_END(b_buffer) + +B_TYPE_DEFINITION_BEGIN(b_buffer) + B_TYPE_ID(0x323e6858, 0x7a43, 0x4484, 0xa6fb, 0xe3d1e47ae637); + B_TYPE_CLASS(b_buffer_class); + B_TYPE_INSTANCE_INIT(buffer_init); + B_TYPE_INSTANCE_INIT(buffer_fini); +B_TYPE_DEFINITION_END(b_buffer) diff --git a/ds/buffer.h b/ds/buffer.h deleted file mode 100644 index 223bbd8..0000000 --- a/ds/buffer.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef _BLUELIB_BUFFER_H_ -#define _BLUELIB_BUFFER_H_ - -#include "../object.h" - -struct b_buffer { - struct b_dsref buf_base; - /* number of items in buffer */ - unsigned int buf_len; - /* maximum number of items that can currently be stored in array */ - unsigned int buf_cap; - /* the size of each individual item in the buffer */ - unsigned int buf_itemsz; - void *buf_data; -}; - -#endif diff --git a/ds/include/blue/ds/buffer.h b/ds/include/blue/ds/buffer.h index f424e95..9885ad1 100644 --- a/ds/include/blue/ds/buffer.h +++ b/ds/include/blue/ds/buffer.h @@ -1,27 +1,25 @@ -#ifndef BLUELIB_BUFFER_H_ -#define BLUELIB_BUFFER_H_ +#ifndef BLUE_DS_BUFFER_H_ +#define BLUE_DS_BUFFER_H_ -#include -#include +#include #include -#define B_BUFFER(p) ((b_buffer *)(p)) +B_DECLS_BEGIN; -typedef struct b_buffer b_buffer; +#define B_TYPE_BUFFER (b_buffer_get_type()) + +B_DECLARE_TYPE(b_buffer); + +B_TYPE_CLASS_DECLARATION_BEGIN(b_buffer) +B_TYPE_CLASS_DECLARATION_END(b_buffer) + +BLUE_API b_type b_buffer_get_type(void); BLUE_API b_buffer *b_buffer_create(size_t item_sz); BLUE_API b_buffer *b_buffer_create_from_bytes(const void *p, size_t len); BLUE_API b_buffer *b_buffer_create_from_array( const void *p, size_t item_sz, size_t len); -static inline b_buffer *b_buffer_retain(b_buffer *buf) -{ - return B_BUFFER(b_retain(B_DSREF(buf))); -} -static inline void b_buffer_release(b_buffer *buf) -{ - b_release(B_DSREF(buf)); -} BLUE_API void *b_buffer_steal(b_buffer *buf); BLUE_API b_status b_buffer_reserve(b_buffer *buf, size_t capacity); BLUE_API b_status b_buffer_resize(b_buffer *buf, size_t length); @@ -46,4 +44,6 @@ BLUE_API size_t b_buffer_get_capacity(const b_buffer *buf); BLUE_API void *b_buffer_ptr(const b_buffer *buf); BLUE_API void *b_buffer_get(const b_buffer *buf, size_t at); +B_DECLS_END; + #endif