static PHP_METHOD(midgard_workspace_manager, move_content)
{
char *type;
int type_length;
zval *z_src_workspace;
zval *z_dest_workspace;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sOO", &type, &type_length,
&z_src_workspace, php_midgard_workspace_class,
&z_dest_workspace, php_midgard_workspace_class) == FAILURE) {
return;
}
MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis()));
MidgardWorkspace *src_workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_src_workspace));
MidgardWorkspace *dest_workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_dest_workspace));
GError *error = NULL;
zend_bool result = midgard_workspace_manager_move_content(self, type, src_workspace, dest_workspace, &error);
if (error) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to move %s content betwen workspaces. %s", type, error->message);
g_error_free(error);
}
RETURN_BOOL(result);
}
// midgard_query_constraint
static PHP_METHOD(midgard_query_constraint, __construct)
{
char *operator = NULL;
int operator_len = 0;
zval *z_property = NULL;
zval *z_holder = NULL;
zval *z_storage = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO|O",
&z_property, php_midgard_query_property_class,
&operator, &operator_len,
&z_holder, php_midgard_query_holder_class,
&z_storage, php_midgard_query_storage_class
) == FAILURE
) {
return;
}
MidgardQueryProperty *property = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_property));
MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder));
MidgardQueryStorage *storage = NULL;
if (z_storage) {
storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage));
}
MidgardQueryConstraint *constraint = midgard_query_constraint_new(property, operator, holder, storage);
if (!constraint) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), constraint);
}
static PHP_METHOD(midgard_sql_query_constraint, __construct)
{
zval *z_column = NULL;
char *operator = NULL;
int op_length = 0;
zval *z_holder = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO",
&z_column, php_midgard_sql_query_column_class,
&operator, &op_length,
&z_holder, php_midgard_query_holder_class
) == FAILURE
) {
return;
}
MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column));
MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder));
MidgardSqlQueryConstraint *constraint = midgard_sql_query_constraint_new(column, operator, holder);
if (!column) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), constraint);
}
static PHP_METHOD(midgard_sql_query_select_data, add_column)
{
zval *z_column = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_column, php_midgard_sql_query_column_class) == FAILURE)
return;
MidgardSqlQuerySelectData *select = MIDGARD_SQL_QUERY_SELECT_DATA(__php_gobject_ptr(getThis()));
MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column));
midgard_sql_query_select_data_add_column(select, column);
}
static PHP_METHOD(midgard_workspace_context, has_workspace)
{
zval *z_workspace = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_class) == FAILURE) {
return;
}
MidgardWorkspaceContext *self = MIDGARD_WORKSPACE_CONTEXT(__php_gobject_ptr(getThis()));
MidgardWorkspace *workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_workspace));
zend_bool result = midgard_workspace_context_has_workspace(self, workspace);
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_query_constraint_group, add_constraint)
{
zval *z_constraint = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_constraint, php_midgard_query_constraint_simple_class) == FAILURE) {
return;
}
MidgardQueryConstraintGroup *constraint_group = MIDGARD_QUERY_CONSTRAINT_GROUP(__php_gobject_ptr(getThis()));
MidgardQueryConstraintSimple *constraint = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(z_constraint));
zend_bool result = midgard_query_constraint_group_add_constraint(constraint_group, constraint, NULL);
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_query_constraint, set_storage)
{
zval *z_storage = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_storage, php_midgard_query_storage_class) == FAILURE) {
return;
}
MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardQueryStorage *storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage));
zend_bool result = midgard_query_constraint_set_storage(constraint, storage);
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_query_constraint, set_property)
{
zval *z_property = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_property, php_midgard_query_property_class) == FAILURE) {
return;
}
MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardQueryProperty *property = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_property));
zend_bool result = midgard_query_constraint_set_property(constraint, property);
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_key_config_context, list_key_config)
{
RETVAL_FALSE;
zval *zval_object = getThis();
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardKeyConfigContext *kctx = (MidgardKeyConfigContext *) __php_gobject_ptr(zval_object);
array_init (return_value);
gint n_cfgs;
gchar **cfgs = midgard_key_config_context_list_key_config (kctx, &n_cfgs);
if (!cfgs)
return;
guint i;
for (i = 0; i < n_cfgs; i++) {
add_assoc_string(return_value, (gchar *)cfgs[i], "", 1);
}
g_strfreev(cfgs);
}
static PHP_METHOD(midgard_sql_query_column, __construct)
{
zval *z_qprop = NULL;
char *name = NULL;
char *qualifier = NULL;
int name_length = 0;
int qualifier_length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|s",
&z_qprop, php_midgard_query_property_class,
&qualifier, &qualifier_length,
&name, &name_length
) == FAILURE
) {
return;
}
MidgardQueryProperty *queryproperty = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_qprop));
MidgardSqlQueryColumn *column = midgard_sql_query_column_new(queryproperty, qualifier, name);
if (!column) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), column);
}
/* Object constructor */
static PHP_FUNCTION(php_midgard_view_constructor)
{
RETVAL_FALSE;
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
zval *zval_object = getThis();
GObject *gobject;
gobject = __php_gobject_ptr(zval_object);
if (!gobject) {
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardView *view = g_object_new(g_type_from_name(Z_OBJCE_P(zval_object)->name), NULL);
if (!view) {
php_midgard_error_exception_throw(mgd TSRMLS_CC);
return;
}
MGD_PHP_SET_GOBJECT(zval_object, view);
} else {
// we already have gobject injected
}
}
/* Object constructor */
static PHP_METHOD(midgard_key_config_file, __construct)
{
RETVAL_FALSE;
zval *object = getThis();
char *path;
int path_length;
zval *ctx_object;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "os", &ctx_object, &path, &path_length) == FAILURE)
return;
GError *error = NULL;
MidgardKeyConfigFileContext *mkcf_ctx = (MidgardKeyConfigFileContext *) __php_gobject_ptr(ctx_object);
MidgardKeyConfigFile *mkcf = midgard_key_config_file_new(mkcf_ctx, path, &error);
if (error) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
error && error->message ? error->message : "Unknown reason");
g_clear_error (&error);
return;
}
MGD_PHP_SET_GOBJECT(object, mkcf);
}
static PHP_METHOD(midgard_query_builder, add_constraint)
{
RETVAL_FALSE;
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
char *name, *op;
long name_length, op_length;
zval *value;
zval *zval_object = getThis();
zend_bool rv;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &name, &name_length, &op, &op_length, &value) != SUCCESS) {
return;
}
MidgardQueryBuilder *builder = MIDGARD_QUERY_BUILDER(__php_gobject_ptr(zval_object));
GValue *gvalue = php_midgard_zval2gvalue(value TSRMLS_CC);
if (gvalue == NULL)
RETURN_FALSE;
rv = midgard_query_builder_add_constraint(builder, name, op, gvalue);
g_value_unset(gvalue);
g_free(gvalue);
RETURN_BOOL(rv);
}
static PHP_METHOD(midgard_workspace_storage, list_children)
{
if (zend_parse_parameters_none() == FAILURE)
return;
guint n_objects;
MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis()));
MidgardWorkspaceStorage **children = midgard_workspace_storage_list_children(self, &n_objects);
array_init(return_value);
if (!children)
return;
const char *g_class_name = G_OBJECT_TYPE_NAME(children[0]);
zend_class_entry *ce = zend_fetch_class((char *) g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
int i;
for (i = 0; i < n_objects; i++) {
zval *zobject;
MAKE_STD_ZVAL(zobject);
php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(children[i]), TRUE TSRMLS_CC);
zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL);
}
}
static PHP_METHOD(midgard_sql_query_constraint, set_column)
{
zval *z_column = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_column, &php_midgard_sql_query_column_class) == FAILURE)
return;
MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column));
GError *error = NULL;
midgard_sql_query_constraint_set_column(constraint, column, &error);
if (error) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to set operator: %s", error->message);
g_error_free(error);
}
}
static PHP_METHOD(midgard_sql_query_select_data, get_connection)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis()));
MidgardConnection *mgd = midgard_query_selector_get_connection(selector);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(mgd)));
}
static PHP_METHOD(midgard_sql_query_constraint, get_holder)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardQueryHolder *holder = midgard_sql_query_constraint_get_holder(constraint);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(holder)));
}
// midgard_query_constraint_group
static PHP_METHOD(midgard_query_constraint_group, __construct)
{
char *type = "AND";
int type_len = 3, num_varargs = 0;
zval ***varargs = NULL;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &type_len) == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s*", &type, &type_len, &varargs, &num_varargs) == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
#endif
MidgardQueryConstraintGroup *constraint_group = NULL;
if (num_varargs) {
MidgardQueryConstraintSimple **constraints = ecalloc(num_varargs, sizeof(MidgardQueryConstraintSimple *));
size_t i;
for (i = 0; i < num_varargs; i++) {
constraints[i] = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(*varargs[i]));
}
efree(varargs);
constraint_group = midgard_query_constraint_group_new_with_constraints(type, constraints, num_varargs);
efree(constraints);
if (!constraint_group) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
} else {
constraint_group = midgard_query_constraint_group_new();
if (!constraint_group) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
zend_bool result = midgard_query_constraint_group_set_group_type(constraint_group, type);
if (!result) {
g_object_unref(constraint_group);
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group: couldn't set type");
return;
}
}
MGD_PHP_SET_GOBJECT(getThis(), constraint_group);
}
static PHP_METHOD(midgard_query_result, get_rows)
{
if (zend_parse_parameters_none() == FAILURE)
return;
guint n_objects;
MidgardQueryResult *result = MIDGARD_QUERY_RESULT(__php_gobject_ptr(getThis()));
MidgardQueryRow **rows = midgard_query_result_get_rows(result, &n_objects, NULL);
array_init(return_value);
php_midgard_array_from_unknown_objects((GObject **)rows, n_objects, return_value TSRMLS_CC);
}
static PHP_METHOD(midgard_sql_query_select_data, get_columns)
{
if (zend_parse_parameters_none() == FAILURE)
return;
guint n_objects;
MidgardSqlQuerySelectData *select = MIDGARD_SQL_QUERY_SELECT_DATA(__php_gobject_ptr(getThis()));
MidgardSqlQueryColumn **columns = midgard_sql_query_select_data_get_columns(select, &n_objects, NULL);
array_init(return_value);
php_midgard_array_from_unknown_objects((GObject **)columns, n_objects, return_value TSRMLS_CC);
}
static PHP_METHOD(midgard_sql_query_constraint, get_operator)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
const gchar *operator = midgard_sql_query_constraint_get_operator(constraint);
if (operator == NULL)
RETURN_NULL();
RETURN_STRING(operator, 1);
}
static PHP_METHOD(midgard_workspace_manager, purge_workspace)
{
zval *z_workspace;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_storage_class) == FAILURE) {
return;
}
MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis()));
MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace));
GError *error = NULL;
zend_bool result = midgard_workspace_manager_purge_workspace(self, workspace, &error);
if (error) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to purge workspace. %s", error->message);
g_error_free(error);
}
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_query_row, get_object)
{
char *name;
int name_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE)
return;
MidgardQueryRow *row = MIDGARD_QUERY_ROW(__php_gobject_ptr(getThis()));
GObject *object = midgard_query_row_get_object(row, (const gchar *)name, NULL);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(object));
}
static PHP_METHOD(midgard_query_column, get_query_property)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQueryColumn *column = MIDGARD_QUERY_COLUMN(__php_gobject_ptr(getThis()));
MidgardQueryProperty *property = midgard_query_column_get_query_property(column, NULL);
if (property == NULL)
RETURN_NULL();
php_midgard_gobject_new_with_gobject(return_value, php_midgard_query_property_class, G_OBJECT(property), TRUE TSRMLS_CC);
}
/* Object constructor */
static PHP_METHOD(midgard_query_builder, __construct)
{
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
char *classname;
long classname_length;
zval *zval_object = getThis();
GObject *gobject;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) {
return;
}
zend_class_entry *ce = zend_fetch_class(classname, classname_length, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
if (ce == NULL) {
php_error(E_WARNING, "Didn't find %s class", classname);
php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);
return;
}
zend_class_entry *base_ce = php_midgard_get_baseclass_ptr(ce);
const gchar *g_base_class_name = php_class_name_to_g_class_name(base_ce->name);
GType classtype = g_type_from_name(g_base_class_name);
if (!g_type_is_a(classtype, MIDGARD_TYPE_DBOBJECT)) {
php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT));
php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);
return;
}
gobject = __php_gobject_ptr(zval_object);
if (!gobject) {
MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, g_base_class_name);
if (!builder) {
php_midgard_error_exception_throw(mgd TSRMLS_CC);
return;
}
MGD_PHP_SET_GOBJECT(zval_object, builder);
} else {
// we already have gobject injected
}
php_midgard_gobject *php_gobject = __php_objstore_object(zval_object);
/* Set user defined class. We might need it when execute is invoked */
php_gobject->user_ce = ce;
php_gobject->user_class_name = (char *)ce->name;
}
static PHP_METHOD(midgard_query_column, get_qualifier)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQueryColumn *column = MIDGARD_QUERY_COLUMN(__php_gobject_ptr(getThis()));
const gchar *qualifier = midgard_query_column_get_qualifier(column, NULL);
if (qualifier == NULL)
RETURN_NULL();
RETURN_STRING(qualifier, 1);
}
static PHP_METHOD(midgard_sql_query_select_data, get_query_string)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis()));
const gchar *query_string = midgard_query_selector_get_query_string(selector);
if (query_string == NULL)
RETURN_NULL();
RETURN_STRING(query_string, 1);
}
/* MidgardWorkspaceStorage */
static PHP_METHOD(midgard_workspace_storage, get_path)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis()));
const char *path = midgard_workspace_storage_get_path(self);
if (path)
RETURN_STRING(path, 1);
RETURN_NULL();
}
static PHP_METHOD(midgard_workspace_manager, path_exists)
{
char *path;
int path_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_length) == FAILURE) {
return;
}
MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis()));
zend_bool result = midgard_workspace_manager_path_exists(self, path);
RETURN_BOOL(result);
}
static PHP_METHOD(midgard_workspace, get_context)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardWorkspace *self = MIDGARD_WORKSPACE(__php_gobject_ptr(getThis()));
const MidgardWorkspaceContext *context = midgard_workspace_get_context(self);
if (!context)
RETURN_NULL();
object_init_ex(return_value, php_midgard_workspace_context_class);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(context)));
}
