token/bigpoint_dyntype.c

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <json/json.h>

#include "bigpoint/bigpoint_dyntype.h"
#include "bigpoint/bigpoint_hash.h"


static
void
__construct(struct BIGPOINT_DYNTYPE * _this, va_list * params)
{
    _this->type = va_arg(* params, enum BIGPOINT_DYNTYPE_TYPES);
    _this->size = va_arg(* params, size_t);

    switch(_this->type) {
        case BIGPOINT_DYNTYPE_INT:
            (_this->data)._int = va_arg(* params, int);
            break;

        case BIGPOINT_DYNTYPE_STRING:
            (_this->data)._string = calloc(_this->size + 1, sizeof(char));
            memcpy((_this->data)._string, va_arg(* params, const char *), _this->size);
            break;

        case BIGPOINT_DYNTYPE_HASH:
            (_this->data)._hash = va_arg(* params, struct BIGPOINT_HASH *);
            break;

        default:
            (_this->data)._hash = NULL;
    }
}

static
void
__jsonConst(struct BIGPOINT_DYNTYPE * _this, struct json_object * json)
{
    switch (json_object_get_type(json)) {
        case json_type_int:
            _this->type = BIGPOINT_DYNTYPE_INT;
            _this->size = sizeof(int);
            (_this->data)._int = (int)json_object_get_int(json);
            break;

        case json_type_string:
            {
                const char * string = json_object_get_string(json);

                _this->type = BIGPOINT_DYNTYPE_STRING;
                _this->size = strlen(string);
                (_this->data)._string = calloc(_this->size + 1, sizeof(char));
                memcpy((_this->data)._string, string, _this->size);
                // the json object handles the memory for string....
            }
            break;

        case json_type_object:
            _this->type = BIGPOINT_DYNTYPE_HASH;
            _this->size = sizeof(struct BIGPOINT_HASH *);
            (_this->data)._hash = newFromJson(BIGPOINT_HASH, json);
            break;

        default:
            _this->type = BIGPOINT_DYNTYPE_NULL;
            _this->size = 0;
            (_this->data)._hash = NULL;
    }
}

static
void
__destruct(struct BIGPOINT_DYNTYPE * _this)
{
    if (_this) {
        switch(_this->type) {
            case BIGPOINT_DYNTYPE_STRING:
                free((_this->data)._string);
                break;

            case BIGPOINT_DYNTYPE_HASH:
                delete((_this->data)._hash);
                break;

            default:
                break;
        }
    }
}

static
struct json_object *
__toJson(struct BIGPOINT_DYNTYPE * _this)
{
    struct json_object * json = NULL;

    switch(_this->type) {
        case BIGPOINT_DYNTYPE_INT:
            json = json_object_new_int((_this->data)._int);
            break;

        case BIGPOINT_DYNTYPE_STRING:
            json = json_object_new_string((_this->data)._string);
            break;

        case BIGPOINT_DYNTYPE_HASH:
            json = toJson((_this->data)._hash);
            break;

        default:
            json = NULL;
    }

    return json;
}

static const
struct BIGPOINT_CCLASS _bigpoint_dyntype = {
    sizeof(struct BIGPOINT_DYNTYPE),
    (ctor)__construct,
    (jCtor)__jsonConst,
    (dtor)__destruct,
    (jTo)__toJson
};

const struct BIGPOINT_CCLASS * const BIGPOINT_DYNTYPE = &_bigpoint_dyntype;

// vim: set et ts=4 sw=4: