SqType

SqType
│
└─── SqCommand    (define in sqxcsupport library)

struct SqType
{
	unsigned int   size;           // instance size

	SqTypeFunc     init;           // initialize instance
	SqTypeFunc     final;          // finalize instance

	SqTypeParseFunc   parse;       // parse Sqxc(SQL/JSON) data to instance
	SqTypeWriteFunc   write;       // write instance data to Sqxc(SQL/JSON)

	// In C++, you must use typeid(TypeName).name() to generate type name,
	// or use macro SQ_GET_TYPE_NAME()
	const char    *name;

	// SqType::entry is array of SqEntry pointer if current SqType is for C struct type.
	// SqType::entry isn't freed if SqType::n_entry == -1
	SqEntry      **entry;          // maps to SqPtrArray::data
	int            n_entry;        // maps to SqPtrArray::length
	// *** About above 2 fields:
	// 1. They are expanded by macro SQ_PTR_ARRAY_MEMBERS(SqEntry*, entry, n_entry)
	// 2. They can NOT change data type and order.

	// SqType::bit_field has SQB_TYPE_DYNAMIC if SqType is dynamic and freeable.
	// SqType::bit_field has SQB_TYPE_SORTED  if SqType::entry is sorted.
	unsigned int   bit_field;

	// SqType::on_destroy() is called when program releases SqType.
	// This is mainly used for deriving or customizing SqType.
	// Instance of SqType will be passed to SqType::on_destroy()
	SqDestroyFunc  on_destroy;     // destroy notifier for SqType. It can be NULL.
};

const SqType type_int = {
	.size  = sizeof(int),
	.init  = NULL,                  // initialize function
	.final = NULL,                  // finalize function
	.parse = int_parse_function,    // Function that parse data from Sqxc instance
	.write = int_write_function,    // Function that write data to   Sqxc instance
};

// prealloc_size : capacity of SqType::entry (SqType::entry is SqEntry pointer array).
// entry_destroy_func : DestroyFunc of SqType::entry's elements.

SqType  *sq_type_new(int prealloc_size, SqDestroyFunc entry_destroy_func);

	SqType *type;

	// 1. Create SqType with argument 'prealloc_size' = -1, 'entry_destroy_func' = NULL.

	/* C function */
	type = sq_type_new(-1, NULL);

	/* C++ method */
//	type = new Sq::Type(-1, NULL);

	// 2. Specify size, and the functions init, final, parse, and write in the SqType structure.
	type->size  = sizeof(int);
	type->init  = NULL;                  // initialize function
	type->final = NULL;                  // finalize function
	type->parse = int_parse_function;    // Function that parse data from Sqxc instance
	type->write = int_write_function;    // Function that write data to   Sqxc instance

// If you use C language, please use 'typedef' to give a struct type a new name.
typedef struct User     User;

struct User {
	int    id;
	char  *name;
	char  *email;
};

/* sortedEntryPointers is "sorted" entryPointers (sorted by name) */
static const SqEntry  *sortedEntryPointers[] = {
	&(SqEntry) {SQ_TYPE_STR,    "email", offsetof(User, email), 0},
	&(SqEntry) {SQ_TYPE_INT,    "id",    offsetof(User, id),    SQB_HIDDEN},
	&(SqEntry) {SQ_TYPE_STR,    "name",  offsetof(User, name),  0},
};

/* sortedTypeUser use sortedEntryPointers (set SQB_TYPE_SORTED in SqType::bit_field) */
const SqType sortedTypeUser = {
	.size  = sizeof(User),
	.init  = NULL,
	.final = NULL,
	.parse = sq_type_object_parse,
	.write = sq_type_object_write,
	.name  = SQ_GET_TYPE_NAME(User),

	.entry   = sortedEntryPointers,
	.n_entry = sizeof(sortedEntryPointers) / sizeof(SqEntry*),
	.bit_field = SQB_TYPE_SORTED,
	// Because sortedEntryPointers have been sorted by SqEntry::name,
	// you can set SQB_TYPE_SORTED in SqType::bit_field
};

const SqType unsortedTypeUser = {
	/*  Omit other codes...  */

	.bit_field = 0,
};

/* Because sortedEntryPointers   is "sorted"   entries, you can pass SQB_TYPE_SORTED to the last argument. */
const SqType  sortedTypeUserM   = SQ_TYPE_INITIALIZER(User, sortedEntryPointers,   SQB_TYPE_SORTED);

/* Because unsortedEntryPointers is "unsorted" entries, you can pass 0 to the last argument. */
const SqType  unsortedTypeUserM = SQ_TYPE_INITIALIZER(User, unsortedEntryPointers, 0);

	SqType  *type;
	int      n_entry = sizeof(entryPointers) / sizeof(SqEntry*);

	type = sq_type_new(8, (SqDestroyFunc)sq_entry_free);

	sq_type_add_entry_ptrs(type, entryPointers, n_entry);

	Sq::Type  *type;
	int        n_entry = sizeof(entryPointers) / sizeof(SqEntry*);

	type = new Sq::Type(8, sq_entry_free);

	type->addEntry(entryPointers, n_entry);

	SqType  *type;
	SqEntry *entry;

	type = sq_type_new(8, (SqDestroyFunc)sq_entry_free);

	entry = sq_entry_new(SQ_TYPE_STR);
	sq_entry_set_name(entry, "name");
	entry->offset = offsetof(User, name);

	sq_type_add_entry(type, entry, 1, 0);

	Sq::Type  *type;
	Sq::Entry *entry;

	type = new Sq::Type(8, sq_entry_free);

	entry = new Sq::Entry(SQ_TYPE_STR);
	entry->setName("name");
	entry->offset = offsetof(User, name);

	type->addEntry(entry);

/* C function */
unsigned int  sq_type_decide_size(SqType *type, const SqEntry *inner_entry, bool entry_removed);

/* C++ method */
unsigned int  Sq::Type::decideSize(const SqEntry *inner_entry, bool entry_removed);

	SqEntry **entry_addr;

	entry_addr = sq_type_find_entry(type, "entry_name", NULL);
	sq_type_erase_entry_addr(type, entry_addr, 1);

	// remove entry from type and keep entry in memory
//	sq_type_steal_entry_addr(type, entry_addr, 1);

	sq_type_decide_size(type, NULL, true);
//	sq_type_decide_size(type, *entry_addr, true);

	Sq::Entry **entry_addr;

	entry_addr = type->findEntry(type, "entry_name");
	type->eraseEntry(type, entry_addr);

	// remove entry from type and keep entry in memory
//	type->stealEntry(type, entry_addr);

	type->decideSize(NULL, true);
//	type->decideSize(*entry_addr, true);

SqType  *sq_type_copy(SqType *type_dest, const SqType *type_src,
                      SqDestroyFunc entry_free_func,
                      SqCopyFunc    entry_copy_func);

	// copy constant SqType - SQ_TYPE_ARRAY
	// This is mainly used to modify constant SqType.
	type = sq_type_copy(NULL, SQ_TYPE_ARRAY,
	                    (SqDestroyFunc) NULL,
	                    (SqCopyFunc)    NULL);

	// copy constant SqType from SqTable::type
	// The new instance 'type' shares SqColumn instances in 'table->type'
	// This is mainly used to modify constant SqType (from SqTable::type) when migrating.
	type = sq_type_copy(NULL, table->type,
	                    (SqDestroyFunc) sq_column_free,
	                    (SqCopyFunc)    NULL);

	// full copy SqType from SqTable::type
	// The new instance 'type' copies SqColumn instances from 'table->type'
	type = sq_type_copy(NULL, table->type,
	                    (SqDestroyFunc) sq_column_free,
	                    (SqCopyFunc)    sq_column_copy);

	// 'globalType' is a global variable and not a constant.
	SqType *type = globalType;

	// initialize
	sq_type_init_self(type, 0, NULL);
	sq_type_use_constant(type);

	// 'globalType' is a global variable and not a constant.
	Sq::Type *type = globalType;

	// initialize
	type->initSelf(0, NULL);
	type->useConstant();

// This is header file

/* MyList is a list data type

struct MyListNode {
	MyListNode *next;    // pointer to next MyListNode
	void       *data;    // pointer to element data
};

struct MyList {
	MyListNode *head;    // pointer to first MyListNode
}
 */

#ifdef __cplusplus    // mix C and C++
extern "C" {
#endif

// sqType_MyList is defined in source file.
extern const SqType                 sqType_MyList

#define SQ_TYPE_MY_LIST           (&sqType_MyList)

#ifdef __cplusplus    // mix C and C++
}  // extern "C"
#endif

// This is source file

static void sq_type_my_list_init(void *mylist, const SqType *type)
{
	// initialize MyList instance
}

static void sq_type_my_list_final(void *mylist, const SqType *type)
{
	// finalize MyList instance
}

static int  sq_type_my_list_parse(void *mylist, const SqType *type, Sqxc *src)
{
	SqxcValue    *xc_value = (SqxcValue*)src->dest;
	SqxcNested   *nested   = xc_value->nested;
	const SqType *element_type;

	// You can assign element type in SqType::entry
	element_type = (SqType*)type->entry;

	// Start of Container
	if (nested->data != mylist) {
		// do type match
		if (src->type != SQXC_TYPE_ARRAY)
			return (src->code = SQCODE_TYPE_NOT_MATCHED);
		// ready to parse
		nested = sqxc_push_nested((Sqxc*)xc_value);
		nested->data = mylist;
		nested->data2 = (void*)type;
		return (src->code = SQCODE_OK);
	}
	// End of Container
	// sqxc_value_send() have handled SQXC_TYPE_ARRAY_END. User doesn't need to handle it.

	// parse elements of MyList
	void *element = calloc(1, element_type->size);
	src->name = NULL;    // set "name" before calling parse()
	src->code = element_type->parse(element, element_type, src);
	my_list_append(mylist, element);
	return src->code;
}

static Sqxc *sq_type_my_list_write(void *mylist, const SqType *type, Sqxc *dest)
{
	const SqType *element_type;
	const char   *container_name = dest->name;

	// You can assign element type in SqType::entry
	element_type = (SqType*)type->entry;

	// Begin of Container
	dest->type = SQXC_TYPE_ARRAY;
//	dest->name = container_name;    // "name" was set by caller of this function
//	dest->value.pointer = NULL;
	dest = sqxc_send(dest);
	if (dest->code != SQCODE_OK)
		return dest;

	// output elements of MyList
	for (MyListNode *node = mylist->head;  node;  node = node->next) {
		void *element = node->data;
		dest->name = NULL;      // set "name" before calling write()
		dest = element_type->write(element, element_type, dest);
		if (dest->code != SQCODE_OK)
			return dest;
	}

	// End of Container
	dest->type = SQXC_TYPE_ARRAY_END;
	dest->name = container_name;
//	dest->value.pointer = NULL;
	dest = sqxc_send(dest);
	return dest;
}

// used by header file.
const SqType sqType_MyList =
{
	sizeof(MyList),                // size
	sq_type_my_list_init,          // init
	sq_type_my_list_final,         // final
	sq_type_my_list_parse,         // parse
	sq_type_my_list_write,         // write

	NULL,                          // name
	(SqEntry**) SQ_TYPE__yours_,   // entry   : You can assign element type in SqType::entry
	-1,                            // n_entry : SqType::entry isn't freed if SqType::n_entry == -1
	0,                             // bit_field
	NULL,                          // on_destroy
};

// If you use C language, please use 'typedef' to give a struct type a new name.
typedef struct MyType   MyType;

// structure that derived from SqType
#ifdef __cplusplus
struct MyType : Sq::TypeMethod        // <-- 1. inherit C++ member function(method)
#else
struct MyType
#endif
{
	SQ_TYPE_MEMBERS;                  // <-- 2. inherit member variable

	int   mydata;                     // <-- 3. Add variable and non-virtual function in derived struct.
	void *mypointer;

#ifdef __cplusplus
	// define C++ constructor and destructor here if you use C++ language.
	MyType() {
		my_type_init(this);
	}
	~MyType() {
		my_type_final(this);
	}
#endif
};

// This is callback function of destroy notifier.
void    my_type_on_destroy(MyType *mytype) {
	// release resource of derived struct
	free(mytype->mypointer);
}

void    my_type_init(MyType *type)
{
	sq_type_init_self((SqType*)mytype, 0, NULL);
	// initialize members of SqType here.
	// ...

	// set callback function of destroy notifier.
	// This notification will be emitted when sq_type_final_self() is called.
	mytype->on_destroy = my_type_on_destroy;

	// initialize variable of derived struct
	mytype->mydata = 10;
	mytype->mypointer = malloc(512);
}

void    my_type_final(MyType *type)
{
	// sq_type_final_self() will emit destroy notifier
	sq_type_final_self((SqType*)type);
}

SqType *my_type_new()
{
	MyType *mytype = malloc(sizeof(MyType));

	my_type_init(mytype);
	// return type is SqType, because MyType can be free by sq_type_free().
	return (SqType*)mytype;
}

	/* C function */
	sq_type_free(type);

	/* C++ method */
	delete type;