/* * gdata_parser_boolean_from_json_member: * @reader: #JsonReader cursor object to read the JSON node from * @member_name: the name of the JSON object member to parse * @options: a bitwise combination of parsing options from #GDataParserOptions, or %P_NONE * @output: (out caller-allocates): the return location for the parsed boolean value * @success: (out caller-allocates): the return location for a value which is %TRUE if the boolean was parsed successfully, %FALSE if an error was encountered, * and undefined if @member_name was not found in the current object in @reader * @error: (allow-none): a #GError, or %NULL * * Gets the boolean value of the @member_name member of the current object in the #JsonReader, subject to various checks specified by @options. * * If no member matching @member_name can be found in the current @reader JSON object, %FALSE will be returned, @error will be unset and @success will be unset. @output will be undefined. * * If @member_name is found but one of the checks specified by @options fails, %TRUE will be returned, @error will be set to a * %GDATA_SERVICE_ERROR_PROTOCOL_ERROR error and @success will be set to %FALSE. @output will be undefined. * * If @member_name is found and all of the checks specified by @options pass, %TRUE will be returned, @error will be unset and * @success will be set to %TRUE. @output will be set to the parsed value. * * The reason for returning the success of the parsing in @success is so that calls to gdata_parser_boolean_from_json_node() can be chained * together in a large "or" statement based on their return values, for the purposes of determining whether any of the calls matched * a given JSON node. If any of the calls to gdata_parser_boolean_from_json_node() return %TRUE, the value of @success can be examined. * * Return value: %TRUE if @member_name was found, %FALSE otherwise * * Since: 0.15.0 */ gboolean gdata_parser_boolean_from_json_member (JsonReader *reader, const gchar *member_name, GDataParserOptions options, gboolean *output, gboolean *success, GError **error) { gboolean val; const GError *child_error = NULL; /* Check if there's such an element. */ if (g_strcmp0 (json_reader_get_member_name (reader), member_name) != 0) { return FALSE; } /* Get the boolean. Check for parse errors. */ val = json_reader_get_boolean_value (reader); child_error = json_reader_get_error (reader); if (child_error != NULL) { *success = parser_error_from_json_error (reader, child_error, error); return TRUE; } /* Success! */ *output = val; *success = TRUE; return TRUE; }
int inputTransform(JsonParser *parser, Graph *graph) { JsonNode *root; JsonReader *reader; int num_nodes, num_edges; int i; root = json_parser_get_root(parser); reader = json_reader_new(root); // Is the graph directed ? json_reader_read_member(reader, "oriented") if(json_reader_get_boolean_value(reader)) { graph->directed = DIRECTED; } else { graph->directed = NOT_DIRECTED; } json_reader_end_member(reader); // Get the nodes json_reader_read_member(reader, "nodes"); if(json_reader_is_array(reader)) { // Allocate the memory for the nodes, and for the edges num_nodes = json_reader_count_elements(reader); graph->nodes = malloc(num_nodes * sizeof(Node)); graph->edges = malloc(num_nodes * sizeof(Edge *)); for(i=0; i < num_nodes; i++) { graph->edges[i] = malloc(num_nodes * sizeof(Edge)); } for(i=0; i < num_nodes; i++) { json_reader_read_element(reader, i); readNode(json_reader_get_value(reader), graph); json_reader_end_element(reader); } } json_reader_end_member(reader); // Get the edges json_reader_read_member(reader, "edges"); if(json_reader_is_array(reader)) { for(i=0; i < num_edges; i++) { json_reader_read_element(reader, i); reader(json_reader_get_value(reader), graph); json_reader_end_element(reader); } } json_reader_end_member(reader); return EXIT_SUCCESS; }
const gboolean getBool (JsonReader * reader, const gchar * member_name) { json_reader_read_member (reader, member_name); gboolean value = json_reader_get_boolean_value (reader); json_reader_end_member (reader); return value; }
/* Save key/values on the table in the stack if the value is an * object or an array, it calls recursively the function again. * * @param L, pointer to the L with nil on top of it; * @param reader, pointed to the first element of main object; * * returns: the table in the stack with all json values */ static void build_table_from_json_reader (lua_State *L, JsonReader *reader) { const GError *err = json_reader_get_error (reader); if (err != NULL) { GRL_WARNING ("Error when building json: %s", err->message); return; } if (lua_isnil (L, -1)) { /* In the first execution of this recursive call, the main json object * does not have a member name. The nil is in the top of the stack and * it shall be converted to the table with json content */ lua_pop (L, 1); } else if (lua_istable (L, -1)) { const gchar *member_name = json_reader_get_member_name (reader); if (member_name) lua_pushstring (L, member_name); } else if (!lua_isnumber (L, -1)) { GRL_DEBUG ("getting value to either table or array"); return; } if (json_reader_is_object (reader)) { guint index_member = 0; guint num_members = json_reader_count_members (reader); lua_createtable (L, num_members, 0); for (index_member = 0; index_member < num_members; index_member++) { json_reader_read_element (reader, index_member); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_array (reader)) { guint index_element = 0; guint num_elements = json_reader_count_elements (reader); lua_createtable (L, num_elements, 0); for (index_element = 0; index_element < num_elements; index_element++) { json_reader_read_element (reader, index_element); lua_pushinteger (L, index_element + 1); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_value (reader)) { if (json_reader_get_null_value (reader)) { lua_pushnil (L); } else { /* value of the element */ JsonNode *value = json_reader_get_value (reader); switch (json_node_get_value_type (value)) { case G_TYPE_STRING: lua_pushstring (L, json_reader_get_string_value (reader)); break; case G_TYPE_INT64: lua_pushinteger (L, json_reader_get_int_value (reader)); break; case G_TYPE_DOUBLE: lua_pushnumber (L, json_reader_get_double_value (reader)); break; case G_TYPE_BOOLEAN: lua_pushnumber (L, json_reader_get_boolean_value (reader)); break; default: GRL_DEBUG ("'%d' (json-node-type) is not being handled", (gint) json_node_get_value_type (value)); lua_pushnil (L); } } } if (lua_gettop (L) > 3) { /* save this key/value on previous table */ lua_settable (L, -3); } }
GList *dt_noiseprofile_get_matching(const dt_image_t *cimg) { JsonParser *parser = darktable.noiseprofile_parser; JsonReader *reader = NULL; GList *result = NULL; if(!parser) goto end; dt_print(DT_DEBUG_CONTROL, "[noiseprofile] looking for maker `%s', model `%s'\n", cimg->camera_maker, cimg->camera_model); JsonNode *root = json_parser_get_root(parser); reader = json_reader_new(root); json_reader_read_member(reader, "noiseprofiles"); // go through all makers const int n_makers = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d makers\n", n_makers); for(int i = 0; i < n_makers; i++) { json_reader_read_element(reader, i); json_reader_read_member(reader, "maker"); if(g_strstr_len(cimg->camera_maker, -1, json_reader_get_string_value(reader))) { dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found `%s' as `%s'\n", cimg->camera_maker, json_reader_get_string_value(reader)); // go through all models and check those json_reader_end_member(reader); json_reader_read_member(reader, "models"); const int n_models = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d models\n", n_models); for(int j = 0; j < n_models; j++) { json_reader_read_element(reader, j); json_reader_read_member(reader, "model"); if(!g_strcmp0(cimg->camera_model, json_reader_get_string_value(reader))) { dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %s\n", cimg->camera_model); // we got a match, return at most bufsize elements json_reader_end_member(reader); json_reader_read_member(reader, "profiles"); const int n_profiles = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d profiles\n", n_profiles); for(int k = 0; k < n_profiles; k++) { dt_noiseprofile_t tmp_profile = { 0 }; json_reader_read_element(reader, k); gchar** member_names = json_reader_list_members(reader); // do we want to skip this entry? if(is_member(member_names, "skip")) { json_reader_read_member(reader, "skip"); gboolean skip = json_reader_get_boolean_value(reader); json_reader_end_member(reader); if(skip) { json_reader_end_element(reader); g_strfreev(member_names); continue; } } // maker tmp_profile.maker = g_strdup(cimg->camera_maker); // model tmp_profile.model = g_strdup(cimg->camera_model); // name json_reader_read_member(reader, "name"); tmp_profile.name = g_strdup(json_reader_get_string_value(reader)); json_reader_end_member(reader); // iso json_reader_read_member(reader, "iso"); tmp_profile.iso = json_reader_get_double_value(reader); json_reader_end_member(reader); // a json_reader_read_member(reader, "a"); for(int a = 0; a < 3; a++) { json_reader_read_element(reader, a); tmp_profile.a[a] = json_reader_get_double_value(reader); json_reader_end_element(reader); } json_reader_end_member(reader); // b json_reader_read_member(reader, "b"); for(int b = 0; b < 3; b++) { json_reader_read_element(reader, b); tmp_profile.b[b] = json_reader_get_double_value(reader); json_reader_end_element(reader); } json_reader_end_member(reader); json_reader_end_element(reader); // everything worked out, add tmp_profile to result dt_noiseprofile_t *new_profile = (dt_noiseprofile_t *)malloc(sizeof(dt_noiseprofile_t)); *new_profile = tmp_profile; result = g_list_append(result, new_profile); g_strfreev(member_names); } // profiles goto end; } json_reader_end_member(reader); json_reader_end_element(reader); } // models } json_reader_end_member(reader); json_reader_end_element(reader); } // makers json_reader_end_member(reader); end: if(reader) g_object_unref(reader); if(result) result = g_list_sort(result, _sort_by_iso); return result; }
static void restore_state(session_callback_type type, gpointer data, gpointer user_data) { JsonParser* jp = NULL; JsonReader* jr = NULL; const gchar* sqs; saved_state* s = NULL; GError* err = NULL; /* Is it the callback we're interested in? */ if (type != SPOP_SESSION_LOGGED_IN) return; /* First disable the callback so it's not called again */ session_remove_callback(restore_state, NULL); g_debug("savestate: reading saved state..."); s = g_new0(saved_state, 1); /* Read and parse state file */ jp = json_parser_new(); if (!json_parser_load_from_file(jp, g_state_file_path, &err)) { g_warning("savestate: error while reading state file: %s", err->message); goto restorestate_error; } jr = json_reader_new(json_parser_get_root(jp)); /* Read basic state */ if (!json_reader_read_member(jr, "status")) goto restorestate_jr_error; sqs = json_reader_get_string_value(jr); json_reader_end_member(jr); if (strcmp(sqs, "stopped")) s->qs = STOPPED; else if (strcmp(sqs, "playing")) s->qs = PLAYING; else if (strcmp(sqs, "paused")) s->qs = PAUSED; else { g_warning("savestate: bad value for queue status: %s", sqs); goto restorestate_error; } if (!json_reader_read_member(jr, "repeat")) goto restorestate_jr_error; s->repeat = json_reader_get_boolean_value(jr); json_reader_end_member(jr); if (!json_reader_read_member(jr, "shuffle")) goto restorestate_jr_error; s->shuffle = json_reader_get_boolean_value(jr); json_reader_end_member(jr); if (!json_reader_read_member(jr, "current_track")) goto restorestate_jr_error; s->cur_track = json_reader_get_int_value(jr); json_reader_end_member(jr); /* Now read tracks URIs */ if (!json_reader_read_member(jr, "tracks")) goto restorestate_jr_error; if (!json_reader_is_array(jr)) { g_warning("savestate: error while parsing JSON: tracks is not an array"); goto restorestate_error; } gint tracks = json_reader_count_elements(jr); if (s->cur_track >= tracks) { g_warning("savestate: incoherent state file: cur_track >= tracks"); goto restorestate_error; } s->tracks = g_array_sized_new(FALSE, FALSE, sizeof(sp_track*), tracks); if (!s->tracks) g_error("Can't allocate array of %d tracks.", tracks); size_t i; gboolean can_restore_now = TRUE; for (i=0; i < tracks; i++) { json_reader_read_element(jr, i); const gchar* uri = json_reader_get_string_value(jr); json_reader_end_element(jr); sp_link* lnk = sp_link_create_from_string(uri); sp_linktype lt = sp_link_type(lnk); if (lt != SP_LINKTYPE_TRACK) { g_warning("savestate: invalid link type for track %zu: %d", i, lt); sp_link_release(lnk); goto restorestate_error; } sp_track* tr = sp_link_as_track(lnk); sp_track_add_ref(tr); sp_link_release(lnk); g_array_append_val(s->tracks, tr); if (!sp_track_is_loaded(tr)) can_restore_now = FALSE; } /* If possible, restore now, else wait for all tracks to be loaded */ if (can_restore_now) really_restore_state(s); else { g_timeout_add(100, (GSourceFunc) really_restore_state, s); g_debug("savestate: waiting for all tracks to be loaded before restoring saved state..."); } /* Add a notification callback */ if (!interface_notify_add_callback(savestate_notification_callback, NULL)) g_error("Could not add savestate callback."); goto restorestate_clean; restorestate_jr_error: err = (GError*) json_reader_get_error(jr); g_warning("savestate: error while parsing JSON: %s", err->message); restorestate_error: if (s) { if (s->tracks) g_array_free(s->tracks, TRUE); g_free(s); } restorestate_clean: if (jp) g_object_unref(jp); if (jr) g_object_unref(jr); }