/** * json_parser_load_from_data: * @parser: a #JsonParser * @data: the buffer to parse * @length: the length of the buffer, or -1 * @error: return location for a #GError, or %NULL * * Loads a JSON stream from a buffer and parses it. You can call this function * multiple times with the same #JsonParser object, but the contents of the * parser will be destroyed each time. * * Return value: %TRUE if the buffer was succesfully parser. In case * of error, @error is set accordingly and %FALSE is returned */ gboolean json_parser_load_from_data (JsonParser *parser, const gchar *data, gssize length, GError **error) { JsonParserPrivate *priv; GError *internal_error; gboolean retval = TRUE; g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE); g_return_val_if_fail (data != NULL, FALSE); priv = parser->priv; if (length < 0) length = strlen (data); priv->is_filename = FALSE; g_free (priv->filename); priv->filename = NULL; internal_error = NULL; if (!json_parser_load (parser, data, length, &internal_error)) { g_propagate_error (error, internal_error); retval = FALSE; } return retval; }
/** * json_parser_load_from_stream_finish: * @parser: a #JsonParser * @result: a #GAsyncResult * @error: the return location for a #GError or %NULL * * Finishes an asynchronous stream loading started with * json_parser_load_from_stream_async(). * * Return value: %TRUE if the content of the stream was successfully retrieves * and parsed, and %FALSE otherwise. In case of error, the #GError will be * filled accordingly. * * Since: 0.12 */ gboolean json_parser_load_from_stream_finish (JsonParser *parser, GAsyncResult *result, GError **error) { gboolean res; g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE); g_return_val_if_fail (g_task_is_valid (result, parser), FALSE); res = g_task_propagate_boolean (G_TASK (result), error); if (res) { LoadData *data = g_task_get_task_data (G_TASK (result)); GError *internal_error = NULL; /* We need to do this inside the finis() function because JsonParser will emit * signals, and we need to ensure that the signals are emitted in the right * context; it's easier to do that if we just rely on the async callback being * called in the right context, even if it means making the finish() function * necessary to complete the async operation. */ res = json_parser_load (parser, (const gchar *) data->content->data, data->pos, &internal_error); if (internal_error != NULL) g_propagate_error (error, internal_error); } return res; }
/** * json_parser_load_from_stream: * @parser: a #JsonParser * @stream: an open #GInputStream * @cancellable: (allow-none): a #GCancellable, or %NULL * @error: the return location for a #GError, or %NULL * * Loads the contents of an input stream and parses them. * * If @cancellable is not %NULL, then the operation can be cancelled by * triggering the @cancellable object from another thread. If the * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be set * on the passed @error. * * Return value: %TRUE if the data stream was successfully read and * parsed, and %FALSE otherwise * * Since: 0.12 */ gboolean json_parser_load_from_stream (JsonParser *parser, GInputStream *stream, GCancellable *cancellable, GError **error) { GByteArray *content; gsize pos; gssize res; gboolean retval = FALSE; GError *internal_error; g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE); g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE); g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE); if (g_cancellable_set_error_if_cancelled (cancellable, error)) return FALSE; content = g_byte_array_new (); pos = 0; g_byte_array_set_size (content, pos + GET_DATA_BLOCK_SIZE + 1); while ((res = g_input_stream_read (stream, content->data + pos, GET_DATA_BLOCK_SIZE, cancellable, error)) > 0) { pos += res; g_byte_array_set_size (content, pos + GET_DATA_BLOCK_SIZE + 1); } if (res < 0) { /* error has already been set */ retval = FALSE; goto out; } /* zero-terminate the content; we allocated an extra byte for this */ content->data[pos] = 0; internal_error = NULL; retval = json_parser_load (parser, (const gchar *) content->data, content->len, &internal_error); if (internal_error != NULL) g_propagate_error (error, internal_error); out: g_byte_array_free (content, TRUE); return retval; }
/** * json_parser_load_from_stream_finish: * @parser: a #JsonParser * @result: a #GAsyncResult * @error: the return location for a #GError or %NULL * * Finishes an asynchronous stream loading started with * json_parser_load_from_stream_async(). * * Return value: %TRUE if the content of the stream was successfully retrieves * and parsed, and %FALSE otherwise. In case of error, the #GError will be * filled accordingly. * * Since: 0.12 */ gboolean json_parser_load_from_stream_finish (JsonParser *parser, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple; GError *internal_error; LoadStreamData *data; gboolean res; g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE); g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE); simple = G_SIMPLE_ASYNC_RESULT (result); if (g_simple_async_result_propagate_error (simple, error)) return FALSE; g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == json_parser_load_from_stream_async); data = g_simple_async_result_get_op_res_gpointer (simple); if (data->error) { g_propagate_error (error, data->error); data->error = NULL; return FALSE; } g_byte_array_set_size (data->content, data->pos + 1); data->content->data[data->pos] = 0; internal_error = NULL; res = json_parser_load (parser, (const gchar *) data->content->data, data->content->len, &internal_error); if (internal_error != NULL) g_propagate_error (error, internal_error); return res; }
/** * json_parser_load_from_file: * @parser: a #JsonParser * @filename: the path for the file to parse * @error: return location for a #GError, or %NULL * * Loads a JSON stream from the content of @filename and parses it. See * json_parser_load_from_data(). * * Return value: %TRUE if the file was successfully loaded and parsed. * In case of error, @error is set accordingly and %FALSE is returned */ gboolean json_parser_load_from_file (JsonParser *parser, const gchar *filename, GError **error) { JsonParserPrivate *priv; GError *internal_error; gchar *data; gsize length; gboolean retval = TRUE; g_return_val_if_fail (JSON_IS_PARSER (parser), FALSE); g_return_val_if_fail (filename != NULL, FALSE); priv = parser->priv; internal_error = NULL; if (!g_file_get_contents (filename, &data, &length, &internal_error)) { g_propagate_error (error, internal_error); return FALSE; } g_free (priv->filename); priv->is_filename = TRUE; priv->filename = g_strdup (filename); if (!json_parser_load (parser, data, length, &internal_error)) { g_propagate_error (error, internal_error); retval = FALSE; } g_free (data); return retval; }