root/trunk/midgard/apis/php5/php_midgard_collector.c

/* Copyright (C) 2006, 2007 Piotr Pokora <piotrek.pokora@gmail.com>
 * 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 "php_midgard.h"
#include "php_midgard_gobject.h"

static zend_class_entry *php_midgard_collector_class;

/* Object constructor */
static PHP_METHOD(midgard_collector, __construct)
{
        RETVAL_FALSE;
        CHECK_MGD;
        gchar *classname, *propname;    
        guint classname_length, propname_length;
        zval *value;
        MidgardConnection *mgd = mgd_handle();
        zend_class_entry **ce_arg = NULL, *ce_base = NULL;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz",
                                &classname, &classname_length, 
                                &propname, &propname_length,
                                &value) == FAILURE) {
                return;
        }

        /* Get base schema class name */
        gchar *_classname = g_ascii_strdown(classname, classname_length);
        zend_lookup_class(classname, classname_length, &ce_arg TSRMLS_DC);
        
        if(ce_arg == NULL) {
                php_error(E_WARNING,
                                "Class '%s' is not registered PHP class", classname);
                g_free(_classname);
                return;
        }
        
        g_free(_classname);

        ce_base = php_midgard_get_baseclass_ptr(*ce_arg);
        
        if(ce_base == NULL) {
                php_error(E_WARNING,
                                "Couldn't find internal base class for derived '%s'", 
                                classname);
        }

        MidgardObjectClass *klass =
                MIDGARD_OBJECT_GET_CLASS_BY_NAME(ce_base->name);
        
        if(!klass){
                php_error(E_WARNING, 
                                "%s is not registered Midgard schema class", ce_base->name);
                return;
        }

        GValue *gvalue = php_midgard_zval2gvalue(value);

        MidgardCollector *object =
                midgard_collector_new(mgd, ce_base->name, propname, gvalue);

        if(!object)
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        php_gobject->gobject = G_OBJECT(object);
}

static PHP_METHOD(midgard_collector, set_key_property)
{
        RETVAL_FALSE;
        CHECK_MGD;
        gchar *propname;
        guint propname_length;
        zval *zvalue;
        gboolean rv;
        GValue *gvalue = NULL;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z",
                                &propname, &propname_length, &zvalue)
                        == FAILURE) {
                return;
        }

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        rv = midgard_collector_set_key_property(object, propname, gvalue);
        
        RETURN_BOOL(rv);
}

static PHP_METHOD(midgard_collector, add_value_property)
{
        RETVAL_FALSE;
        CHECK_MGD;
        gchar *propname;
        guint propname_length;
        zval *zval_object = getThis();
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                                &propname, &propname_length) == FAILURE) 
                return;
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        RETURN_BOOL(midgard_collector_add_value_property(object, propname));
}

static PHP_METHOD(midgard_collector, set)
{
        CHECK_MGD;
        RETVAL_TRUE;
        gchar *key, *subkey;
        guint key_length, subkey_length;
        zval *zvalue;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", 
                                &key, &key_length, 
                                &subkey, &subkey_length, &zvalue) == FAILURE) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        GValue *gvalue = php_midgard_zval2gvalue(zvalue);
        gboolean rv = 
                midgard_collector_set(object, key, subkey, gvalue);     

        RETURN_BOOL(rv);
}

static void __colector_update_zend_hash(GQuark key_id,
                                gpointer data, gpointer user_data)
{
        zval *zend_hash = (zval *) user_data;
        GValue *gvalue = (GValue *) data;
        
        if(gvalue == NULL)
                return;
        
        zval *zvalue;
        MAKE_STD_ZVAL(zvalue);
        /* FIXME, we need to get underlying object here */
        php_midgard_gvalue2zval(gvalue, zvalue);
        
        add_assoc_zval(zend_hash,
                        (gchar *)g_quark_to_string(key_id),
                        zvalue);
        return;
}

static PHP_METHOD(midgard_collector, get)
{
        RETVAL_FALSE;
        CHECK_MGD;
        gchar *key;
        guint key_length;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                                &key, &key_length) == FAILURE) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        array_init(return_value);       

        GData *keyslist = midgard_collector_get(object, (const gchar *)key);
        
        if(keyslist != NULL){
                g_datalist_foreach(&keyslist,
                                __colector_update_zend_hash,
                                return_value);
        }
}

static PHP_METHOD(midgard_collector, get_subkey)
{
        RETVAL_FALSE;
        CHECK_MGD;      
        const gchar *key, *subkey;
        guint key_length, subkey_length;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
                                &key, &key_length, &subkey, &subkey_length) == FAILURE) 
                return;
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        GValue *gvalue = 
                midgard_collector_get_subkey(object, key, subkey);      

        if(!gvalue)
                return;
        
        php_midgard_gvalue2zval(gvalue, return_value);  
}

static PHP_METHOD(midgard_collector, remove_key)
{
        RETVAL_FALSE;
        CHECK_MGD;
        const gchar *key;
        guint key_length;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                                &key, &key_length) == FAILURE) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        RETURN_BOOL(midgard_collector_remove_key(object, key));
}

static PHP_METHOD(midgard_collector, merge)
{
        CHECK_MGD;
        RETVAL_FALSE;
        zval *zobject;
        zend_bool zbool = FALSE;
        zval *zval_object = getThis();
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", 
                                &zobject, php_midgard_collector_class, &zbool) == FAILURE) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        php_midgard_gobject *php_gobject_param =
                (php_midgard_gobject *)zend_object_store_get_object(zobject TSRMLS_CC);
        MidgardCollector *mc = MIDGARD_COLLECTOR(php_gobject_param->gobject);
        
        RETURN_BOOL(midgard_collector_merge(object, mc, zbool));
}

static PHP_METHOD(midgard_collector, list_keys)
{
        RETVAL_FALSE;
        CHECK_MGD;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);
        
        array_init(return_value);
        
        gchar **keys =
                midgard_collector_list_keys(object);
        
        if(!keys)
                return;
        
        guint i = 0;
        while(keys[i] != NULL) {
                add_assoc_string(return_value, 
                                (gchar *)keys[i], "", 1);
                i++;
        }

        g_free(keys);
}

static PHP_METHOD(midgard_collector, add_constraint)
{
        RETVAL_FALSE;
        CHECK_MGD;
        gchar *name, *op;
        guint name_length, op_length;
        zval *value;
        zval *zval_object = getThis();
        gboolean rv;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", 
                                &name, &name_length, 
                                &op, &op_length, &value) != SUCCESS) 
                return;
        
        GValue *gvalue = php_midgard_zval2gvalue(value);
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        rv = midgard_collector_add_constraint(object, name, op, gvalue);
        
        g_value_unset(gvalue);
        g_free(gvalue);

        RETURN_BOOL(rv);
}

static PHP_METHOD(midgard_collector, begin_group)
{
        CHECK_MGD;
        RETVAL_FALSE;
        gchar *type;
        guint type_length;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                                &type, &type_length) != SUCCESS) 
                return;
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        RETURN_BOOL(midgard_collector_begin_group(object, type));
}

static PHP_METHOD(midgard_collector, end_group)
{
        RETVAL_FALSE;
        CHECK_MGD;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) 
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        RETURN_BOOL(midgard_collector_end_group(object));
}

static PHP_METHOD(midgard_collector, add_order)
{
        RETVAL_FALSE;
        CHECK_MGD;
        const gchar *field, *order = "ASC";
        guint field_length, order_length;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
                                &field, &field_length, &order, &order_length) != SUCCESS) 
                return;
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        RETURN_BOOL(midgard_collector_add_order(object, field, order));
}

static PHP_METHOD(midgard_collector, set_offset)
{
        RETVAL_FALSE;
        CHECK_MGD;
        zval *zval_object = getThis();
        long offset;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &offset) != SUCCESS) 
                return;
        
        if (offset < 0) {

                php_error(E_WARNING, "Ignoring a negative query offset");
                return;

        }
        
        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);
        
        midgard_collector_set_offset(object, offset);

        RETURN_TRUE;
}

static PHP_METHOD(midgard_collector, set_limit)
{
        RETVAL_FALSE;
        CHECK_MGD;
        long limit;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &limit) != SUCCESS) 
                return;
        
        if (limit < 0) {

                php_error(E_WARNING, "Ignoring a negative query limit");
                return;
        }

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);

        midgard_collector_set_limit(object, limit);

        RETURN_TRUE;
}

static PHP_METHOD(midgard_collector, execute)
{
        RETVAL_FALSE;
        CHECK_MGD;
        zval *zval_object = getThis();

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS)
                return;

        php_midgard_gobject *php_gobject =
                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
        MidgardCollector *object = MIDGARD_COLLECTOR(php_gobject->gobject);
        
        RETURN_BOOL(midgard_collector_execute(object));         
}

void php_midgard_collector_init(int module_number)
{
        static function_entry collector_methods[] = {
                PHP_ME(midgard_collector,       __construct,            NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       set_key_property,       NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       add_value_property,     NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       set,                    NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       get,                    NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       get_subkey,             NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       merge,                  NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       list_keys,              NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       remove_key,             NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       add_constraint,         NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       begin_group,            NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       end_group,              NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       add_order,              NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       set_offset,             NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       set_limit,              NULL, ZEND_ACC_PUBLIC)
                PHP_ME(midgard_collector,       execute,                NULL, ZEND_ACC_PUBLIC)
                {NULL, NULL, NULL}
        };
        
        static zend_class_entry php_midgard_collector_class_entry;

        INIT_CLASS_ENTRY(
                        php_midgard_collector_class_entry,
                        "midgard_collector", collector_methods);

        php_midgard_collector_class = 
                midgard_php_register_internal_class(
                                "midgard_collector", 
                                MIDGARD_TYPE_COLLECTOR,
                                php_midgard_collector_class_entry,                      
                                collector_methods);

        /* Set function to initialize underlying data */
        php_midgard_collector_class->create_object = php_midgard_gobject_new;
}