src/types_metadata.c

/* 
 * Copyright (C) 2005 Piotr Pokora <piotr.pokora@infoglob.pl>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * */

#include <config.h>
#include <stdlib.h>
#include "midgard/midgard_metadata.h"
#include "midgard/midgard_timestamp.h"
#include "midgard/query.h"
#include "midgard/midgard_object.h"
#include "midgard_core_object.h"
#include "schema.h"

enum {
    MIDGARD_METADATA_CREATOR = 1,
    MIDGARD_METADATA_CREATED,
    MIDGARD_METADATA_REVISOR,
    MIDGARD_METADATA_REVISED,
    MIDGARD_METADATA_REVISION,
    MIDGARD_METADATA_LOCKER,
    MIDGARD_METADATA_LOCKED,
    MIDGARD_METADATA_APPROVER,
    MIDGARD_METADATA_APPROVED,
    MIDGARD_METADATA_AUTHORS,
    MIDGARD_METADATA_OWNER,
    MIDGARD_METADATA_SCHEDULE_START,
    MIDGARD_METADATA_SCHEDULE_END,
    MIDGARD_METADATA_HIDDEN,
    MIDGARD_METADATA_NAV_NOENTRY,
    MIDGARD_METADATA_SIZE,
    MIDGARD_METADATA_PUBLISHED,
    MIDGARD_METADATA_SCORE,
    MIDGARD_METADATA_IMPORTED,
    MIDGARD_METADATA_EXPORTED,
    MIDGARD_METADATA_DELETED
};

static void
_metadata_set_property (GObject *object, guint property_id,
        const GValue *value, GParamSpec *pspec)
{
        MidgardMetadata *self = (MidgardMetadata *) object;
        
        switch (property_id) {
                
                case MIDGARD_METADATA_CREATOR:
                        g_free (self->private->creator);
                        self->private->creator = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_CREATED:
                        g_free (self->private->created);
                        self->private->created = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_REVISOR:      
                        g_free (self->private->revisor);
                        self->private->revisor = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_REVISED:
                        g_free (self->private->revised);
                        self->private->revised = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_REVISION:
                        self->private->revision = g_value_get_uint (value);
                        break;
                        
                case MIDGARD_METADATA_LOCKER:
                        g_free (self->private->locker);                
                        self->private->locker = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_LOCKED:
                        g_free (self->private->locked);                
                        self->private->locked = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_APPROVER:
                        g_free (self->private->approver);                
                        self->private->approver = g_value_dup_string (value);
                        break;                                            
                        
                case MIDGARD_METADATA_APPROVED:    
                        g_free (self->private->approved);
                        self->private->approved = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_AUTHORS:
                        g_free (self->private->authors);
                        self->private->authors = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_OWNER:
                        g_free (self->private->owner);
                        self->private->owner = g_value_dup_string (value);
                        break;

                case MIDGARD_METADATA_SCHEDULE_START:
                        g_free (self->private->schedule_start);
                        self->private->schedule_start = g_value_dup_string (value);
                        break;
                
                case MIDGARD_METADATA_SCHEDULE_END:
                        g_free (self->private->schedule_end);
                        self->private->schedule_end = g_value_dup_string (value);
                        break;
                
                case MIDGARD_METADATA_HIDDEN:
                        self->private->hidden = g_value_get_boolean (value);
                        break;
                        
                case MIDGARD_METADATA_NAV_NOENTRY:
                        self->private->nav_noentry = g_value_get_boolean (value);
                        break;
                        
                case MIDGARD_METADATA_SIZE:
                        self->private->size = g_value_get_uint (value);
                        break;
                        
                case MIDGARD_METADATA_PUBLISHED:            
                        g_free (self->private->published);
                        self->private->published = g_value_dup_string (value);
                        break;

                case MIDGARD_METADATA_SCORE:
                        self->private->score = g_value_get_int (value);
                        break;

                case MIDGARD_METADATA_EXPORTED:
                        g_free (self->private->exported);
                        self->private->exported = g_value_dup_string (value);
                        break;
                
                case MIDGARD_METADATA_IMPORTED:
                        g_free (self->private->imported);
                        self->private->imported = g_value_dup_string (value);
                        break;
                        
                case MIDGARD_METADATA_DELETED:
                        self->private->deleted = g_value_get_boolean (value);
                        break;
                        
                default:
                        G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
                        break;                  
        }
}
    

static void
_metadata_get_property (GObject *object, guint property_id,
        GValue *value, GParamSpec *pspec)
{    
        MidgardMetadata *self = (MidgardMetadata *) object;
        
        switch (property_id) {
                
                case MIDGARD_METADATA_CREATOR: 
                        g_value_set_string (value, self->private->creator);
                        break;
                        
                case MIDGARD_METADATA_CREATED:
                        g_value_set_string (value, self->private->created);
                        break;
                        
                case MIDGARD_METADATA_REVISOR:
                        g_value_set_string (value, self->private->revisor);
                        break;
                        
                case MIDGARD_METADATA_REVISED:
                        g_value_set_string (value, self->private->revised);
                        break;
                        
                case MIDGARD_METADATA_LOCKER:
                        g_value_set_string (value, self->private->locker);
                        break;
                        
                case MIDGARD_METADATA_LOCKED:
                        g_value_set_string (value, self->private->locked);
                        break;
                        
                case MIDGARD_METADATA_APPROVER:
                        g_value_set_string (value, self->private->approver);
                        break;
                        
                case MIDGARD_METADATA_APPROVED:    
                        g_value_set_string (value, self->private->approved);
                        break;
                        
                case MIDGARD_METADATA_REVISION:             
                        g_value_set_uint (value, self->private->revision);            
                        break;
                        
                case MIDGARD_METADATA_AUTHORS:
                        g_value_set_string (value, self->private->authors);
                        break;
                        
                case MIDGARD_METADATA_OWNER:
                        g_value_set_string (value, self->private->owner);
                        break;
                        
                case MIDGARD_METADATA_SCHEDULE_START:
                        g_value_set_string (value, self->private->schedule_start);
                        break;
                        
                case MIDGARD_METADATA_SCHEDULE_END:
                        g_value_set_string (value, self->private->schedule_end);
                        break;
                        
                case MIDGARD_METADATA_HIDDEN:
                        g_value_set_boolean (value, self->private->hidden);
                        break;
                        
                case MIDGARD_METADATA_NAV_NOENTRY:
                        g_value_set_boolean (value, self->private->nav_noentry);
                        break;
                        
                case MIDGARD_METADATA_SIZE:
                        g_value_set_uint(value,  self->private->size);
                        break;
                        
                case MIDGARD_METADATA_PUBLISHED:
                        g_value_set_string (value, self->private->published);
                        break;

                case MIDGARD_METADATA_SCORE:
                        g_value_set_int (value, self->private->score);
                        break;

                case MIDGARD_METADATA_EXPORTED:
                        g_value_set_string (value, self->private->exported);
                        break;

                case MIDGARD_METADATA_IMPORTED:
                        g_value_set_string (value, self->private->imported);
                        break;

                case MIDGARD_METADATA_DELETED:
                        g_value_set_boolean (value, self->private->deleted);
                        break;
                        
                default:
                        G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
                        break;
        }
}

static void 
_metadata_instance_init(GTypeInstance *instance, gpointer g_class) 
{       
        MidgardMetadata *self = (MidgardMetadata *)instance;
        
        /* allocate private data */
        self->private = g_new(MidgardMetadataPrivate, 1);
        self->private->creator = NULL;
        self->private->created = NULL;
        self->private->revised = NULL;
        self->private->revisor = NULL;
        self->private->locker = NULL;
        self->private->locked = NULL;
        self->private->approved = NULL;
        self->private->approver = NULL;
        self->private->authors = NULL;
        self->private->owner = NULL;
        self->private->revision = 0;
        self->private->schedule_start = NULL;
        self->private->schedule_end = NULL;
        self->private->hidden = FALSE;
        self->private->nav_noentry = FALSE;
        self->private->size = 0;
        self->private->published = NULL;
        self->private->score = 0;
        self->private->exported = NULL;
        self->private->imported = NULL;
        self->private->deleted = FALSE;
}

static void 
_metadata_object_finalize(GObject *object) 
{
        g_assert(object);
        
        MidgardMetadata *self = (MidgardMetadata *)object;
        
        /* Free private data */
        g_free(self->private->creator);
        g_free(self->private->created);
        g_free(self->private->revised);
        g_free(self->private->revisor);
        g_free(self->private->locker);
        g_free(self->private->locked);
        g_free(self->private->approved);
        g_free(self->private->approver);
        g_free(self->private->authors);
        g_free(self->private->owner);
        g_free(self->private->schedule_start);
        g_free(self->private->schedule_end);
        g_free(self->private->published);
        g_free(self->private->exported);
        g_free(self->private->imported);
        
        g_free(self->private);
}

/* Set properties when object is created */
void midgard_metadata_set_create(MgdObject *object)
{
        MgdObject *person = (MgdObject *)object->mgd->person;
        gchar *person_guid;
        g_object_get(G_OBJECT(person), "guid", &person_guid, NULL);

        GValue tval = {0, };
        g_value_init(&tval, midgard_timestamp_get_type());
        midgard_timestamp_set_time(&tval, time(NULL));
        
        MidgardMetadata *metadata = (MidgardMetadata *) object->metadata;
        metadata->private->creator = person_guid;    
        metadata->private->created = midgard_timestamp_dup_string(&tval);
}

/* Set properties when object is updated */
void midgard_metadata_set_update(MgdObject *object){

    MgdObject *person = (MgdObject *)object->mgd->person;
    gchar *person_guid;
    g_object_get(G_OBJECT(person), "guid", &person_guid, NULL);

    GValue tval = {0, };
    g_value_init(&tval, midgard_timestamp_get_type());
    midgard_timestamp_set_time(&tval, time(NULL));

    MidgardMetadata *metadata = (MidgardMetadata *) object->metadata;
    metadata->private->revisor = person_guid;
    metadata->private->revised = midgard_timestamp_dup_string(&tval);
    metadata->private->revision += 1; 
}

/* Initialize class */
static void
_metadata_class_init (gpointer g_class,
        gpointer g_class_data){
    
    GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
    MidgardMetadataClass *klass = MIDGARD_METADATA_CLASS (g_class); 
    GParamSpec *pspec;

    gobject_class->set_property = _metadata_set_property;
    gobject_class->get_property = _metadata_get_property;
    gobject_class->finalize = _metadata_object_finalize;
    
    /* Register signals */
    /* Create signal which should be emitted before MgdObject is created */
    klass->set_created = midgard_metadata_set_create;
    klass->signal_set_created = g_signal_new("set_created",
            G_TYPE_FROM_CLASS(g_class),
            G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
            G_STRUCT_OFFSET (MidgardMetadataClass, set_created),
            NULL, /* accumulator */
            NULL, /* accu_data */
            NULL, /* marshaller */
            G_TYPE_NONE,
            0);
    
    /* Create signal which should be emitted before MgdObject is updates */
    klass->set_updated = midgard_metadata_set_update;
    klass->signal_set_updated = g_signal_new("set_updated",
            G_TYPE_FROM_CLASS(g_class),
            G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
            G_STRUCT_OFFSET (MidgardMetadataClass, set_updated),
            NULL, /* accumulator */
            NULL, /* accu_data */
            NULL, /* marshaller */
            G_TYPE_NONE,
            0);
       
    /* Register properties */        
    pspec = g_param_spec_string ("creator",
            "metadata_creator",
            "The person who created object's record",
            "" /* We can set midgard admin */,
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_CREATOR,
            pspec);

    pspec = g_param_spec_string ("created",
            "metadata_created",
            "The date when object's record was created",
            "0000-00-00 00:00",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_CREATED,
            pspec);
    
    pspec = g_param_spec_string ("revisor",
            "metadata_revisor",
            "The person who revised object's record",
            "", 
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_REVISOR,
            pspec);

    pspec = g_param_spec_string ("revised",
            "metadata_revised",
            "The date when object's record was revised",
            "0000-00-00 00:00",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_REVISED,
            pspec);

    pspec = g_param_spec_uint ("revision",
            "metadata_revision",
            "Object's record revision number",
            0, G_MAXUINT32, 0, G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_REVISION,
            pspec);

    pspec = g_param_spec_string ("locker",
            "metadata_locker",
            "The person who (un)locked object's record",
            "",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_LOCKER,
            pspec);

    pspec = g_param_spec_string ("locked",
            "metadata_locked",
            "The date when object's record  was (un)locked",
            "" /* We can set midgard admin */,
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_LOCKED,
            pspec);

    pspec = g_param_spec_string ("approver",
            "metadata_approver",
            "The person who (un)approved object's record",
            "",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_APPROVER,
            pspec);

    pspec = g_param_spec_string ("approved",
            "metadata_approved",
            "The date when object's record was (un)approved",
            "",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_APPROVED,
            pspec);

    pspec = g_param_spec_string ("authors",
            "metadata_authors",
            "The person who is an author",
            "",
            G_PARAM_READWRITE);

    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_AUTHORS,
            pspec);
        
    pspec = g_param_spec_string ("owner",
            "metadata_owner",
            "Group's guid which is an owner of the object",
            "",
            G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_OWNER,
            pspec);

    pspec = g_param_spec_string ("schedulestart",
            "metadata_schedule_start",
            "",
            "",
            G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_SCHEDULE_START,
            pspec);

        pspec = g_param_spec_string ("scheduleend",
            "metadata_schedule_end",
            "",
            "",
            G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_SCHEDULE_END,
            pspec);

        pspec = g_param_spec_boolean ("hidden",
            "metadata_hidden",
            "",
            FALSE,
            G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_HIDDEN,
            pspec);

        pspec = g_param_spec_boolean ("navnoentry",
            "metadata_nav_noentry",
            "",
            FALSE,
            G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_NAV_NOENTRY,
            pspec);

    pspec = g_param_spec_uint ("size",
            "metadata_size",
            "Object's size in bytes",
            0, G_MAXUINT32, 0, G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
            MIDGARD_METADATA_SIZE,
            pspec);

    pspec = g_param_spec_string ("published",
                    "metadata_published",
                    "",
                    "",
                    G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,
                    MIDGARD_METADATA_PUBLISHED,
                    pspec);

    pspec = g_param_spec_int ("score",
                    "metadata_score",
                    "Object's record score",
                    0, G_MAXINT32, 0, G_PARAM_READWRITE);
    
    g_object_class_install_property (gobject_class,      
                    MIDGARD_METADATA_SCORE,        
                    pspec);

    pspec = g_param_spec_string ("exported",
                    "metadata_exported",
                    "",
                    "",
                    G_PARAM_READWRITE);
    g_object_class_install_property (gobject_class,
                    MIDGARD_METADATA_EXPORTED,
                    pspec);
    
    pspec = g_param_spec_string ("imported",
                    "metadata_imported",
                    "",
                    "",
                    G_PARAM_READWRITE);
    g_object_class_install_property (gobject_class,
                    MIDGARD_METADATA_IMPORTED,
                    pspec);
    
    pspec = g_param_spec_boolean ("deleted",
                    "metadata_deleted",
                    "",
                    FALSE,
                    G_PARAM_READWRITE);
    g_object_class_install_property (gobject_class,
                    MIDGARD_METADATA_DELETED,
                    pspec);
}


GType midgard_metadata_get_type (void)
{    
        static GType type = 0;
        if (type == 0) {
                static const GTypeInfo info = {
                        sizeof (MidgardMetadataClass),
                        NULL,   /* base_init */
                        NULL,   /* base_finalize */
                        _metadata_class_init,   /* class_init */                        
                        NULL,   /* class_finalize */
                        NULL,   /* class_data */
                        sizeof (MidgardMetadata),
                        0,      /* n_preallocs */
                        _metadata_instance_init    /* instance_init */
                };
                type = g_type_register_static (G_TYPE_OBJECT,
                                "midgard_metadata",
                                &info, 0);
        }
        return type;
}


MidgardMetadata *midgard_metadata_new(MgdObject *object) 
{
        g_assert(object->mgd);

        MidgardMetadata *self = 
                (MidgardMetadata *) g_object_new(MIDGARD_TYPE_METADATA, NULL);
        self->private->object = object;

        /* TODO , create part of metadata SQL */
        /*
        GString *sql = g_string_new (
            "SELECT metadata_creator, metadata_created, metadata_revisor, "
            "metadata_revised, metadata_revision, "
            "metadata_locker, metadata_locked, metadata_approver, "
            "metadata_approved, metadata_author, metadata_owner, "
            "metadata_schedule_start, metadata_schedule_end, metadata_hidden, "
            "metadata_nav_noentry FROM ");
    g_string_append_printf(sql, " %s WHERE guid = ", 
            midgard_object_class_get_table(
                    MIDGARD_OBJECT_GET_CLASS(object)) );
                    */
        return self;
}

MidgardMetadata *midgard_object_metadata_get(MgdObject *object){

    MidgardMetadata *mm = midgard_metadata_new(object);
    if(mm)
        return mm;

    return NULL;
}


gchar *midgard_metadata_get_sql(MidgardMetadata *object){

    g_assert(object);
    
    guint i = 0;    
    const gchar *nick, *prop_str;
    GValue pval = {0, };
    GParamSpec *prop;
   
    static gchar *props[] = { "locker", "locked", "approver", "approved", 
        "authors", "owner", "schedulestart", "scheduleend", "hidden",
        "navnoentry", "published", "score", NULL};

    GString *sql = g_string_new("");
    
    while (props[i] != NULL) {
        
        prop = g_object_class_find_property(
                G_OBJECT_GET_CLASS(G_OBJECT(object)), 
                props[i]);
        
        nick = g_param_spec_get_nick (prop);
        if((g_ascii_strcasecmp(nick, "") != 0)){

            g_value_init(&pval,prop->value_type);
            g_object_get_property(G_OBJECT(object), props[i], &pval);

            switch (prop->value_type) {
                
                case G_TYPE_STRING:
                    prop_str = g_value_get_string(&pval);
                    if(prop_str == NULL) prop_str = "";
                    g_string_append_printf(sql,
                            ",%s='%s' ",
                            nick, prop_str);
                    break;

                case G_TYPE_BOOLEAN:
                    g_string_append_printf(sql,
                            ",%s=%d ",
                            nick, g_value_get_boolean(&pval));
                    break;

                case G_TYPE_UINT:
                    g_string_append_printf(sql,
                            ",%s=%d ",
                            nick, g_value_get_uint(&pval));
                    break;
            }
            g_value_unset(&pval);
        }
        i++;
    }

    return g_string_free(sql, FALSE);
}

#define _SET_VALUE_TYPE \
    case G_TYPE_STRING:\
        g_hash_table_insert(vtable, "type", "string"); \
        break;\
    case G_TYPE_UINT:\
        g_hash_table_insert(vtable, "type", "integer");\
        break;\
    case G_TYPE_BOOLEAN:\
        g_hash_table_insert(vtable, "type", "boolean");\
        break;\
    case G_TYPE_FLOAT:\
        g_hash_table_insert(vtable, "type", "float");\
        break;


typedef enum
{
    MGD_META_PROPERTY_PARENT = 0,
    MGD_META_PROPERTY_UP,
    MGD_META_PROPERTY_PRIMARY,
    MGD_META_TREE_PARENT,
    MGD_META_TREE_CHILDS
} MidgardMetadataType;

static struct
{
  const gchar *cname;
  MidgardMetadataType type;
} 
_types[] = {
    {"MGD_META_PROPERTY_PARENT", MGD_META_PROPERTY_PARENT},
    {"MGD_META_PROPERTY_UP", MGD_META_PROPERTY_UP},
    {"MGD_META_PROPERTY_PRIMARY", MGD_META_PROPERTY_PRIMARY},
    {"MGD_META_TREE_PARENT", MGD_META_TREE_PARENT},
    {"MGD_META_TREE_CHILDS", MGD_META_TREE_CHILDS},
    {NULL, 0}
};

GSList *midgard_class_metadata_types()
{
    gint i;
    GSList *list = NULL;

    for ( i = 0; _types[i].cname; i++) {
    
        if (_types[i].cname != NULL)
            list = g_slist_append(list, (gchar *)_types[i].cname);
    }

    return list;
}


static void _destroy_metadata_hash_keys(gpointer data){
    
    g_free((gchar *) data);
}

static void _destroy_metadata_hash_values(gpointer data){

    g_hash_table_destroy( (GHashTable *) data);
}


static void _destroy_metadata_vtable_hash_values(gpointer data){

    g_free((gchar *) data);
}

GHashTable *_midgard_class_list_properties(const gchar *classname){

    GParamSpec **props;
    guint propn, i;
    GHashTable *ptable, *vtable;

    
    if (( props = g_object_class_list_properties(
                    g_type_class_peek(g_type_from_name(classname)), &propn)) == NULL) {

        ptable = g_hash_table_new_full (g_str_hash,  g_str_equal, 
                _destroy_metadata_hash_keys, 
                _destroy_metadata_hash_values);
                
        for (i = 0; i < propn; i++) {

            vtable = g_hash_table_new_full (g_str_hash,  g_str_equal,
                    _destroy_metadata_hash_keys,
                    _destroy_metadata_vtable_hash_values);      

            /* Add value type as string */           
            switch(props[i]->value_type) {

                case G_TYPE_STRING:
                    
                    g_hash_table_insert(vtable, "type", "string");
                    break;

                case G_TYPE_UINT:

                    g_hash_table_insert(vtable, "type", "integer");
                    break;

                case G_TYPE_BOOLEAN:

                    g_hash_table_insert(vtable, "type", "boolean");
                    break;

                case G_TYPE_FLOAT:

                    g_hash_table_insert(vtable, "type", "float");
                    break;

            }

            /* Add description */
            g_hash_table_insert(vtable, "description", 
                    g_strdup(g_param_spec_get_blurb(props[i])));
            
            
            g_hash_table_insert(ptable, g_strdup(props[i]->name), vtable);  

        } 

        g_free(props);
        return ptable;
    }
 
    return NULL;        
}


GHashTable *_midgard_class_find_property(const gchar *classname, gchar *propertyname){

    GParamSpec  *prop;
    GHashTable  *vtable; 

    if (( prop = g_object_class_find_property(
                    g_type_class_peek(g_type_from_name(classname)),
                    propertyname)) == NULL) {

        vtable = g_hash_table_new_full (g_str_hash,  g_str_equal,
                _destroy_metadata_hash_keys,
                _destroy_metadata_vtable_hash_values);
       /* 
        switch(prop[i]->value_type) {
            _SET_VALUE_TYPE 
        }
        */
        g_hash_table_insert(vtable, "description",
                g_strdup(g_param_spec_get_blurb(prop)));

        return vtable;        

    }
    
    return NULL;
}

GParamSpec **midgard_class_list_properties(MgdObject *object, guint *n)
{
    GParamSpec **pspecs = 
        g_object_class_list_properties((GObjectClass *)object->klass, n);

    return pspecs; 
}


GParamSpec *midgard_class_find_property(MgdObject *object, gchar *propertyname)
{
    GParamSpec *pspec =
        g_object_class_find_property((GObjectClass *) object->klass, 
                propertyname);
    
    if (pspec != NULL)
        return pspec;

    return NULL;

}


void midgard_class_get_metadata(MgdObject *object,  gint mmt, GValue *val)
{
    mmt = (MidgardMetadataType) mmt;
    
    switch (mmt) {

        case MGD_META_PROPERTY_PARENT:

            g_value_init(val, G_TYPE_STRING);
            g_value_set_string(val, object->data->property_parent);
            break;

        case MGD_META_PROPERTY_UP:

            g_value_init(val, G_TYPE_STRING);
            g_value_set_string(val, object->data->property_up);
            break;

        case MGD_META_PROPERTY_PRIMARY:

            g_value_init(val, G_TYPE_STRING);
            g_value_set_string(val, object->data->primary);
            break;
                                    
        case MGD_META_TREE_PARENT:

            g_value_init(val, G_TYPE_STRING);
            g_value_set_string(val, object->data->parent);
            break;
                                    
        case MGD_META_TREE_CHILDS:

                g_value_init(val, G_TYPE_POINTER);
                g_value_set_pointer(val,(gpointer )object->data->childs);
            
            break;

        default:

            g_value_init(val, G_TYPE_INVALID);
            break;

    }
 
    
}

void midgard_class_list_data()
{
 
   
}

---