fx/ds/uuid.c

#include <fx/core/stringstream.h>
#include <fx/ds/string.h>
#include <fx/ds/uuid.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*** PRIVATE DATA *************************************************************/

struct fx_uuid_p {
	union fx_uuid_bytes uuid_bytes;
};

/*** PRIVATE FUNCTIONS ********************************************************/

static fx_status uuid_to_cstr(
	const struct fx_uuid_p *uuid, char out[FX_UUID_STRING_MAX])
{
	snprintf(
		out, FX_UUID_STRING_MAX,
		"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%"
		"02x%02x",
		uuid->uuid_bytes.uuid_bytes[0], uuid->uuid_bytes.uuid_bytes[1],
		uuid->uuid_bytes.uuid_bytes[2], uuid->uuid_bytes.uuid_bytes[3],
		uuid->uuid_bytes.uuid_bytes[4], uuid->uuid_bytes.uuid_bytes[5],
		uuid->uuid_bytes.uuid_bytes[6], uuid->uuid_bytes.uuid_bytes[7],
		uuid->uuid_bytes.uuid_bytes[8], uuid->uuid_bytes.uuid_bytes[9],
		uuid->uuid_bytes.uuid_bytes[10], uuid->uuid_bytes.uuid_bytes[11],
		uuid->uuid_bytes.uuid_bytes[12], uuid->uuid_bytes.uuid_bytes[13],
		uuid->uuid_bytes.uuid_bytes[14], uuid->uuid_bytes.uuid_bytes[15]);
	return FX_SUCCESS;
}

static void uuid_get_bytes(
	const struct fx_uuid_p *uuid, unsigned char bytes[FX_UUID_NBYTES])
{
	memcpy(bytes, uuid->uuid_bytes.uuid_bytes, FX_UUID_NBYTES);
}

static void uuid_get_uuid_bytes(
	const struct fx_uuid_p *uuid, union fx_uuid_bytes *bytes)
{
	memcpy(bytes, &uuid->uuid_bytes, sizeof *bytes);
}

static union fx_uuid_bytes *uuid_ptr(struct fx_uuid_p *uuid)
{
	return &uuid->uuid_bytes;
}

/*** PUBLIC FUNCTIONS *********************************************************/

fx_uuid *fx_uuid_create_from_bytes(
	unsigned char u00, unsigned char u01, unsigned char u02,
	unsigned char u03, unsigned char u04, unsigned char u05,
	unsigned char u06, unsigned char u07, unsigned char u08,
	unsigned char u09, unsigned char u10, unsigned char u11,
	unsigned char u12, unsigned char u13, unsigned char u14, unsigned char u15)
{
	fx_uuid *uuid = fx_uuid_create();
	if (!uuid) {
		return NULL;
	}

	struct fx_uuid_p *p = fx_object_get_private(uuid, FX_TYPE_UUID);

	p->uuid_bytes.uuid_bytes[0] = u00;
	p->uuid_bytes.uuid_bytes[1] = u01;
	p->uuid_bytes.uuid_bytes[2] = u02;
	p->uuid_bytes.uuid_bytes[3] = u03;
	p->uuid_bytes.uuid_bytes[4] = u04;
	p->uuid_bytes.uuid_bytes[5] = u05;
	p->uuid_bytes.uuid_bytes[6] = u06;
	p->uuid_bytes.uuid_bytes[7] = u07;
	p->uuid_bytes.uuid_bytes[8] = u08;
	p->uuid_bytes.uuid_bytes[9] = u09;
	p->uuid_bytes.uuid_bytes[10] = u10;
	p->uuid_bytes.uuid_bytes[11] = u11;
	p->uuid_bytes.uuid_bytes[12] = u12;
	p->uuid_bytes.uuid_bytes[13] = u13;
	p->uuid_bytes.uuid_bytes[14] = u14;
	p->uuid_bytes.uuid_bytes[15] = u15;

	return uuid;
}

fx_uuid *fx_uuid_create_from_bytev(const unsigned char bytes[FX_UUID_NBYTES])
{
	fx_uuid *uuid = fx_uuid_create();
	if (!uuid) {
		return NULL;
	}

	struct fx_uuid_p *p = fx_object_get_private(uuid, FX_TYPE_UUID);

	memcpy(p->uuid_bytes.uuid_bytes, bytes, FX_UUID_NBYTES);

	return uuid;
}

fx_uuid *fx_uuid_create_from_cstr(const char *str)
{
	union fx_uuid_bytes bytes;

	bool valid = true;
	bool is_guid = false;
	if (*str == '{') {
		is_guid = true;
		str++;
	}

	size_t i, byte = 0;
	for (i = 0; str[i] && byte < FX_UUID_NBYTES;) {
		if (i == 8 || i == 13 || i == 18 || i == 23) {
			if (str[i] != '-') {
				valid = false;
				break;
			}

			i++;
			continue;
		}

		char n[3];
		n[0] = str[i];
		n[1] = str[i + 1];
		n[2] = '\0';

		if (!isxdigit(n[0]) || !isxdigit(n[1])) {
			valid = false;
			break;
		}

		char *p;
		unsigned long v = strtoul(n, &p, 16);
		bytes.uuid_bytes[byte] = v;

		byte++;
		i += 2;
	}

	if (str[i] == '}') {
		if (is_guid) {
			i++;
		} else {
			valid = false;
		}
	}

	if (str[i] != '\0' || byte != FX_UUID_NBYTES) {
		valid = false;
	}

	if (!valid) {
		return NULL;
	}

	return fx_uuid_create_from_uuid_bytes(&bytes);
}

fx_status fx_uuid_to_cstr(const fx_uuid *uuid, char out[FX_UUID_STRING_MAX])
{
	FX_CLASS_DISPATCH_STATIC(FX_TYPE_UUID, uuid_to_cstr, uuid, out);
}

void fx_uuid_get_bytes(const fx_uuid *uuid, unsigned char bytes[FX_UUID_NBYTES])
{
	FX_CLASS_DISPATCH_STATIC(FX_TYPE_UUID, uuid_get_bytes, uuid, bytes);
}

void fx_uuid_get_uuid_bytes(const fx_uuid *uuid, union fx_uuid_bytes *bytes)
{
	FX_CLASS_DISPATCH_STATIC(FX_TYPE_UUID, uuid_get_uuid_bytes, uuid, bytes);
}

union fx_uuid_bytes *fx_uuid_ptr(fx_uuid *uuid)
{
	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_UUID, uuid_ptr, uuid);
}

/*** PUBLIC ALIAS FUNCTIONS ***************************************************/

fx_uuid *fx_uuid_create_from_uuid_bytes(const union fx_uuid_bytes *bytes)
{
	return fx_uuid_create_from_bytev(bytes->uuid_bytes);
}

fx_uuid *fx_uuid_create_from_string(const fx_string *string)
{
	return fx_uuid_create_from_cstr(fx_string_ptr(string));
}

/*** VIRTUAL FUNCTIONS ********************************************************/

static void uuid_init(fx_object *obj, void *priv)
{
	struct fx_uuid_p *uuid = priv;
}

static void uuid_fini(fx_object *obj, void *priv)
{
	struct fx_uuid_p *uuid = priv;
}

static void uuid_to_string(const fx_object *uuid, fx_stream *out)
{
	char str[FX_UUID_STRING_MAX];
	fx_uuid_to_cstr(uuid, str);
	fx_stream_write_string(out, str, NULL);
}

/*** CLASS DEFINITION *********************************************************/

FX_TYPE_CLASS_DEFINITION_BEGIN(fx_uuid)
	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
		FX_INTERFACE_ENTRY(to_string) = uuid_to_string;
	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
FX_TYPE_CLASS_DEFINITION_END(fx_uuid)

FX_TYPE_DEFINITION_BEGIN(fx_uuid)
	FX_TYPE_ID(0x17037068, 0x92f7, 0x4582, 0xad1f, 0x0dea43b628de);
	FX_TYPE_CLASS(fx_uuid_class);
	FX_TYPE_INSTANCE_PRIVATE(struct fx_uuid_p);
	FX_TYPE_INSTANCE_INIT(uuid_init);
	FX_TYPE_INSTANCE_FINI(uuid_fini);
FX_TYPE_DEFINITION_END(fx_uuid)