static JsonNode * snra_json_value_to_node (const GValue *value) { JsonNode *n = NULL; if (GST_VALUE_HOLDS_STRUCTURE (value)) { const GstStructure *s = gst_value_get_structure (value); n = snra_json_from_gst_structure (s); } else if (GST_VALUE_HOLDS_ARRAY (value)) { guint count = gst_value_array_get_size (value); guint i; JsonArray *arr = json_array_sized_new (count); for (i = 0; i < count; i++) { const GValue *sub_val = gst_value_array_get_value (value, i); JsonNode *tmp = snra_json_value_to_node (sub_val); if (tmp) json_array_add_element (arr, tmp); } n = json_node_new (JSON_NODE_ARRAY); json_node_take_array (n, arr); } else { n = json_node_new (JSON_NODE_VALUE); json_node_set_value (n, value); } return n; }
JsonNode* cometd_msg_wrap(JsonNode* msg) { JsonNode* payload = json_node_new(JSON_NODE_ARRAY); JsonArray* arr = json_array_new(); json_array_add_element(arr, msg); json_node_take_array(payload, arr); return payload; }
/** * json_object_set_array_member: * @object: a #JsonObject * @member_name: the name of the member * @value: the value of the member * * Convenience function for setting an array @value of * @member_name inside @object. * * The @object will take ownership of the passed #JsonArray * * See also: json_object_set_member() * * Since: 0.8 */ void json_object_set_array_member (JsonObject *object, const gchar *member_name, JsonArray *value) { JsonNode *node; g_return_if_fail (object != NULL); g_return_if_fail (member_name != NULL); node = json_node_new (JSON_NODE_ARRAY); json_node_take_array (node, value); object_set_member_internal (object, member_name, node); }
// Create a gchar** into a json array JsonNode *glib_jsonrpc_json_strv_to_json_array(gchar **strv) { JsonArray *array = json_array_new(); gchar **p = strv; while(*p) { JsonNode *node = json_node_new(JSON_NODE_VALUE); json_node_set_string(node, *p); json_array_add_element(array,node); p++; } JsonNode *node = json_node_new(JSON_NODE_ARRAY); json_node_take_array(node, array); return node; }
/** * json_array_add_array_element: * @array: a #JsonArray * @value: (transfer full): a #JsonArray * * Conveniently adds an array into @array. The @array takes ownership * of the newly added #JsonArray * * See also: json_array_add_element(), json_node_take_array() * * Since: 0.8 */ void json_array_add_array_element (JsonArray *array, JsonArray *value) { JsonNode *node; g_return_if_fail (array != NULL); g_return_if_fail (value != NULL); if (value != NULL) { node = json_node_new (JSON_NODE_ARRAY); json_node_take_array (node, value); } else node = json_node_new (JSON_NODE_NULL); g_ptr_array_add (array->elements, node); }
static void glide_document_json_obj_set_slides (GlideDocument *document, JsonObject *obj) { JsonNode *node = json_node_new (JSON_NODE_ARRAY); JsonArray *array = json_array_new (); GList *s; for (s = document->priv->slides; s; s = s->next) { JsonNode *n; GlideSlide *slide = (GlideSlide *)(s->data); n = glide_actor_serialize (GLIDE_ACTOR (slide)); json_array_add_element (array, n); } json_node_take_array (node, array); json_object_set_member (obj, "slides", node); }
/** * json_builder_end_array: * @builder: a #JsonBuilder * * Closes the subarray inside the given @builder that was opened by the most * recent call to json_builder_begin_array(). * * Cannot be called after json_builder_set_member_name(). * * Return value: (transfer none): the #JsonBuilder, or %NULL if the call was inconsistent */ JsonBuilder * json_builder_end_array (JsonBuilder *builder) { JsonBuilderState *state; g_return_val_if_fail (JSON_IS_BUILDER (builder), NULL); g_return_val_if_fail (!g_queue_is_empty (builder->priv->stack), NULL); g_return_val_if_fail (json_builder_current_mode (builder) == JSON_BUILDER_MODE_ARRAY, NULL); state = g_queue_pop_head (builder->priv->stack); if (g_queue_is_empty (builder->priv->stack)) { builder->priv->root = json_node_new (JSON_NODE_ARRAY); json_node_take_array (builder->priv->root, json_array_ref (state->data.array)); } json_builder_state_free (state); return builder; }
JsonNode * json_serialize_pspec (const GValue *real_value, GParamSpec *pspec) { JsonNode *retval = NULL; GValue value = { 0, }; JsonNodeType node_type; switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value))) { case G_TYPE_INT64: case G_TYPE_BOOLEAN: case G_TYPE_DOUBLE: /* JSON native types */ retval = json_node_new (JSON_NODE_VALUE); g_value_init (&value, G_VALUE_TYPE (real_value)); g_value_copy (real_value, &value); json_node_set_value (retval, &value); g_value_unset (&value); break; case G_TYPE_STRING: /* strings might be NULL, so we handle it differently */ if (!g_value_get_string (real_value)) retval = json_node_new (JSON_NODE_NULL); else { retval = json_node_new (JSON_NODE_VALUE); json_node_set_string (retval, g_value_get_string (real_value)); break; } break; case G_TYPE_INT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_int (real_value)); break; case G_TYPE_FLOAT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_double (retval, g_value_get_float (real_value)); break; case G_TYPE_BOXED: if (G_VALUE_HOLDS (real_value, G_TYPE_STRV)) { gchar **strv = g_value_get_boxed (real_value); gint i, strv_len; JsonArray *array; strv_len = g_strv_length (strv); array = json_array_sized_new (strv_len); for (i = 0; i < strv_len; i++) { JsonNode *str = json_node_new (JSON_NODE_VALUE); json_node_set_string (str, strv[i]); json_array_add_element (array, str); } retval = json_node_new (JSON_NODE_ARRAY); json_node_take_array (retval, array); } else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type)) { gpointer boxed = g_value_get_boxed (real_value); retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed); } else g_warning ("Boxed type '%s' is not handled by JSON-GLib", g_type_name (G_VALUE_TYPE (real_value))); break; case G_TYPE_UINT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_uint (real_value)); break; case G_TYPE_LONG: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_long (real_value)); break; case G_TYPE_ULONG: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_long (real_value)); break; case G_TYPE_CHAR: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_char (real_value)); break; case G_TYPE_UCHAR: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_uchar (real_value)); break; case G_TYPE_ENUM: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_enum (real_value)); break; case G_TYPE_FLAGS: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_flags (real_value)); break; case G_TYPE_OBJECT: { GObject *object = g_value_get_object (real_value); if (object != NULL) { retval = json_node_new (JSON_NODE_OBJECT); json_node_take_object (retval, json_gobject_dump (object)); } else retval = json_node_new (JSON_NODE_NULL); } break; case G_TYPE_NONE: retval = json_node_new (JSON_NODE_NULL); break; default: g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value))); break; } return retval; }
static guint json_parse_array (JsonParser *parser, JsonScanner *scanner, JsonNode **node) { JsonParserPrivate *priv = parser->priv; JsonNode *old_current; JsonArray *array; guint token; gint idx; old_current = priv->current_node; priv->current_node = json_node_init_array (json_node_alloc (), NULL); array = json_array_new (); token = json_scanner_get_next_token (scanner); g_assert (token == G_TOKEN_LEFT_BRACE); g_signal_emit (parser, parser_signals[ARRAY_START], 0); idx = 0; while (token != G_TOKEN_RIGHT_BRACE) { guint next_token = json_scanner_peek_next_token (scanner); JsonNode *element = NULL; /* parse the element */ switch (next_token) { case G_TOKEN_LEFT_BRACE: JSON_NOTE (PARSER, "Nested array at index %d", idx); token = json_parse_array (parser, scanner, &element); break; case G_TOKEN_LEFT_CURLY: JSON_NOTE (PARSER, "Nested object at index %d", idx); token = json_parse_object (parser, scanner, &element); break; case G_TOKEN_RIGHT_BRACE: goto array_done; default: token = json_scanner_get_next_token (scanner); token = json_parse_value (parser, scanner, token, &element); break; } if (token != G_TOKEN_NONE || element == NULL) { /* the json_parse_* functions will have set the error code */ json_array_unref (array); json_node_free (priv->current_node); priv->current_node = old_current; return token; } next_token = json_scanner_peek_next_token (scanner); if (next_token == G_TOKEN_COMMA) { token = json_scanner_get_next_token (scanner); next_token = json_scanner_peek_next_token (scanner); /* look for trailing commas */ if (next_token == G_TOKEN_RIGHT_BRACE) { priv->error_code = JSON_PARSER_ERROR_TRAILING_COMMA; json_array_unref (array); json_node_free (priv->current_node); json_node_free (element); priv->current_node = old_current; return G_TOKEN_RIGHT_BRACE; } } JSON_NOTE (PARSER, "Array element %d completed", idx + 1); json_node_set_parent (element, priv->current_node); json_array_add_element (array, element); g_signal_emit (parser, parser_signals[ARRAY_ELEMENT], 0, array, idx); token = next_token; } array_done: json_scanner_get_next_token (scanner); json_node_take_array (priv->current_node, array); json_node_set_parent (priv->current_node, old_current); g_signal_emit (parser, parser_signals[ARRAY_END], 0, array); if (node != NULL && *node == NULL) *node = priv->current_node; priv->current_node = old_current; return G_TOKEN_NONE; }
/** * melo_jsonrpc_parse_request: * @request: the JSON-RPC requrest serialized in a string * @length: the length og @request, can be -1 for null-terminated string * @error: a pointer to a #GError which is set if an error occurred * * Parse a string @request containing a JSON-RPC serialized request, call the * registered callback which match the request method and present the result * as a JSON-RPC response serialized in a string. * If the method is not registered, a JSON-RPC response is generated with the * error MELO_JSONRPC_ERROR_METHOD_NOT_FOUND. * * Returns: (transfer full): a string containing the serialized #JsonNode * corresponding to the respond to the JSON-RPC request. Use g_free() after * usage. */ gchar * melo_jsonrpc_parse_request (const gchar *request, gsize length, GError **error) { JsonParser *parser; JsonNodeType type; JsonNode *req; JsonNode *res; GError *err = NULL; gchar *str; /* Create parser */ parser = json_parser_new (); if (!parser) return melo_jsonrpc_build_error_str (MELO_JSONRPC_ERROR_INTERNAL_ERROR, "Internal error"); /* Parse request */ if (!json_parser_load_from_data (parser, request, length, &err) || (req = json_parser_get_root (parser)) == NULL) { g_clear_error (&err); goto parse_error; } /* Get node type */ type = json_node_get_node_type (req); /* Parse node */ if (type == JSON_NODE_OBJECT) { /* Parse single request */ res = melo_jsonrpc_parse_node (req); } else if (type == JSON_NODE_ARRAY) { /* Parse multiple requests: batch */ JsonArray *req_array; JsonArray *res_array; JsonNode *node; guint count, i; /* Get array from node */ req_array = json_node_get_array (req); count = json_array_get_length (req_array); if (!count) goto invalid; /* Create a new array for response */ res_array = json_array_sized_new (count); res = json_node_new (JSON_NODE_ARRAY); json_node_take_array (res, res_array); /* Parse each elements of array */ for (i = 0; i < count; i++) { /* Get element */ node = json_array_get_element (req_array, i); /* Process requesit */ node = melo_jsonrpc_parse_node (node); /* Add new response to array */ if (node) json_array_add_element (res_array, node); } /* Check if array is empty */ count = json_array_get_length (res_array); if (!count) { json_node_free (res); goto empty; } } else goto invalid; /* No response */ if (!res) goto empty; /* Generate final string */ str = melo_jsonrpc_node_to_string (res); /* Free parser and root node */ json_node_free (res); g_object_unref (parser); return str; parse_error: g_object_unref (parser); return melo_jsonrpc_build_error_str (MELO_JSONRPC_ERROR_PARSE_ERROR, "Parse error"); invalid: g_object_unref (parser); return melo_jsonrpc_build_error_str (MELO_JSONRPC_ERROR_INVALID_REQUEST, "Invalid request"); empty: g_object_unref (parser); return NULL; }
static guint json_parse_array (JsonParser *parser, JsonScanner *scanner, JsonNode **node) { JsonParserPrivate *priv = parser->priv; JsonNode *old_current; JsonArray *array; guint token; gint idx; old_current = priv->current_node; priv->current_node = json_node_new (JSON_NODE_ARRAY); array = json_array_new (); token = json_scanner_get_next_token (scanner); g_assert (token == G_TOKEN_LEFT_BRACE); g_signal_emit (parser, parser_signals[ARRAY_START], 0); idx = 0; while (token != G_TOKEN_RIGHT_BRACE) { guint next_token = json_scanner_peek_next_token (scanner); JsonNode *element = NULL; /* parse the element */ switch (next_token) { case G_TOKEN_LEFT_BRACE: token = json_parse_array (parser, scanner, &element); break; case G_TOKEN_LEFT_CURLY: token = json_parse_object (parser, scanner, &element); break; case G_TOKEN_INT: case G_TOKEN_FLOAT: case G_TOKEN_STRING: case '-': case JSON_TOKEN_TRUE: case JSON_TOKEN_FALSE: case JSON_TOKEN_NULL: token = json_scanner_get_next_token (scanner); token = json_parse_value (parser, scanner, token, &element); break; case G_TOKEN_RIGHT_BRACE: goto array_done; default: if (next_token != G_TOKEN_RIGHT_BRACE) token = G_TOKEN_RIGHT_BRACE; break; } if (token != G_TOKEN_NONE || element == NULL) { /* the json_parse_* functions will have set the error code */ json_array_unref (array); json_node_free (priv->current_node); priv->current_node = old_current; return token; } next_token = json_scanner_peek_next_token (scanner); if (next_token == G_TOKEN_COMMA) { token = json_scanner_get_next_token (scanner); next_token = json_scanner_peek_next_token (scanner); /* look for trailing commas */ if (next_token == G_TOKEN_RIGHT_BRACE) { json_array_unref (array); json_node_free (priv->current_node); json_node_free (element); priv->current_node = old_current; return G_TOKEN_RIGHT_BRACE; } } json_node_set_parent (element, priv->current_node); json_array_add_element (array, element); g_signal_emit (parser, parser_signals[ARRAY_ELEMENT], 0, array, idx); token = next_token; } array_done: json_scanner_get_next_token (scanner); json_node_take_array (priv->current_node, array); json_node_set_parent (priv->current_node, old_current); g_signal_emit (parser, parser_signals[ARRAY_END], 0, array); if (node != NULL && *node == NULL) *node = priv->current_node; priv->current_node = old_current; return G_TOKEN_NONE; }