wash/bluelib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ds: buffer: convert to new object system

Browse Source
This commit is contained in:
max 🍓
2025-10-19 11:03:09 +01:00
parent 0a9eb4a085
commit dacbc5e9c2
3 changed files with 236 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
ds/buffer.c
View File

@@ -1,77 +1,23 @@
#include "buffer.h"
#include <blue/core/iterator.h>
#include <blue/ds/buffer.h>
#include <blue/ds/type.h>
#include <stdlib.h>
#include <string.h>
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)

17
ds/buffer.h
View File

@@ -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

28
ds/include/blue/ds/buffer.h
View File

@@ -1,27 +1,25 @@
#ifndef BLUELIB_BUFFER_H_
#define BLUELIB_BUFFER_H_
#ifndef BLUE_DS_BUFFER_H_
#define BLUE_DS_BUFFER_H_
#include <blue/ds/object.h>
#include <blue/ds/type.h>
#include <blue/core/macros.h>
#include <stddef.h>
#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