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

meta: rename to fx

Browse Source
This commit is contained in:
max 🍓
2026-03-16 10:35:43 +00:00
parent 84df46489a
commit e9d0e323f0
233 changed files with 12875 additions and 12869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

234
ds/buffer.c
View File

@@ -1,11 +1,11 @@
#include <blue/core/iterator.h>
#include <blue/ds/buffer.h>
#include <fx/core/iterator.h>
#include <fx/ds/buffer.h>
#include <stdlib.h>
#include <string.h>
/*** PRIVATE DATA *************************************************************/
struct b_buffer_p {
struct fx_buffer_p {
/* number of items in buffer */
unsigned int buf_len;
/* maximum number of items that can currently be stored in array */
@@ -17,13 +17,13 @@ struct b_buffer_p {
/*** PRIVATE FUNCTIONS ********************************************************/
static b_status resize_buffer(struct b_buffer_p *buffer, size_t new_capacity)
static fx_status resize_buffer(struct fx_buffer_p *buffer, size_t new_capacity)
{
if (buffer->buf_cap < new_capacity) {
void *new_data = realloc(
buffer->buf_data, new_capacity * buffer->buf_itemsz);
if (!new_data) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
buffer->buf_data = new_data;
@@ -31,7 +31,7 @@ static b_status resize_buffer(struct b_buffer_p *buffer, size_t new_capacity)
void *new_data = realloc(
buffer->buf_data, new_capacity * buffer->buf_itemsz);
if (!new_data) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
buffer->buf_data = new_data;
@@ -42,10 +42,10 @@ static b_status resize_buffer(struct b_buffer_p *buffer, size_t new_capacity)
buffer->buf_len = new_capacity;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static void *buffer_steal(struct b_buffer_p *buf)
static void *buffer_steal(struct fx_buffer_p *buf)
{
void *p = buf->buf_data;
@@ -56,44 +56,44 @@ static void *buffer_steal(struct b_buffer_p *buf)
return p;
}
static enum b_status buffer_reserve(struct b_buffer_p *buf, size_t capacity)
static enum fx_status buffer_reserve(struct fx_buffer_p *buf, size_t capacity)
{
if (buf->buf_cap >= capacity) {
return B_SUCCESS;
return FX_SUCCESS;
}
return resize_buffer(buf, capacity);
}
static enum b_status buffer_resize(struct b_buffer_p *buf, size_t length)
static enum fx_status buffer_resize(struct fx_buffer_p *buf, size_t length)
{
enum b_status status = resize_buffer(buf, length);
enum fx_status status = resize_buffer(buf, length);
if (!B_OK(status)) {
if (!FX_OK(status)) {
return status;
}
buf->buf_len = length;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_insert(
struct b_buffer_p *buffer, const void *p, size_t count, size_t at)
static enum fx_status buffer_insert(
struct fx_buffer_p *buffer, const void *p, size_t count, size_t at)
{
if (at == B_NPOS) {
if (at == FX_NPOS) {
at = buffer->buf_len;
}
if (at > buffer->buf_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
b_status status = B_SUCCESS;
fx_status status = FX_SUCCESS;
if (buffer->buf_len + count > buffer->buf_cap) {
status = resize_buffer(buffer, buffer->buf_cap + count);
if (status != B_SUCCESS) {
if (status != FX_SUCCESS) {
return status;
}
}
@@ -107,13 +107,13 @@ static enum b_status buffer_insert(
memcpy(src, p, count * buffer->buf_itemsz);
buffer->buf_len += count;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_remove(struct b_buffer_p *buffer, size_t at, size_t count)
static enum fx_status buffer_remove(struct fx_buffer_p *buffer, size_t at, size_t count)
{
if (at >= buffer->buf_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
if (at + count >= buffer->buf_len) {
@@ -128,15 +128,15 @@ static enum b_status buffer_remove(struct b_buffer_p *buffer, size_t at, size_t
buffer->buf_len -= count;
return B_SUCCESS;
return FX_SUCCESS;
}
static void *buffer_ptr(const struct b_buffer_p *buffer)
static void *buffer_ptr(const struct fx_buffer_p *buffer)
{
return buffer->buf_data;
}
static void *buffer_get(const struct b_buffer_p *buffer, size_t at)
static void *buffer_get(const struct fx_buffer_p *buffer, size_t at)
{
if (at >= buffer->buf_len) {
return NULL;
@@ -145,56 +145,56 @@ static void *buffer_get(const struct b_buffer_p *buffer, size_t at)
return (unsigned char *)buffer->buf_data + (at * buffer->buf_itemsz);
}
static size_t buffer_size(const struct b_buffer_p *buffer)
static size_t buffer_size(const struct fx_buffer_p *buffer)
{
return buffer->buf_len;
}
static size_t buffer_capacity(const struct b_buffer_p *buffer)
static size_t buffer_capacity(const struct fx_buffer_p *buffer)
{
return buffer->buf_cap;
}
static enum b_status buffer_clear(struct b_buffer_p *buffer)
static enum fx_status buffer_clear(struct fx_buffer_p *buffer)
{
buffer->buf_len = 0;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_push_back(
struct b_buffer_p *buf, size_t count, void **p)
static enum fx_status buffer_push_back(
struct fx_buffer_p *buf, size_t count, void **p)
{
enum b_status status = B_SUCCESS;
enum fx_status status = FX_SUCCESS;
if (buf->buf_len + count > buf->buf_cap) {
status = resize_buffer(buf, buf->buf_len + count);
}
if (!B_OK(status)) {
if (!FX_OK(status)) {
return status;
}
buf->buf_len += count;
*p = buffer_get(buf, buf->buf_len - count);
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_push_front(
struct b_buffer_p *buf, size_t count, void **p)
static enum fx_status buffer_push_front(
struct fx_buffer_p *buf, size_t count, void **p)
{
enum b_status status = B_SUCCESS;
enum fx_status status = FX_SUCCESS;
if (buf->buf_len + count > buf->buf_cap) {
status = resize_buffer(buf, buf->buf_len + count);
}
if (!B_OK(status)) {
if (!FX_OK(status)) {
return status;
}
void *src = buf->buf_data;
void *dest = b_buffer_get(buf->buf_data, count);
void *dest = fx_buffer_get(buf->buf_data, count);
size_t len = count * buf->buf_itemsz;
memmove(dest, src, len);
@@ -202,82 +202,82 @@ static enum b_status buffer_push_front(
*p = buffer_get(buf, 0);
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_pop_back(struct b_buffer_p *buf, size_t count)
static enum fx_status buffer_pop_back(struct fx_buffer_p *buf, size_t count)
{
if (count > buf->buf_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
buf->buf_len -= count;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status buffer_pop_front(struct b_buffer_p *buf, size_t count)
static enum fx_status buffer_pop_front(struct fx_buffer_p *buf, size_t count)
{
if (count > buf->buf_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
void *src = b_buffer_get(buf->buf_data, count);
void *src = fx_buffer_get(buf->buf_data, count);
void *dest = buf->buf_data;
size_t len = (buf->buf_len - count) * buf->buf_itemsz;
memmove(dest, src, len);
buf->buf_len -= count;
return B_SUCCESS;
return FX_SUCCESS;
}
static size_t buffer_get_size(const struct b_buffer_p *buf)
static size_t buffer_get_size(const struct fx_buffer_p *buf)
{
return buf->buf_len;
}
static size_t buffer_get_item_size(const struct b_buffer_p *buf)
static size_t buffer_get_item_size(const struct fx_buffer_p *buf)
{
return buf->buf_itemsz;
}
static size_t buffer_get_capacity(const struct b_buffer_p *buf)
static size_t buffer_get_capacity(const struct fx_buffer_p *buf)
{
return buf->buf_cap;
}
/*** PUBLIC FUNCTIONS *********************************************************/
b_buffer *b_buffer_create(size_t item_sz)
fx_buffer *fx_buffer_create(size_t item_sz)
{
b_buffer *buffer = b_object_create(B_TYPE_BUFFER);
fx_buffer *buffer = fx_object_create(FX_TYPE_BUFFER);
if (!buffer) {
return NULL;
}
struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER);
struct fx_buffer_p *p = fx_object_get_private(buffer, FX_TYPE_BUFFER);
p->buf_itemsz = item_sz;
return buffer;
}
b_buffer *b_buffer_create_from_bytes(const void *buf, size_t len)
fx_buffer *fx_buffer_create_from_bytes(const void *buf, size_t len)
{
b_buffer *buffer = b_object_create(B_TYPE_BUFFER);
fx_buffer *buffer = fx_object_create(FX_TYPE_BUFFER);
if (!buffer) {
return NULL;
}
struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER);
struct fx_buffer_p *p = fx_object_get_private(buffer, FX_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);
fx_buffer_unref(buffer);
return NULL;
}
@@ -286,21 +286,21 @@ b_buffer *b_buffer_create_from_bytes(const void *buf, size_t len)
return buffer;
}
b_buffer *b_buffer_create_from_array(const void *buf, size_t item_sz, size_t len)
fx_buffer *fx_buffer_create_from_array(const void *buf, size_t item_sz, size_t len)
{
b_buffer *buffer = b_object_create(B_TYPE_BUFFER);
fx_buffer *buffer = fx_object_create(FX_TYPE_BUFFER);
if (!buffer) {
return NULL;
}
struct b_buffer_p *p = b_object_get_private(buffer, B_TYPE_BUFFER);
struct fx_buffer_p *p = fx_object_get_private(buffer, FX_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);
fx_buffer_unref(buffer);
return NULL;
}
@@ -309,114 +309,114 @@ b_buffer *b_buffer_create_from_array(const void *buf, size_t item_sz, size_t len
return buffer;
}
void *b_buffer_steal(b_buffer *buf)
void *fx_buffer_steal(fx_buffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_steal, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_steal, buf);
}
enum b_status b_buffer_reserve(b_buffer *buf, size_t capacity)
enum fx_status fx_buffer_reserve(fx_buffer *buf, size_t capacity)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_reserve, buf, capacity);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_reserve, buf, capacity);
}
enum b_status b_buffer_resize(b_buffer *buf, size_t length)
enum fx_status fx_buffer_resize(fx_buffer *buf, size_t length)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_resize, buf, length);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_resize, buf, length);
}
enum b_status b_buffer_insert(
b_buffer *buffer, const void *p, size_t count, size_t at)
enum fx_status fx_buffer_insert(
fx_buffer *buffer, const void *p, size_t count, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_insert, buffer, p, count, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_insert, buffer, p, count, at);
}
enum b_status b_buffer_remove(b_buffer *buffer, size_t at, size_t count)
enum fx_status fx_buffer_remove(fx_buffer *buffer, size_t at, size_t count)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_remove, buffer, at, count);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_remove, buffer, at, count);
}
void *b_buffer_ptr(const b_buffer *buffer)
void *fx_buffer_ptr(const fx_buffer *buffer)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_ptr, buffer);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_ptr, buffer);
}
void *b_buffer_get(const b_buffer *buffer, size_t at)
void *fx_buffer_get(const fx_buffer *buffer, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_get, buffer, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_get, buffer, at);
}
size_t b_buffer_size(const b_buffer *buffer)
size_t fx_buffer_size(const fx_buffer *buffer)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_size, buffer);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_size, buffer);
}
size_t b_buffer_capacity(const b_buffer *buffer)
size_t fx_buffer_capacity(const fx_buffer *buffer)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_capacity, buffer);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_capacity, buffer);
}
enum b_status b_buffer_clear(b_buffer *buffer)
enum fx_status fx_buffer_clear(fx_buffer *buffer)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_clear, buffer);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_clear, buffer);
}
enum b_status b_buffer_push_back(b_buffer *buf, size_t count, void **p)
enum fx_status fx_buffer_push_back(fx_buffer *buf, size_t count, void **p)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_push_back, buf, count, p);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_push_back, buf, count, p);
}
enum b_status b_buffer_push_front(b_buffer *buf, size_t count, void **p)
enum fx_status fx_buffer_push_front(fx_buffer *buf, size_t count, void **p)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_push_front, buf, count, p);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_push_front, buf, count, p);
}
enum b_status b_buffer_pop_back(b_buffer *buf, size_t count)
enum fx_status fx_buffer_pop_back(fx_buffer *buf, size_t count)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_pop_back, buf, count);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_pop_back, buf, count);
}
enum b_status b_buffer_pop_front(b_buffer *buf, size_t count)
enum fx_status fx_buffer_pop_front(fx_buffer *buf, size_t count)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_BUFFER, buffer_pop_front, buf, count);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_BUFFER, buffer_pop_front, buf, count);
}
size_t b_buffer_get_size(const b_buffer *buf)
size_t fx_buffer_get_size(const fx_buffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_size, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_get_size, buf);
}
size_t b_buffer_get_item_size(const b_buffer *buf)
size_t fx_buffer_get_item_size(const fx_buffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_item_size, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_get_item_size, buf);
}
size_t b_buffer_get_capacity(const b_buffer *buf)
size_t fx_buffer_get_capacity(const fx_buffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_BUFFER, buffer_get_capacity, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BUFFER, buffer_get_capacity, buf);
}
/*** PUBLIC ALIAS FUNCTIONS ***************************************************/
enum b_status b_buffer_append(b_buffer *buffer, const void *p, size_t count)
enum fx_status fx_buffer_append(fx_buffer *buffer, const void *p, size_t count)
{
return b_buffer_insert(buffer, p, count, B_NPOS);
return fx_buffer_insert(buffer, p, count, FX_NPOS);
}
enum b_status b_buffer_prepend(b_buffer *buffer, const void *p, size_t count)
enum fx_status fx_buffer_prepend(fx_buffer *buffer, const void *p, size_t count)
{
return b_buffer_insert(buffer, p, count, 0);
return fx_buffer_insert(buffer, p, count, 0);
}
/*** VIRTUAL FUNCTIONS ********************************************************/
void buffer_init(b_object *obj, void *priv)
void buffer_init(fx_object *obj, void *priv)
{
struct b_buffer_p *buffer = priv;
struct fx_buffer_p *buffer = priv;
}
void buffer_fini(b_object *obj, void *priv)
void buffer_fini(fx_object *obj, void *priv)
{
struct b_buffer_p *buffer = priv;
struct fx_buffer_p *buffer = priv;
if (buffer->buf_data) {
free(buffer->buf_data);
@@ -426,16 +426,16 @@ void buffer_fini(b_object *obj, void *priv)
/*** 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)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_buffer)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
FX_INTERFACE_ENTRY(to_string) = NULL;
FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
FX_TYPE_CLASS_DEFINITION_END(fx_buffer)
B_TYPE_DEFINITION_BEGIN(b_buffer)
B_TYPE_ID(0x323e6858, 0x7a43, 0x4484, 0xa6fb, 0xe3d1e47ae637);
B_TYPE_CLASS(b_buffer_class);
B_TYPE_INSTANCE_PRIVATE(struct b_buffer_p);
B_TYPE_INSTANCE_INIT(buffer_init);
B_TYPE_INSTANCE_FINI(buffer_fini);
B_TYPE_DEFINITION_END(b_buffer)
FX_TYPE_DEFINITION_BEGIN(fx_buffer)
FX_TYPE_ID(0x323e6858, 0x7a43, 0x4484, 0xa6fb, 0xe3d1e47ae637);
FX_TYPE_CLASS(fx_buffer_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_buffer_p);
FX_TYPE_INSTANCE_INIT(buffer_init);
FX_TYPE_INSTANCE_FINI(buffer_fini);
FX_TYPE_DEFINITION_END(fx_buffer)