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

356
ds/array.c
View File

@@ -1,51 +1,51 @@
#include <blue/core/iterator.h>
#include <blue/core/stream.h>
#include <blue/ds/array.h>
#include <blue/ds/string.h>
#include <fx/core/iterator.h>
#include <fx/core/stream.h>
#include <fx/ds/array.h>
#include <fx/ds/string.h>
#include <stdlib.h>
#include <string.h>
/*** PRIVATE DATA *************************************************************/
struct b_array_p {
struct fx_array_p {
/* number of items in array */
size_t ar_len;
/* maximum number of items that can currently be stored in array */
size_t ar_cap;
b_object **ar_data;
fx_object **ar_data;
};
struct b_array_iterator_p {
b_array *_a;
struct b_array_p *_a_p;
struct fx_array_iterator_p {
fx_array *_a;
struct fx_array_p *_a_p;
/** The index of the current value */
size_t i;
/** The current value */
b_object *value;
fx_object *value;
};
/*** PRIVATE FUNCTIONS ********************************************************/
static b_status resize_array(struct b_array_p *array, size_t new_capacity)
static fx_status resize_array(struct fx_array_p *array, size_t new_capacity)
{
if (array->ar_cap < new_capacity) {
void *new_data = realloc(
array->ar_data, new_capacity * sizeof(struct b_dsref *));
array->ar_data, new_capacity * sizeof(struct fx_dsref *));
if (!new_data) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
array->ar_data = new_data;
} else {
for (size_t i = new_capacity; i < array->ar_len; i++) {
b_object_unref(array->ar_data[i]);
fx_object_unref(array->ar_data[i]);
}
void *new_data = realloc(
array->ar_data, new_capacity * sizeof(struct b_dsref *));
array->ar_data, new_capacity * sizeof(struct fx_dsref *));
if (!new_data) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
array->ar_data = new_data;
@@ -56,81 +56,81 @@ static b_status resize_array(struct b_array_p *array, size_t new_capacity)
array->ar_len = new_capacity;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static b_status array_insert(struct b_array_p *array, b_object *value, size_t at)
static fx_status array_insert(struct fx_array_p *array, fx_object *value, size_t at)
{
if (at == B_NPOS) {
if (at == FX_NPOS) {
at = array->ar_len;
}
if (at > array->ar_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
b_status status = B_SUCCESS;
fx_status status = FX_SUCCESS;
if (array->ar_len + 1 > array->ar_cap) {
status = resize_array(array, array->ar_cap + 8);
if (status != B_SUCCESS) {
if (status != FX_SUCCESS) {
return status;
}
}
b_object **src = array->ar_data + at;
b_object **dest = src + 1;
size_t move_len = (array->ar_len - at) * sizeof(struct b_dsref *);
fx_object **src = array->ar_data + at;
fx_object **dest = src + 1;
size_t move_len = (array->ar_len - at) * sizeof(struct fx_dsref *);
memmove(dest, src, move_len);
array->ar_data[at] = b_object_ref(value);
array->ar_data[at] = fx_object_ref(value);
array->ar_len++;
return B_SUCCESS;
return FX_SUCCESS;
}
static b_status array_remove(struct b_array_p *array, size_t at)
static fx_status array_remove(struct fx_array_p *array, size_t at)
{
if (at >= array->ar_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
b_object **src = array->ar_data + at;
b_object **dest = src + 1;
size_t move_len = array->ar_len * sizeof(struct b_dsref *);
fx_object **src = array->ar_data + at;
fx_object **dest = src + 1;
size_t move_len = array->ar_len * sizeof(struct fx_dsref *);
b_object_unref(array->ar_data[at]);
fx_object_unref(array->ar_data[at]);
memmove(dest, src, move_len);
array->ar_len--;
return B_SUCCESS;
return FX_SUCCESS;
}
static b_status array_remove_front(struct b_array_p *array)
static fx_status array_remove_front(struct fx_array_p *array)
{
return array_remove(array, 0);
}
static b_status array_remove_back(struct b_array_p *array)
static fx_status array_remove_back(struct fx_array_p *array)
{
return array_remove(array, array->ar_len - 1);
}
static b_object *array_pop(struct b_array_p *array, size_t at)
static fx_object *array_pop(struct fx_array_p *array, size_t at)
{
if (at >= array->ar_len) {
return NULL;
}
b_object **src = array->ar_data + at;
b_object **dest = src + 1;
size_t move_len = array->ar_len * sizeof(struct b_dsref *);
fx_object **src = array->ar_data + at;
fx_object **dest = src + 1;
size_t move_len = array->ar_len * sizeof(struct fx_dsref *);
b_object *out = array->ar_data[at];
fx_object *out = array->ar_data[at];
memmove(dest, src, move_len);
@@ -139,17 +139,17 @@ static b_object *array_pop(struct b_array_p *array, size_t at)
return out;
}
static b_object *array_pop_front(struct b_array_p *array)
static fx_object *array_pop_front(struct fx_array_p *array)
{
return array_pop(array, 0);
}
static b_object *array_pop_back(struct b_array_p *array)
static fx_object *array_pop_back(struct fx_array_p *array)
{
return array_pop(array, array->ar_len - 1);
}
static b_object *array_at(const struct b_array_p *array, size_t at)
static fx_object *array_at(const struct fx_array_p *array, size_t at)
{
if (at >= array->ar_len) {
return NULL;
@@ -158,49 +158,49 @@ static b_object *array_at(const struct b_array_p *array, size_t at)
return array->ar_data[at];
}
static b_object *array_get(struct b_array_p *array, size_t at)
static fx_object *array_get(struct fx_array_p *array, size_t at)
{
if (at >= array->ar_len) {
return NULL;
}
return b_object_ref(array->ar_data[at]);
return fx_object_ref(array->ar_data[at]);
}
static size_t array_size(const struct b_array_p *array)
static size_t array_size(const struct fx_array_p *array)
{
return array->ar_len;
}
static size_t array_capacity(const struct b_array_p *array)
static size_t array_capacity(const struct fx_array_p *array)
{
return array->ar_cap;
}
static void array_clear(struct b_array_p *array)
static void array_clear(struct fx_array_p *array)
{
if (!array->ar_len) {
return;
}
for (size_t i = 0; i < array->ar_len; i++) {
b_object_unref(array->ar_data[i]);
fx_object_unref(array->ar_data[i]);
}
memset(array->ar_data, 0x0, array->ar_cap * sizeof(b_object *));
memset(array->ar_data, 0x0, array->ar_cap * sizeof(fx_object *));
array->ar_len = 0;
}
/*** PUBLIC FUNCTIONS *********************************************************/
b_array *b_array_create_with_values(b_object *const *values, size_t nr_values)
fx_array *fx_array_create_with_values(fx_object *const *values, size_t nr_values)
{
b_array *array = b_array_create();
fx_array *array = fx_array_create();
if (!array) {
return NULL;
}
struct b_array_p *p = b_object_get_private(array, B_TYPE_ARRAY);
struct fx_array_p *p = fx_object_get_private(array, FX_TYPE_ARRAY);
size_t real_nr_values = 0;
for (size_t i = 0; i < nr_values; i++) {
@@ -211,106 +211,106 @@ b_array *b_array_create_with_values(b_object *const *values, size_t nr_values)
p->ar_len = real_nr_values;
p->ar_cap = real_nr_values;
p->ar_data = calloc(real_nr_values, sizeof(struct b_dsref *));
p->ar_data = calloc(real_nr_values, sizeof(struct fx_dsref *));
if (!p->ar_data) {
b_array_unref(array);
fx_array_unref(array);
return NULL;
}
size_t index = 0;
for (size_t i = 0; i < nr_values; i++) {
p->ar_data[index++] = b_object_ref(values[i]);
p->ar_data[index++] = fx_object_ref(values[i]);
}
return array;
}
b_status b_array_insert(b_array *array, b_object *value, size_t at)
fx_status fx_array_insert(fx_array *array, fx_object *value, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ARRAY, array_insert, array, value, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ARRAY, array_insert, array, value, at);
}
b_status b_array_remove(b_array *array, size_t at)
fx_status fx_array_remove(fx_array *array, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ARRAY, array_remove, array, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ARRAY, array_remove, array, at);
}
b_status b_array_remove_front(b_array *array)
fx_status fx_array_remove_front(fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_remove_front, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_remove_front, array);
}
b_status b_array_remove_back(b_array *array)
fx_status fx_array_remove_back(fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_remove_back, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_remove_back, array);
}
b_object *b_array_pop(b_array *array, size_t at)
fx_object *fx_array_pop(fx_array *array, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ARRAY, array_pop, array, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ARRAY, array_pop, array, at);
}
b_object *b_array_pop_front(b_array *array)
fx_object *fx_array_pop_front(fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_pop_front, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_pop_front, array);
}
b_object *b_array_pop_back(b_array *array)
fx_object *fx_array_pop_back(fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_pop_back, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_pop_back, array);
}
b_object *b_array_at(const b_array *array, size_t at)
fx_object *fx_array_at(const fx_array *array, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ARRAY, array_at, array, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ARRAY, array_at, array, at);
}
b_object *b_array_get(b_array *array, size_t at)
fx_object *fx_array_get(fx_array *array, size_t at)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ARRAY, array_get, array, at);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ARRAY, array_get, array, at);
}
size_t b_array_size(const b_array *array)
size_t fx_array_size(const fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_size, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_size, array);
}
size_t b_array_capacity(const b_array *array)
size_t fx_array_capacity(const fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_capacity, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_capacity, array);
}
void b_array_clear(b_array *array)
void fx_array_clear(fx_array *array)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ARRAY, array_clear, array);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ARRAY, array_clear, array);
}
/*** PUBLIC ALIAS FUNCTIONS ***************************************************/
b_status b_array_append(b_array *array, b_object *value)
fx_status fx_array_append(fx_array *array, fx_object *value)
{
return b_array_insert(array, value, B_NPOS);
return fx_array_insert(array, value, FX_NPOS);
}
b_status b_array_prepend(b_array *array, b_object *value)
fx_status fx_array_prepend(fx_array *array, fx_object *value)
{
return b_array_insert(array, value, 0);
return fx_array_insert(array, value, 0);
}
/*** VIRTUAL FUNCTIONS ********************************************************/
static void array_init(b_object *obj, void *priv)
static void array_init(fx_object *obj, void *priv)
{
struct b_array_p *array = priv;
struct fx_array_p *array = priv;
}
static void array_fini(b_object *obj, void *priv)
static void array_fini(fx_object *obj, void *priv)
{
struct b_array_p *array = priv;
struct fx_array_p *array = priv;
if (array->ar_data) {
for (size_t i = 0; i < array->ar_len; i++) {
b_object_unref(array->ar_data[i]);
fx_object_unref(array->ar_data[i]);
}
free(array->ar_data);
@@ -318,90 +318,90 @@ static void array_fini(b_object *obj, void *priv)
}
}
static void array_to_string(const b_object *obj, b_stream *out)
static void array_to_string(const fx_object *obj, fx_stream *out)
{
struct b_array_p *array = b_object_get_private(obj, B_TYPE_ARRAY);
struct fx_array_p *array = fx_object_get_private(obj, FX_TYPE_ARRAY);
if (!array->ar_len) {
b_stream_write_string(out, "[]", NULL);
fx_stream_write_string(out, "[]", NULL);
return;
}
b_stream_write_string(out, "[\n", NULL);
fx_stream_write_string(out, "[\n", NULL);
b_stream_push_indent(out, 1);
fx_stream_push_indent(out, 1);
size_t len = array_size(array);
for (size_t i = 0; i < array->ar_len; i++) {
b_object *value = array->ar_data[i];
bool is_string = b_object_is_type(value, B_TYPE_STRING);
fx_object *value = array->ar_data[i];
bool is_string = fx_object_is_type(value, FX_TYPE_STRING);
if (is_string) {
b_stream_write_char(out, '"');
fx_stream_write_char(out, '"');
}
b_object_to_string(value, out);
fx_object_to_string(value, out);
if (is_string) {
b_stream_write_char(out, '"');
fx_stream_write_char(out, '"');
}
if (i < len - 1) {
b_stream_write_string(out, ",", NULL);
fx_stream_write_string(out, ",", NULL);
}
b_stream_write_char(out, '\n');
fx_stream_write_char(out, '\n');
}
b_stream_pop_indent(out);
b_stream_write_char(out, ']');
fx_stream_pop_indent(out);
fx_stream_write_char(out, ']');
}
/*** ITERATOR FUNCTIONS *******************************************************/
static b_iterator *iterable_begin(b_object *obj)
static fx_iterator *iterable_begin(fx_object *obj)
{
b_array_iterator *it_obj = b_object_create(B_TYPE_ARRAY_ITERATOR);
struct b_array_iterator_p *it
= b_object_get_private(it_obj, B_TYPE_ARRAY_ITERATOR);
fx_array_iterator *it_obj = fx_object_create(FX_TYPE_ARRAY_ITERATOR);
struct fx_array_iterator_p *it
= fx_object_get_private(it_obj, FX_TYPE_ARRAY_ITERATOR);
it->_a = obj;
it->_a_p = b_object_get_private(obj, B_TYPE_ARRAY);
it->_a_p = fx_object_get_private(obj, FX_TYPE_ARRAY);
it->i = 0;
if (it->_a_p->ar_len > 0) {
it->value = it->_a_p->ar_data[0];
} else {
b_iterator_set_status(it_obj, B_ERR_NO_DATA);
fx_iterator_set_status(it_obj, FX_ERR_NO_DATA);
it->value = NULL;
}
return it_obj;
}
static const b_iterator *iterable_cbegin(const b_object *obj)
static const fx_iterator *iterable_cbegin(const fx_object *obj)
{
b_array_iterator *it_obj = b_object_create(B_TYPE_ARRAY_ITERATOR);
struct b_array_iterator_p *it
= b_object_get_private(it_obj, B_TYPE_ARRAY_ITERATOR);
it->_a = (b_array *)obj;
it->_a_p = b_object_get_private(obj, B_TYPE_ARRAY);
fx_array_iterator *it_obj = fx_object_create(FX_TYPE_ARRAY_ITERATOR);
struct fx_array_iterator_p *it
= fx_object_get_private(it_obj, FX_TYPE_ARRAY_ITERATOR);
it->_a = (fx_array *)obj;
it->_a_p = fx_object_get_private(obj, FX_TYPE_ARRAY);
it->i = 0;
if (it->_a_p->ar_len > 0) {
it->value = it->_a_p->ar_data[0];
} else {
b_iterator_set_status(it_obj, B_ERR_NO_DATA);
fx_iterator_set_status(it_obj, FX_ERR_NO_DATA);
it->value = NULL;
}
return it_obj;
}
static enum b_status iterator_move_next(const b_iterator *obj)
static enum fx_status iterator_move_next(const fx_iterator *obj)
{
struct b_array_iterator_p *it
= b_object_get_private(obj, B_TYPE_ARRAY_ITERATOR);
struct b_array_p *array = it->_a_p;
struct fx_array_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_ARRAY_ITERATOR);
struct fx_array_p *array = it->_a_p;
if (it->value == NULL || it->i >= array->ar_len) {
return false;
@@ -415,21 +415,21 @@ static enum b_status iterator_move_next(const b_iterator *obj)
it->value = array->ar_data[it->i];
}
return (it->value != NULL) ? B_SUCCESS : B_ERR_NO_DATA;
return (it->value != NULL) ? FX_SUCCESS : FX_ERR_NO_DATA;
}
static enum b_status iterator_erase(b_iterator *obj)
static enum fx_status iterator_erase(fx_iterator *obj)
{
struct b_array_iterator_p *it
= b_object_get_private(obj, B_TYPE_ARRAY_ITERATOR);
struct b_array_p *array = it->_a_p;
struct fx_array_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_ARRAY_ITERATOR);
struct fx_array_p *array = it->_a_p;
if (it->i >= array->ar_len) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
if (array->ar_data[it->i] != it->value) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
array_remove(array, it->i);
@@ -440,30 +440,30 @@ static enum b_status iterator_erase(b_iterator *obj)
it->value = NULL;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static b_iterator_value iterator_get_value(b_iterator *obj)
static fx_iterator_value iterator_get_value(fx_iterator *obj)
{
struct b_array_iterator_p *it
= b_object_get_private(obj, B_TYPE_ARRAY_ITERATOR);
struct fx_array_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_ARRAY_ITERATOR);
return B_ITERATOR_VALUE_PTR(it->value);
return FX_ITERATOR_VALUE_PTR(it->value);
}
static const b_iterator_value iterator_get_cvalue(const b_iterator *obj)
static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
{
struct b_array_iterator_p *it
= b_object_get_private(obj, B_TYPE_ARRAY_ITERATOR);
struct fx_array_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_ARRAY_ITERATOR);
return B_ITERATOR_VALUE_CPTR(it->value);
return FX_ITERATOR_VALUE_CPTR(it->value);
}
static enum b_status iterator_is_valid(const b_iterator *obj)
static enum fx_status iterator_is_valid(const fx_iterator *obj)
{
struct b_array_iterator_p *it
= b_object_get_private(obj, B_TYPE_ARRAY_ITERATOR);
struct b_array_p *array = it->_a_p;
struct fx_array_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_ARRAY_ITERATOR);
struct fx_array_p *array = it->_a_p;
if (it->i >= array->ar_len) {
return false;
@@ -473,49 +473,49 @@ static enum b_status iterator_is_valid(const b_iterator *obj)
return false;
}
return (it->value != NULL) ? B_SUCCESS : B_ERR_NO_DATA;
return (it->value != NULL) ? FX_SUCCESS : FX_ERR_NO_DATA;
}
/*** CLASS DEFINITION *********************************************************/
// ---- b_array DEFINITION
B_TYPE_CLASS_DEFINITION_BEGIN(b_array)
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
B_INTERFACE_ENTRY(to_string) = array_to_string;
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
// ---- fx_array DEFINITION
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_array)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
FX_INTERFACE_ENTRY(to_string) = array_to_string;
FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
B_TYPE_CLASS_INTERFACE_BEGIN(b_iterable, B_TYPE_ITERABLE)
B_INTERFACE_ENTRY(it_begin) = iterable_begin;
B_INTERFACE_ENTRY(it_cbegin) = iterable_cbegin;
B_TYPE_CLASS_INTERFACE_END(b_iterable, B_TYPE_ITERABLE)
B_TYPE_CLASS_DEFINITION_END(b_array)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
FX_INTERFACE_ENTRY(it_begin) = iterable_begin;
FX_INTERFACE_ENTRY(it_cbegin) = iterable_cbegin;
FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
FX_TYPE_CLASS_DEFINITION_END(fx_array)
B_TYPE_DEFINITION_BEGIN(b_array)
B_TYPE_ID(0xe3c46da1, 0x5f37, 0x4e44, 0xb53b, 0xff5a6200191b);
B_TYPE_CLASS(b_array_class);
B_TYPE_IMPLEMENTS(B_TYPE_ITERABLE);
B_TYPE_INSTANCE_PRIVATE(struct b_array_p);
B_TYPE_INSTANCE_INIT(array_init);
B_TYPE_INSTANCE_FINI(array_fini);
B_TYPE_DEFINITION_END(b_array)
FX_TYPE_DEFINITION_BEGIN(fx_array)
FX_TYPE_ID(0xe3c46da1, 0x5f37, 0x4e44, 0xb53b, 0xff5a6200191b);
FX_TYPE_CLASS(fx_array_class);
FX_TYPE_IMPLEMENTS(FX_TYPE_ITERABLE);
FX_TYPE_INSTANCE_PRIVATE(struct fx_array_p);
FX_TYPE_INSTANCE_INIT(array_init);
FX_TYPE_INSTANCE_FINI(array_fini);
FX_TYPE_DEFINITION_END(fx_array)
// ---- b_array_iterator DEFINITION
B_TYPE_CLASS_DEFINITION_BEGIN(b_array_iterator)
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)
// ---- fx_array_iterator DEFINITION
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_array_iterator)
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)
B_TYPE_CLASS_INTERFACE_BEGIN(b_iterator, B_TYPE_ITERATOR)
B_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
B_INTERFACE_ENTRY(it_erase) = iterator_erase;
B_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
B_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
B_TYPE_CLASS_INTERFACE_END(b_iterator, B_TYPE_ITERATOR)
B_TYPE_CLASS_DEFINITION_END(b_array_iterator)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
FX_TYPE_CLASS_DEFINITION_END(fx_array_iterator)
B_TYPE_DEFINITION_BEGIN(b_array_iterator)
B_TYPE_ID(0xe5e9e8b8, 0x14cb, 0x4192, 0x8138, 0xf45238a2ae73);
B_TYPE_EXTENDS(B_TYPE_ITERATOR);
B_TYPE_CLASS(b_array_iterator_class);
B_TYPE_INSTANCE_PRIVATE(struct b_array_iterator_p);
B_TYPE_DEFINITION_END(b_array_iterator)
FX_TYPE_DEFINITION_BEGIN(fx_array_iterator)
FX_TYPE_ID(0xe5e9e8b8, 0x14cb, 0x4192, 0x8138, 0xf45238a2ae73);
FX_TYPE_EXTENDS(FX_TYPE_ITERATOR);
FX_TYPE_CLASS(fx_array_iterator_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_array_iterator_p);
FX_TYPE_DEFINITION_END(fx_array_iterator)