metadata_cell.c

Go to the documentation of this file.

/*
 * File Name: metadata_cell.c
 */

/*
 * This file is part of libermetadb.
 *
 * libermetadb is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * libermetadb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <unistd.h>
#include <sys/types.h>

// ereader include files, between < >
#include <liberutils/er_error.h>

// local include files, between " "
#define LOGGING_ON 0
#include "ermetadb_log.h"
#include "metadata_cell.h"
#include "metadata_cell_private.h"

//============================================================================
// Functions Implementation
//============================================================================

void metadata_cell_clear (metadata_cell *thiz)
{
    g_return_if_fail(thiz);

    if (thiz->name)
    {
        g_string_free(thiz->name, TRUE);
        thiz->name = NULL;
    }

    metadata_cell_clear_value(thiz);
}


void metadata_cell_clear_value (metadata_cell *thiz)
{
    LOGPRINTF("entry: thiz [%p]", thiz);
    g_return_if_fail(thiz);

    // release value
    switch (thiz->type)
    {
        case METADATA_TEXT:
            g_string_free(thiz->value.v_text, TRUE);
            break;
        case METADATA_BLOB:
            if ( thiz->value.v_blob.data_is_static == FALSE )
            {
                g_free( (gchar*)(thiz->value.v_blob.data) );
            }
            thiz->value.v_blob.len = 0;
            break;
        default:
            ; //ignore
    }

    // set type to "empty"
    thiz->type = METADATA_NULL;
}


int metadata_cell_copy_value (metadata_cell *thiz, const metadata_cell *src)
{
    int   ret = ER_OK; // return value
    int   len;
    gchar *blob;

    LOGPRINTF("entry: thiz [%p] src [%p]", thiz, src);
    g_return_val_if_fail(thiz, ER_INVALID_PARAMETER);
    g_return_val_if_fail(src,  ER_INVALID_PARAMETER);

    switch (src->type)
    {
        case METADATA_NULL:
            metadata_cell_set_null(thiz);
            break;
        case METADATA_INT64:
            metadata_cell_set_int64(thiz, src->value.v_int64);
            break;
        case METADATA_DOUBLE:
            metadata_cell_set_double(thiz, src->value.v_double);
            break;
        case METADATA_TEXT:
            metadata_cell_set_text(thiz, src->value.v_text->str);
            break;
        case METADATA_BLOB:
            // note: metadata_cell_set_blob takes ownership of blob,
            //       so we must pass it a copy of the blob data
            len  = src->value.v_blob.len;
            blob = g_malloc(len);
            g_assert(blob);
            memcpy(blob, src->value.v_blob.data, len);
            metadata_cell_set_blob(thiz, blob, len);
            break;
        default:
            ERRORPRINTF("unknown cell type [%d]", src->type);
            metadata_cell_set_null(thiz);
            ret = ER_INVALID_PARAMETER;
    }

    return ret;
}


int metadata_cell_set_name (metadata_cell *thiz, const char *name)
{
    LOGPRINTF("entry: thiz [%p] name [%s]", thiz, name);
    g_return_val_if_fail(thiz, ER_INVALID_PARAMETER);

    if (thiz->name)
    {
        g_string_free(thiz->name, TRUE);
        thiz->name = NULL;
    }

    if (name)
    {
        thiz->name = g_string_new(name);
    }

    return ER_OK;
}


int metadata_cell_set_value (metadata_cell *thiz, const sqlite3_value *value)
{
    int           ret = ER_OK;  // return value
    gint64        i64;
    double        d;
    const char    *cp;
    gchar         *blob;
    int           len;

    LOGPRINTF("entry: thiz [%p] value [%p]", thiz, value);
    g_return_val_if_fail(thiz,  ER_INVALID_PARAMETER);
    g_return_val_if_fail(value, ER_INVALID_PARAMETER);

    sqlite3_value *val = (sqlite3_value*)value;  // const_cast
    int type = sqlite3_value_type(val);
    switch (type)
    {
        case SQLITE_INTEGER:
            i64 = sqlite3_value_int64(val);
            ret = metadata_cell_set_int64(thiz, i64);
            break;

        case SQLITE_FLOAT:
            d   = sqlite3_value_double(val);
            ret = metadata_cell_set_double(thiz, d);
            break;

        case SQLITE_TEXT:
            cp  = (const char*) sqlite3_value_text(val);
            ret = metadata_cell_set_text(thiz, cp);
            break;

        case SQLITE_BLOB:
            // note: metadata_cell_set_blob takes ownership of blob,
            //       so we must pass it a copy of the blob data
            len  = sqlite3_value_bytes(val);
            blob = g_malloc(len);
            g_assert(blob);
            memcpy(blob, sqlite3_value_blob(val), len);
            ret = metadata_cell_set_blob(thiz, blob, len);
            break;

        case SQLITE_NULL:
            metadata_cell_set_null(thiz);
            break;

        default:
            ERRORPRINTF("illegal return [%d] from sqlite3_value_type", type);
            metadata_cell_clear(thiz);
            ret= ER_INVALID_PARAMETER;
    }

    return ret;
}


int metadata_cell_set_int64 (metadata_cell *thiz, const gint64 value)
{
    LOGPRINTF("entry: thiz [%p] value [%lld]", thiz, value);
    g_return_val_if_fail(thiz, ER_INVALID_PARAMETER);

    metadata_cell_clear_value(thiz);
    thiz->type          = METADATA_INT64;
    thiz->value.v_int64 = value;
    return ER_OK;
}


int metadata_cell_set_double (metadata_cell *thiz, const double value)
{
    LOGPRINTF("entry: thiz [%p] value [%f]", thiz, value);
    g_return_val_if_fail(thiz, ER_INVALID_PARAMETER);

    metadata_cell_clear_value(thiz);
    thiz->type           = METADATA_DOUBLE;
    thiz->value.v_double = value;

    return ER_OK;
}


int metadata_cell_set_text (metadata_cell *thiz, const char *value)
{
    int ret = ER_OK;

    LOGPRINTF("entry: thiz [%p] value [%s]", thiz, value);
    g_return_val_if_fail(thiz,  ER_INVALID_PARAMETER);
    g_return_val_if_fail(value, ER_INVALID_PARAMETER);

    metadata_cell_clear_value(thiz);

    thiz->value.v_text = g_string_new(value);
    if (thiz->value.v_text == NULL)
    {
        ERRORPRINTF("cannot create GString");
        ret = ER_FAIL;
    }
    else
    {
        // string assignment ok
        thiz->type = METADATA_TEXT;
    }

    return ret;
}


int metadata_cell_set_blob (metadata_cell *thiz, gchar *value, const guint len)
{
    LOGPRINTF("entry: thiz [%p] value [%p]", thiz, value);
    g_return_val_if_fail(thiz,  ER_INVALID_PARAMETER);
    g_return_val_if_fail(value, ER_INVALID_PARAMETER);

    metadata_cell_clear_value(thiz);

    // store pointer to blob value
    thiz->type = METADATA_BLOB;
    thiz->value.v_blob.data = value;
    thiz->value.v_blob.len  = len;

    // remember to release this data
    thiz->value.v_blob.data_is_static = FALSE;;

    return ER_OK;
}


int metadata_cell_set_blob_static (metadata_cell *thiz, const gchar *value, const guint len)
{
    LOGPRINTF("entry: thiz [%p] value [%p]", thiz, value);
    g_return_val_if_fail(thiz,  ER_INVALID_PARAMETER);
    g_return_val_if_fail(value, ER_INVALID_PARAMETER);

    metadata_cell_clear_value(thiz);

    // store pointer to blob value
    thiz->type = METADATA_BLOB;
    thiz->value.v_blob.data = value;
    thiz->value.v_blob.len  = len;

    // remember to leave this data as is, so NEVER release it
    thiz->value.v_blob.data_is_static = TRUE;
    return ER_OK;
}


GString* metadata_cell_get_string (const metadata_cell *thiz)
{
    LOGPRINTF("entry: thiz [%p]", thiz);
    g_return_val_if_fail(thiz, NULL);

    // get cell value and convert
    GString *string = g_string_new("");
    switch (thiz->type)
    {
        case METADATA_INT64:
            g_string_printf(string, "%lld", thiz->value.v_int64);
            break;
        case METADATA_DOUBLE:
            g_string_printf(string, "%f", thiz->value.v_double);
            break;
        case METADATA_TEXT:
            g_string_assign(string, thiz->value.v_text->str);
            break;
        default:
            if (thiz->type != METADATA_NULL)
            {
                ERRORPRINTF("pid [%lld] cannot convert type [%d] to string", (gint64)getpid(), thiz->type); 
            }
            g_string_free(string, TRUE);
            string = NULL;
    }

    return string;
}