ds: buffer: convert to new object system

ds/buffer.c

@@ -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 = {
+struct b_buffer_p {
-	.t_flags = B_DSREF_FUNDAMENTAL,
+	/* number of items in buffer */
-	.t_id = B_DSREF_TYPE_BUFFER,
+	unsigned int buf_len;
-	.t_name = "corelib::buffer",
+	/* maximum number of items that can currently be stored in array */
-	.t_instance_size = sizeof(struct b_buffer),
+	unsigned int buf_cap;
-	.t_release = buffer_release,
+	/* 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)
+/*** PRIVATE FUNCTIONS ********************************************************/
-{
-	struct b_buffer *buffer
-		= (struct b_buffer *)b_dsref_type_instantiate(&buffer_type);
-	if (!buffer) {
-		return NULL;
-	}
 
-	buffer->buf_itemsz = item_sz;
+static b_status resize_buffer(struct b_buffer_p *buffer, size_t new_capacity)
-
-	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)
 {
 	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)
+static enum b_status buffer_insert(
-{
+	struct b_buffer_p *buffer, const void *p, size_t count, size_t at)
-	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)
 {
 	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)
+static enum b_status buffer_clear(struct b_buffer_p *buffer)
-{
-	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)
 {
 	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)

ds/buffer.h

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

ds/include/blue/ds/buffer.h

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