/** * json_reader_get_boolean_value: * @reader: a #JsonReader * * Retrieves the boolean value of the current position of @reader * * Return value: the boolean value * * Since: 0.12 */ gboolean json_reader_get_boolean_value (JsonReader *reader) { JsonNode *node; g_return_val_if_fail (JSON_IS_READER (reader), FALSE); json_reader_return_val_if_error_set (reader, FALSE); if (reader->priv->current_node == NULL) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE, _("No node available at the current position")); return FALSE; } node = reader->priv->current_node; if (!JSON_NODE_HOLDS_VALUE (node)) { json_reader_set_error (reader, JSON_READER_ERROR_NO_VALUE, _("The current position holds a '%s' and not a value"), json_node_type_get_name (JSON_NODE_TYPE (node))); return FALSE; } return json_node_get_boolean (node); }
/*! * Convert the specified \c JsonNode into a string. * * \param node \c JsonNode. * \return Newly-allocated string on success, else \c NULL. */ static gchar * clr_oci_json_string (JsonNode* node) { gchar buffer[NODE_BUF_SIZE]; GType valueType = json_node_get_value_type(node); switch (valueType) { case G_TYPE_STRING: return json_node_dup_string(node); case G_TYPE_DOUBLE: case G_TYPE_FLOAT: g_snprintf(buffer, NODE_BUF_SIZE, "%f", json_node_get_double(node)); break; case G_TYPE_INT: case G_TYPE_INT64: g_snprintf(buffer, NODE_BUF_SIZE, "%ld", json_node_get_int(node)); break; case G_TYPE_BOOLEAN: if (json_node_get_boolean(node)) { g_snprintf(buffer, NODE_BUF_SIZE, "%s", "true"); } else { g_snprintf(buffer, NODE_BUF_SIZE, "%s", "false"); } break; default: g_snprintf(buffer, NODE_BUF_SIZE, "%s", "Unknown type"); break; } return g_strdup(buffer); }
gboolean trg_prefs_get_bool(TrgPrefs * p, const gchar * key, int flags) { JsonNode *node = trg_prefs_get_value(p, key, JSON_NODE_VALUE, flags); if (node) return json_node_get_boolean(node); else return FALSE; }
/* Build the RDP server from information in the JSON object */ Server * rdp_server_new_from_json (JsonObject * object) { RdpServer * server = g_object_new(RDP_SERVER_TYPE, NULL); if (json_object_has_member(object, JSON_SERVER_NAME)) { JsonNode * node = json_object_get_member(object, JSON_SERVER_NAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * name = json_node_get_string(node); server->parent.name = g_strdup(name); } } if (json_object_has_member(object, JSON_URI)) { JsonNode * node = json_object_get_member(object, JSON_URI); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * uri = json_node_get_string(node); server->parent.uri = g_strdup(uri); } } if (json_object_has_member(object, JSON_USERNAME)) { JsonNode * node = json_object_get_member(object, JSON_USERNAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * username = json_node_get_string(node); server->username = g_strdup(username); } } if (json_object_has_member(object, JSON_PASSWORD)) { JsonNode * node = json_object_get_member(object, JSON_PASSWORD); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * password = json_node_get_string(node); server->password = g_strdup(password); mlock(server->password, strlen(server->password)); } } if (json_object_has_member(object, JSON_DOMAIN)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * domain = json_node_get_string(node); server->domain = g_strdup(domain); } } if (json_object_has_member(object, JSON_DOMAIN_REQ)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN_REQ); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_BOOLEAN) { server->domain_required = json_node_get_boolean(node); } } return SERVER(server); }
static void twitter_status_build (TwitterStatus *status, JsonNode *node) { TwitterStatusPrivate *priv = status->priv; JsonObject *obj; JsonNode *member; if (!node || JSON_NODE_TYPE (node) != JSON_NODE_OBJECT) return; obj = json_node_get_object (node); member = json_object_get_member (obj, "user"); if (member) { priv->user = twitter_user_new_from_node (member); g_object_ref_sink (priv->user); priv->user_changed_id = g_signal_connect (priv->user, "changed", G_CALLBACK (user_changed_cb), status); } member = json_object_get_member (obj, "source"); if (member) priv->source = json_node_dup_string (member); member = json_object_get_member (obj, "created_at"); if (member) priv->created_at = json_node_dup_string (member); member = json_object_get_member (obj, "id"); if (member) priv->id = json_node_get_int (member); member = json_object_get_member (obj, "truncated"); if (member) priv->truncated = json_node_get_boolean (member); member = json_object_get_member (obj, "text"); if (member) priv->text = json_node_dup_string (member); member = json_object_get_member (obj, "in_reply_to_user_id"); if (member) priv->in_reply_to_user_id = json_node_get_int (member); member = json_object_get_member (obj, "in_reply_to_status_id"); if (member) priv->in_reply_to_status_id = json_node_get_int (member); }
/** * json_reader_get_boolean_value: * @reader: a #JsonReader * * Retrieves the boolean value of the current position of @reader * * Return value: the boolean value * * Since: 0.12 */ gboolean json_reader_get_boolean_value (JsonReader *reader) { g_return_val_if_fail (JSON_IS_READER (reader), FALSE); json_reader_return_val_if_error_set (reader, FALSE); if (reader->priv->current_node == NULL) return FALSE; if (!JSON_NODE_HOLDS_VALUE (reader->priv->current_node)) return FALSE; return json_node_get_boolean (reader->priv->current_node); }
/** * json_object_get_boolean_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that retrieves the boolean value * stored in @member_name of @object * * See also: json_object_get_member() * * Return value: the boolean value of the object's member * * Since: 0.8 */ gboolean json_object_get_boolean_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, FALSE); g_return_val_if_fail (member_name != NULL, FALSE); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, FALSE); g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE, FALSE); return json_node_get_boolean (node); }
/** * json_array_get_boolean_element: * @array: a #JsonArray * @index_: the index of the element to retrieve * * Conveniently retrieves the boolean value of the element at @index_ * inside @array * * See also: json_array_get_element(), json_node_get_boolean() * * Return value: the integer value * * Since: 0.8 */ gboolean json_array_get_boolean_element (JsonArray *array, guint index_) { JsonNode *node; g_return_val_if_fail (array != NULL, FALSE); g_return_val_if_fail (index_ < array->elements->len, FALSE); node = g_ptr_array_index (array->elements, index_); g_return_val_if_fail (node != NULL, FALSE); g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE, FALSE); return json_node_get_boolean (node); }
gboolean json_get_bool (JsonNode *node, const gchar *keyName) { JsonObject *obj; JsonNode *key; obj = json_node_get_object (node); if (!obj) return FALSE; key = json_object_get_member (obj, keyName); if (!key) return FALSE; return json_node_get_boolean (key); }
/** * @return a GList of FBAlbums associated to the user */ static GList *fb_get_album_list(FBContext *ctx, gboolean *ok) { if(!ok) return NULL; *ok = TRUE; GList *album_list = NULL; GHashTable *args = g_hash_table_new((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); g_hash_table_insert(args, "fields", "id,name,can_upload"); JsonObject *reply = fb_query_get(ctx, "me/albums", args); g_hash_table_destroy(args); if(reply == NULL) goto error; JsonArray *jsalbums = json_object_get_array_member(reply, "data"); if(jsalbums == NULL) goto error; guint i; for(i = 0; i < json_array_get_length(jsalbums); i++) { JsonObject *obj = json_array_get_object_element(jsalbums, i); if(obj == NULL) continue; JsonNode *canupload_node = json_object_get_member(obj, "can_upload"); if(canupload_node == NULL || !json_node_get_boolean(canupload_node)) continue; FBAlbum *album = fb_album_init(); if(album == NULL) goto error; const char *id = json_object_get_string_member(obj, "id"); const char *name = json_object_get_string_member(obj, "name"); if(id == NULL || name == NULL) { fb_album_destroy(album); goto error; } album->id = g_strdup(id); album->name = g_strdup(name); album_list = g_list_append(album_list, album); } return album_list; error: *ok = FALSE; g_list_free_full(album_list, (GDestroyNotify)fb_album_destroy); return NULL; }
void js_util_pushjsonnode(js_State *state, JsonNode *node) { GType type; if (!JSON_NODE_HOLDS_VALUE(node)) { js_pushundefined(state); return; } type = json_node_get_value_type(node); if (type == G_TYPE_STRING) js_pushstring(state, json_node_get_string(node)); else if (type == G_TYPE_INT) js_pushnumber(state, json_node_get_int(node)); else if (type == G_TYPE_BOOLEAN) js_pushboolean(state, json_node_get_boolean(node)); else js_pushundefined(state); }
/** * @return a GList of FBAlbums associated to the user */ static GList *fb_get_album_list(FBContext *ctx, gboolean* ok) { if (ok) *ok = TRUE; GList *album_list = NULL; JsonObject *reply = fb_query_get(ctx, "me/albums", NULL); if (reply == NULL) goto error; JsonArray *jsalbums = json_object_get_array_member(reply, "data"); if (jsalbums == NULL) goto error; guint i; for (i = 0; i < json_array_get_length(jsalbums); i++) { JsonObject *obj = json_array_get_object_element(jsalbums, i); if (obj == NULL) continue; JsonNode* canupload_node = json_object_get_member(obj, "can_upload"); if (canupload_node == NULL || !json_node_get_boolean(canupload_node)) continue; FBAlbum *album = fb_album_init(); const char* id = json_object_get_string_member(obj, "id"); const char* name = json_object_get_string_member(obj, "name"); if (id == NULL || name == NULL) goto error; album->id = g_strdup(id); album->name = g_strdup(name); album_list = g_list_append(album_list, album); } return album_list; error: *ok = FALSE; g_list_free_full(album_list, (GDestroyNotify)fb_album_destroy); return NULL; }
gboolean _rpmostree_jsonutil_object_get_optional_boolean_member (JsonObject *object, const char *member_name, gboolean *out_value, GError **error) { gboolean ret = FALSE; JsonNode *node = json_object_get_member (object, member_name); if (node != NULL) { if (json_node_get_value_type (node) != G_TYPE_BOOLEAN) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Member '%s' is not a boolean", member_name); goto out; } *out_value = json_node_get_boolean (node); } ret = TRUE; out: return ret; }
static GVariant * parse_json (JsonNode *node, const GVariantType *type, GError **error) { const GVariantType *element_type; const gchar *str; if (!g_variant_type_is_definite (type)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Indefinite type '%.*s' is not supported", (int)g_variant_type_get_string_length (type), g_variant_type_peek_string (type)); return NULL; } if (g_variant_type_is_basic (type)) { if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_BOOLEAN, error)) return g_variant_new_boolean (json_node_get_boolean (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_byte (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, NULL)) return g_variant_new_double (json_node_get_int (node)); else if (check_type (node, JSON_NODE_VALUE, G_TYPE_DOUBLE, error)) return g_variant_new_double (json_node_get_double (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) return g_variant_new_string (json_node_get_string (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_object_path (str)) return g_variant_new_object_path (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid object path '%s'", str); return NULL; } } } else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_signature (str)) return g_variant_new_signature (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid signature '%s'", str); return NULL; } } } else { parse_not_supported (type, error); } } else if (g_variant_type_is_variant (type)) { return parse_json_variant (node, error); } else if (g_variant_type_is_array (type)) { element_type = g_variant_type_element (type); if (g_variant_type_is_dict_entry (element_type)) return parse_json_dictionary (node, element_type, error); else return parse_json_array (node, element_type, error); } else if (g_variant_type_is_tuple (type)) { return parse_json_tuple (node, g_variant_type_first (type), error); } else { parse_not_supported (type, error); } return NULL; }
gboolean Settings::getBool(const char* path){ JsonNode* node = getNode(path); gboolean value = json_node_get_boolean (node); json_node_free(node); return value; }
/** * json_node_equal: * @a: (type JsonNode): a JSON node * @b: (type JsonNode): another JSON node * * Check whether @a and @b are equal #JsonNodes, meaning they have the same * type and same values (checked recursively). Note that integer values are * compared numerically, ignoring type, so a double value 4.0 is equal to the * integer value 4. * * Returns: %TRUE if @a and @b are equal; %FALSE otherwise * Since: 1.2 */ gboolean json_node_equal (gconstpointer a, gconstpointer b) { JsonNode *node_a, *node_b; /* unowned */ node_a = (JsonNode *) a; node_b = (JsonNode *) b; /* Identity comparison. */ if (node_a == node_b) return TRUE; /* Eliminate mismatched types rapidly. */ if (!json_type_is_a (node_a, node_b) && !json_type_is_a (node_b, node_a)) { return FALSE; } switch (node_a->type) { case JSON_NODE_NULL: /* Types match already. */ return TRUE; case JSON_NODE_ARRAY: return json_array_equal (json_node_get_array (node_a), json_node_get_array (node_b)); case JSON_NODE_OBJECT: return json_object_equal (json_node_get_object (node_a), json_node_get_object (node_b)); case JSON_NODE_VALUE: /* Handled below. */ break; default: g_assert_not_reached (); } /* Handle values. */ switch (node_a->data.value->type) { case JSON_VALUE_NULL: /* Types already match. */ return TRUE; case JSON_VALUE_BOOLEAN: return (json_node_get_boolean (node_a) == json_node_get_boolean (node_b)); case JSON_VALUE_STRING: return json_string_equal (json_node_get_string (node_a), json_node_get_string (node_b)); case JSON_VALUE_DOUBLE: case JSON_VALUE_INT: { gdouble val_a, val_b; JsonValueType value_type_a, value_type_b; value_type_a = node_a->data.value->type; value_type_b = node_b->data.value->type; /* Integer comparison doesn’t need to involve doubles… */ if (value_type_a == JSON_VALUE_INT && value_type_b == JSON_VALUE_INT) { return (json_node_get_int (node_a) == json_node_get_int (node_b)); } /* …but everything else does. We can use bitwise double equality here, * since we’re not doing any calculations which could introduce floating * point error. We expect that the doubles in the JSON nodes come directly * from strtod() or similar, so should be bitwise equal for equal string * representations. * * Interesting background reading: * http://randomascii.wordpress.com/2012/06/26/\ * doubles-are-not-floats-so-dont-compare-them/ */ if (value_type_a == JSON_VALUE_INT) val_a = json_node_get_int (node_a); else val_a = json_node_get_double (node_a); if (value_type_b == JSON_VALUE_INT) val_b = json_node_get_int (node_b); else val_b = json_node_get_double (node_b); return (val_a == val_b); } case JSON_VALUE_INVALID: default: g_assert_not_reached (); } }
/* Params utils */ static gboolean melo_jsonrpc_add_node (JsonNode *node, JsonObject *schema, JsonObject *obj, JsonArray *array) { GType vtype = G_TYPE_INVALID; const gchar *s_name; const gchar *s_type; JsonNodeType type; /* Get name and type from schema */ s_name = json_object_get_string_member (schema, "name"); s_type = json_object_get_string_member (schema, "type"); if (!s_name || !s_type) return FALSE; /* Get type */ type = json_node_get_node_type (node); if (type == JSON_NODE_VALUE) vtype = json_node_get_value_type (node); /* Check type: * We check only first letter of the type string. */ switch (s_type[0]) { case 'b': /* Boolean: check type */ if (vtype != G_TYPE_BOOLEAN) return FALSE; /* Add to object / array */ if (obj || array) { gboolean v; v = json_node_get_boolean (node); if (obj) json_object_set_boolean_member (obj, s_name, v); else json_array_add_boolean_element (array, v); break; } break; case 'i': /* Integer: check type */ if (vtype != G_TYPE_INT64) return FALSE; /* Add to object / array */ if (obj || array) { gint64 v; v = json_node_get_int (node); if (obj) json_object_set_int_member (obj, s_name, v); else json_array_add_int_element (array, v); } break; case 'd': /* Double: check type */ if (vtype != G_TYPE_DOUBLE) return FALSE; /* Add to object / array */ if (obj || array) { gdouble v; v = json_node_get_double (node); if (obj) json_object_set_double_member (obj, s_name, v); else json_array_add_double_element (array, v); } break; case 's': /* String: check type */ if (vtype != G_TYPE_STRING) return FALSE; /* Add to object / array */ if (obj || array) { const gchar *v; v = json_node_get_string (node); if (obj) json_object_set_string_member (obj, s_name, v); else json_array_add_string_element (array, v); } break; case 'o': /* Object: check type */ if (type != JSON_NODE_OBJECT) return FALSE; /* Add to object / array */ if (obj || array) { JsonObject *v; v = json_node_dup_object (node); if (obj) json_object_set_object_member (obj, s_name, v); else json_array_add_object_element (array, v); } break; case 'a': /* Array: check type */ if (type != JSON_NODE_ARRAY) return FALSE; /* Add to object / array */ if (obj || array) { JsonArray *v; v = json_node_dup_array (node); if (obj) json_object_set_array_member (obj, s_name, v); else json_array_add_array_element (array, v); } break; default: return FALSE; } return TRUE; }
static GValue *getValue(JsonNode *node) { GValue *p = new GValue; GValue &ret = *p; switch (JSON_NODE_TYPE(node)) { case JSON_NODE_OBJECT: { JsonObject *node_object; node_object = json_node_get_object (node); g_assert (node_object != NULL); GHashTable *object = g_hash_table_new(g_str_hash, g_str_equal); json_object_foreach_member(node_object, parseMembers, object); g_value_init(&ret, G_TYPE_HASH_TABLE); g_value_set_boxed(&ret, object); } break; case JSON_NODE_ARRAY: { JsonArray *node_array; node_array = json_node_get_array (node); g_assert (node_array != NULL); GValueArray *array = g_value_array_new(0); json_array_foreach_element(node_array, parseElements, array); g_value_init(&ret, G_TYPE_VALUE_ARRAY); g_value_set_boxed(&ret, array); } break; case JSON_NODE_VALUE: { switch (json_node_get_value_type(node)) { case G_TYPE_INT64: { gint64 val = json_node_get_int(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_int64(&ret, val); } break; case G_TYPE_DOUBLE: { double val = json_node_get_double(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_double(&ret, val); } break; case G_TYPE_BOOLEAN: { bool val = json_node_get_boolean(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_boolean(&ret, val); } break; case G_TYPE_STRING: { const gchar * str = json_node_get_string(node); g_value_init (&ret, G_TYPE_STRING); g_value_set_string(&ret, str); } break; default: break; } } break; case JSON_NODE_NULL: break; } return &ret; }
static gboolean melo_jsonrpc_get_json_node (JsonArray *schema_params, JsonNode *params, JsonObject *obj, JsonArray *array, JsonNode **error) { JsonObject *schema; JsonNodeType type; JsonNode *node; guint count, i; /* Check schema */ if (!schema_params) return FALSE; /* No params to check */ if (!params) { if (error && *error == NULL) *error = melo_jsonrpc_build_error_node ( MELO_JSONRPC_ERROR_INVALID_REQUEST, "Invalid request"); return FALSE; } /* Get element count from schema */ count = json_array_get_length (schema_params); /* Get type */ type = json_node_get_node_type (params); /* Already an object */ if (type == JSON_NODE_OBJECT) { const gchar *name; JsonObject *o; /* Get object */ o = json_node_get_object (params); /* Parse object */ for (i = 0; i < count; i++) { /* Get next schema object */ schema = json_array_get_object_element (schema_params, i); if (!schema) goto failed; /* Get parameter name */ name = json_object_get_string_member (schema, "name"); if (!name) goto failed; /* Get node */ node = json_object_get_member (o, name); if (!node) { /* Get required flag: failed if not defined or TRUE */ node = json_object_get_member (schema, "required"); if (!node || (node && json_node_get_boolean (node))) goto failed; /* When not required: * - skip when converting to an object, * - stop when converting to an array. */ if (obj) continue; if (array) return TRUE; } /* Check node type */ if (!melo_jsonrpc_add_node (node, schema, obj, array)) goto failed; } } else if (type == JSON_NODE_ARRAY) { guint params_count; JsonArray *a; /* Get array */ a = json_node_get_array (params); params_count = json_array_get_length (a); /* Parse object */ for (i = 0; i < count; i++) { /* Get next schema object */ schema = json_array_get_object_element (schema_params, i); if (!schema) goto failed; /* No more parameters available */ if (i >= params_count) { /* Get required flag: failed if not defined or TRUE */ node = json_object_get_member (schema, "required"); if (!node || (node && json_node_get_boolean (node))) goto failed; /* If this parameter was not required: stop conversion */ return TRUE; } /* Get node */ node = json_array_get_element (a, i); if (!node) goto failed; /* Check node type */ if (!melo_jsonrpc_add_node (node, schema, obj, array)) goto failed; } } return TRUE; failed: if (error && *error == NULL) *error = melo_jsonrpc_build_error_node (MELO_JSONRPC_ERROR_INVALID_PARAMS, "Invalid params"); return FALSE; }