qofgobj.c

/********************************************************************\
 * qofgobj.c -- QOF to GLib GObject mapping                         *
 *                                                                  *
 * Copyright (c) 2000,2001,2004 Linas Vepstas <linas@linas.org>     *
 *                                                                  *
 * This program 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.              *
 *                                                                  *
 * This program 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, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/

#include "config.h"
#include <glib.h>
#include "qof.h"
#include "qofgobj.h"

static QofLogModule log_module = QOF_MOD_QUERY;

static gboolean initialized = FALSE;
static GSList *paramList = NULL;
static GSList *classList = NULL;

/* =================================================================== */

#if 0
static gboolean
clear_table (gpointer key, gpointer value, gpointer user_data)
{
    g_slist_free (value);
    return TRUE;
}
#endif

void
qof_gobject_init (void)
{
    if (initialized)
        return;
    initialized = TRUE;

    // gobjectClassTable = g_hash_table_new (g_str_hash, g_str_equal);

    /* Init the other subsystems that we need */
    qof_object_initialize ();
    qof_query_init ();
}

void
qof_gobject_shutdown (void)
{
    GSList *n;

    if (!initialized)
        return;
    initialized = FALSE;

//  GSList *n;
    for (n = paramList; n; n = n->next)
        g_free (n->data);
    g_slist_free (paramList);

    for (n = classList; n; n = n->next)
        g_free (n->data);
    g_slist_free (classList);

#if 0
    // XXX also need to walk over books, and collection and delete
    // the collection get_data instance lists !!
    // without this we have a memory leak !!
    g_hash_table_foreach_remove (gobjectParamTable, clear_table, NULL);
    g_hash_table_destroy (gobjectParamTable);
#endif
}

/* =================================================================== */

#define GOBJECT_TABLE  "GobjectTable"

void
qof_gobject_register_instance (QofBook * book, QofType type, GObject * gob)
{
    QofCollection *coll;
    GSList *instance_list;

    if (!book || !type)
        return;

    coll = qof_book_get_collection (book, type);

    instance_list = qof_collection_get_data (coll);
    instance_list = g_slist_prepend (instance_list, gob);
    qof_collection_set_data (coll, instance_list);
}

/* =================================================================== */

static gpointer
qof_gobject_getter (gpointer data, QofParam * getter)
{
    GObject *gob = data;
    const char *str;

    GParamSpec *gps = getter->param_userdata;

    /* Note that the return type must actually be of type
     * getter->param_type but we just follow the hard-coded 
     * mapping below ... */
    if (G_IS_PARAM_SPEC_STRING (gps))
    {
        GValue gval;
        g_value_init (&gval, G_TYPE_STRING);
        g_object_get_property (gob, getter->param_name, &gval);

        str = g_value_get_string (&gval);
        return (gpointer) str;
    }
    else if (G_IS_PARAM_SPEC_INT (gps))
    {
        long ival;

        GValue gval;
        g_value_init (&gval, G_TYPE_INT);
        g_object_get_property (gob, getter->param_name, &gval);

        ival = g_value_get_int (&gval);
        return (gpointer) ival;
    }
    else if (G_IS_PARAM_SPEC_UINT (gps))
    {
        long ival;
        GValue gval;
        g_value_init (&gval, G_TYPE_UINT);
        g_object_get_property (gob, getter->param_name, &gval);

        ival = g_value_get_uint (&gval);
        return (gpointer) ival;
    }
    else if (G_IS_PARAM_SPEC_BOOLEAN (gps))
    {
        gboolean ival;

        GValue gval;
        g_value_init (&gval, G_TYPE_BOOLEAN);
        g_object_get_property (gob, getter->param_name, &gval);

        ival = g_value_get_boolean (&gval);
        return GINT_TO_POINTER (ival);
    }

    PWARN ("unhandled parameter type %s for paramter %s",
        G_PARAM_SPEC_TYPE_NAME (gps), getter->param_name);
    return NULL;
}

static double
qof_gobject_double_getter (gpointer data, QofParam * getter)
{
    GObject *gob = data;
    double fval;

    GParamSpec *gps = getter->param_userdata;

    /* Note that the return type must actually be of type
     * getter->param_type but we just follow the hard-coded 
     * mapping below ... */
    if (G_IS_PARAM_SPEC_FLOAT (gps))
    {
        GValue gval;
        g_value_init (&gval, G_TYPE_FLOAT);
        g_object_get_property (gob, getter->param_name, &gval);

        fval = g_value_get_float (&gval);
        return fval;
    }
    else if (G_IS_PARAM_SPEC_DOUBLE (gps))
    {
        GValue gval;
        g_value_init (&gval, G_TYPE_DOUBLE);
        g_object_get_property (gob, getter->param_name, &gval);

        fval = g_value_get_double (&gval);
        return fval;
    }

    PWARN ("unhandled parameter type %s for paramter %s",
        G_PARAM_SPEC_TYPE_NAME (gps), getter->param_name);
    return 0.0;
}

/* =================================================================== */
/* Loop over every instance of the given type in the collection
 * of instances that we have on hand.
 */
static void
qof_gobject_foreach (QofCollection * coll, QofEntityForeachCB cb,
    gpointer ud)
{
    GSList *n;
    n = qof_collection_get_data (coll);
    for (; n; n = n->next)
    {
        cb (n->data, ud);
    }
}

/* =================================================================== */

void
qof_gobject_register (QofType e_type, GObjectClass * obclass)
{
    guint i, j;
    QofParam *qof_param_list, *qpar;
    QofObject *class_def;
    GParamSpec **prop_list, *gparam;
    guint n_props;

    /* Get the GObject properties, convert to QOF properties */
    prop_list = g_object_class_list_properties (obclass, &n_props);

    qof_param_list = g_new0 (QofParam, n_props);
    paramList = g_slist_prepend (paramList, qof_param_list);

    PINFO ("object %s has %d props", e_type, n_props);
    j = 0;
    for (i = 0; i < n_props; i++)
    {
        gparam = prop_list[i];
        qpar = &qof_param_list[j];

        PINFO ("param %d %s is type %s",
            i, gparam->name, G_PARAM_SPEC_TYPE_NAME (gparam));

        qpar->param_name = g_param_spec_get_name (gparam);
        qpar->param_getfcn = (QofAccessFunc) qof_gobject_getter;
        qpar->param_setfcn = NULL;
        qpar->param_userdata = gparam;
        if ((G_IS_PARAM_SPEC_INT (gparam)) ||
            (G_IS_PARAM_SPEC_UINT (gparam)) ||
            (G_IS_PARAM_SPEC_ENUM (gparam)) ||
            (G_IS_PARAM_SPEC_FLAGS (gparam)))
        {
            qpar->param_type = QOF_TYPE_INT32;
            j++;
        }
        else if ((G_IS_PARAM_SPEC_INT64 (gparam)) ||
            (G_IS_PARAM_SPEC_UINT64 (gparam)))
        {
            qpar->param_type = QOF_TYPE_INT64;
            j++;
        }
        else if (G_IS_PARAM_SPEC_BOOLEAN (gparam))
        {
            qpar->param_type = QOF_TYPE_BOOLEAN;
            j++;
        }
        else if (G_IS_PARAM_SPEC_STRING (gparam))
        {
            qpar->param_type = QOF_TYPE_STRING;
            j++;
        }
        else if ((G_IS_PARAM_SPEC_POINTER (gparam)) ||
            (G_IS_PARAM_SPEC_OBJECT (gparam)))
        {
            /* No-op, silently ignore.  Someday we should handle this ...  */
        }
        else if ((G_IS_PARAM_SPEC_FLOAT (gparam)) ||
            (G_IS_PARAM_SPEC_DOUBLE (gparam)))
        {
            qpar->param_getfcn = (QofAccessFunc) qof_gobject_double_getter;
            qpar->param_type = QOF_TYPE_DOUBLE;
            j++;
        }
        else if (G_IS_PARAM_SPEC_CHAR (gparam))
        {
            qpar->param_type = QOF_TYPE_CHAR;
            j++;
        }
        else
        {
            PWARN ("Unknown/unhandled parameter type %s on %s:%s\n",
                G_PARAM_SPEC_TYPE_NAME (gparam), e_type, qpar->param_name);
        }
    }

    /* NULL-terminated list! */
    qof_param_list[j].param_type = NULL;

    qof_class_register (e_type, NULL, qof_param_list);

    /* ------------------------------------------------------ */
    /* Now do the class itself */
    class_def = g_new0 (QofObject, 1);
    classList = g_slist_prepend (classList, class_def);

    class_def->interface_version = QOF_OBJECT_VERSION;
    class_def->e_type = e_type;
    /* We could let the user specify a "nick" here, but
     * the actual class name seems reasonable, e.g. for debugging. */
    class_def->type_label = G_OBJECT_CLASS_NAME (obclass);
    class_def->create = NULL;
    class_def->book_begin = NULL;
    class_def->book_end = NULL;
    class_def->is_dirty = NULL;
    class_def->mark_clean = NULL;
    class_def->foreach = qof_gobject_foreach;
    class_def->printable = NULL;
    class_def->version_cmp = NULL;

    qof_object_register (class_def);
}

/* ======================= END OF FILE ================================ */

---