/**
* 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;
}
