src/midgard_object_parameter.c

/* 
 * Copyright (C) 2006 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 "midgard_core_object.h"
#include "midgard/types.h"

/* We do not use this hash table because of nature of 
 * Apache processes. Simply one request is not one process
 * so this global hash table should be moved to internal cache */
/* GHashTable *objects_ptrs = NULL; */


static MidgardCollector *__get_parameters_collector(MgdObject *object, 
                const gchar *domain)
{
        GHashTable *domains;
        const gchar *guid = object->private->guid;
        GQuark guidq = g_quark_from_string(guid);
        GQuark domainq = g_quark_from_string(domain);
        
        /* Initialize objects_ptrs hash , this is the first call 
         * to parameter method for any object */
        if(object->private->_params == NULL) {
                object->private->_params = g_hash_table_new_full(NULL, NULL, 
                                NULL, (GDestroyNotify) g_hash_table_destroy);
                domains = g_hash_table_new(NULL, NULL);
                g_hash_table_insert(domains, (gpointer)domainq, NULL);
                g_hash_table_insert(object->private->_params, (gpointer)guidq, domains);
                return NULL;
        }

        domains = g_hash_table_lookup(object->private->_params, (gpointer)guidq);
        /* Objects_ptrs hash is already initialized but particular 
         * object doesn't exist in hash */
        if(!domains) {
                domains = g_hash_table_new(NULL, NULL);
                g_hash_table_insert(domains, (gpointer)domainq, NULL);
                g_hash_table_insert(object->private->_params, (gpointer)guidq, domains);
                return NULL;
        }

        /* object already exists in hash , look for domain hash and return it. */
        return g_hash_table_lookup(domains, (gpointer)domainq);
}

static void __register_domain_collector(
                MgdObject *object, const gchar *domain, MidgardCollector *mc)
{
        const gchar *guid = object->private->guid;
        GQuark guidq = g_quark_from_string(guid);
        GQuark domainq = g_quark_from_string(domain);   

        GHashTable *domains = 
                g_hash_table_lookup(object->private->_params, (gpointer)guidq);

        g_hash_table_insert(domains, (gpointer)domainq, mc);
}

static gboolean __is_guid_valid(MgdObject *self)
{
        if(self->private->guid == NULL) {

                midgard_set_error(self->mgd->_mgd,
                                MGD_GENERIC_ERROR,
                                MGD_ERR_INVALID_PROPERTY_VALUE,
                                " Guid property is NULL for %s. ", 
                                G_OBJECT_TYPE_NAME(self));
                g_warning("%s", self->mgd->_mgd->err->message); 
                g_clear_error(&self->mgd->_mgd->err);
                return FALSE;
        }

        if(!midgard_is_guid(self->private->guid)) {

                midgard_set_error(self->mgd->_mgd,
                                MGD_GENERIC_ERROR,
                                MGD_ERR_INVALID_PROPERTY_VALUE,
                                " Guid property is invalid for %s. ", 
                                G_OBJECT_TYPE_NAME(self));
                g_warning("%s", self->mgd->_mgd->err->message);
                g_clear_error(&self->mgd->_mgd->err);
                return FALSE;
        }

        return TRUE;
}

const GValue *midgard_object_get_parameter(MgdObject *self,
                const gchar *domain, const gchar *name)
{
        g_assert(self);

        if(!__is_guid_valid(self))
                return NULL;

        GValue *ret_value;
        MidgardCollector *domain_collector = 
                __get_parameters_collector(self, domain);

        if(domain_collector == NULL){
                
                /* Initialize collector for object and its domain */
                GValue *domain_value = g_new0(GValue, 1);
                g_value_init(domain_value, G_TYPE_STRING);
                g_value_set_string(domain_value, domain);

                MidgardCollector *mc = 
                        midgard_collector_new(self->mgd->_mgd,
                                        "midgard_parameter",
                                        "domain", domain_value);
                
                /* FIXME, probably we should pass NULL as value argument
                 * and get *all* parameters */
                midgard_collector_set_key_property(mc, 
                                "name", NULL);
                
                /* Add value */
                midgard_collector_add_value_property(mc, "value");

                /* Limit records to these with parent guid */
                GValue *guid_value = g_new0(GValue, 1);
                g_value_init(guid_value, G_TYPE_STRING);
                g_value_set_string(guid_value, self->private->guid);
        
                midgard_collector_add_constraint(mc,
                                "parentguid", "=", guid_value);
                g_value_unset(guid_value);

                midgard_collector_execute(mc);
                
                /* prepend collector to object's parameter list 
                 * we will free it in MgdObject destructor */

                self->private->parameters = 
                        g_slist_prepend(self->private->parameters, mc);

                ret_value = 
                        midgard_collector_get_subkey(mc, name, "value");

                __register_domain_collector(self, domain, mc);

                return (const GValue*)ret_value;
        
        } else {
                
                ret_value = 
                        midgard_collector_get_subkey(
                                        domain_collector, name, "value");
                return (const GValue *)ret_value;
        }

        return NULL;
}

gboolean midgard_object_set_parameter(MgdObject *self,
                const gchar *domain, const gchar *name,
                GValue *value, gboolean lang) 
{

        g_assert(self);

        if(!__is_guid_valid(self))
                return FALSE;
                
        MgdObject *param;
        const gchar *value_string =
                g_value_get_string(value);
        gboolean delete_parameter = FALSE;
        gboolean do_return_true = FALSE;

        if(g_str_equal(value_string, ""))
                delete_parameter = TRUE;

        const GValue *get_value = 
                midgard_object_get_parameter(self,
                                domain, name);

        MidgardCollector *domain_collector =
                __get_parameters_collector(self, domain);

        /* This is the case when set_parameter is invoked
         * before any get_parameter */
        if(get_value == NULL && delete_parameter) {
                MIDGARD_ERRNO_SET(self->mgd, MGD_ERR_NOT_EXISTS);
                return FALSE;
        }

        /* Parameter doesn't exist. We have to create it */
        if(get_value == NULL && !delete_parameter){
                
                param = midgard_object_new(
                                self->mgd, "midgard_parameter", NULL);
                g_object_set(param, 
                                "domain", domain, 
                                "name", name,
                                "parentguid", self->private->guid,
                                NULL);
                g_object_set_property(G_OBJECT(param), "value", value);

                if(midgard_object_create(param)) {
                        
                        if(!midgard_collector_set(domain_collector,
                                                name, "value", value)){
                                g_warning("Failed to update parameter's cache"); 
                        }
                        g_object_unref(param);
                        return TRUE;
                } else {
                        /* Error should be already set by create */
                        g_object_unref(param);
                        return FALSE;
                }

        
                /* Parameter exists. if value is '' we delete it.
                 * In any other case we update it */
        } else {
                
                MidgardQueryBuilder *builder = 
                        midgard_query_builder_new(self->mgd,
                                        "midgard_parameter");
                GValue gval = {0,};
                g_value_init(&gval, G_TYPE_STRING);
                g_value_set_string(&gval, self->private->guid);
                midgard_query_builder_add_constraint(builder,
                                "parentguid", "=", &gval);
                g_value_unset(&gval);

                g_value_init(&gval, G_TYPE_STRING);
                g_value_set_string(&gval, domain);
                midgard_query_builder_add_constraint(builder,
                                "domain", "=", &gval);
                g_value_unset(&gval);

                g_value_init(&gval, G_TYPE_STRING);
                g_value_set_string(&gval, name);
                midgard_query_builder_add_constraint(builder,
                                "name", "=", &gval);
                g_value_unset(&gval);

                guint n_objects = 0;
                GObject **ret_object =
                        midgard_query_builder_execute(
                                        builder, &n_objects);
        
                g_object_unref(builder);
                if(n_objects < 1){              
                        return FALSE;
                }

                if(delete_parameter){

                        if(midgard_object_delete(
                                                MIDGARD_OBJECT(ret_object[0]))) {
                                midgard_collector_remove_key(
                                                domain_collector,
                                                name);
                                do_return_true = TRUE;                          
                        }
                        
                } else {
                        
                        g_object_set(ret_object[0], "value", value_string, NULL);
                        if(midgard_object_update(
                                                MIDGARD_OBJECT(ret_object[0]))) {
                                midgard_collector_set(domain_collector,
                                                name, "value", value);
                                do_return_true = TRUE;
                        }
                }
                
                g_object_unref(ret_object[0]);
                g_free(ret_object);
                if(do_return_true)
                        return TRUE;

        }

        return FALSE;
}

---