/** * json_reader_get_double_value: * @reader: a #JsonReader * * Retrieves the floating point value of the current position of @reader * * Return value: the floating point value * * Since: 0.12 */ gdouble json_reader_get_double_value (JsonReader *reader) { JsonNode *node; g_return_val_if_fail (JSON_IS_READER (reader), 0.0); json_reader_return_val_if_error_set (reader, 0.0); if (reader->priv->current_node == NULL) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE, _("No node available at the current position")); return 0.0; } 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 0.0; } return json_node_get_double (reader->priv->current_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); }
gdouble trg_prefs_get_double(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_double(node); else return 0.0; }
/** * json_reader_get_double_value: * @reader: a #JsonReader * * Retrieves the floating point value of the current position of @reader * * Return value: the floating point value * * Since: 0.12 */ gdouble json_reader_get_double_value (JsonReader *reader) { g_return_val_if_fail (JSON_IS_READER (reader), 0.0); json_reader_return_val_if_error_set (reader, 0.0); if (reader->priv->current_node == NULL) return 0.0; if (!JSON_NODE_HOLDS_VALUE (reader->priv->current_node)) return 0.0; return json_node_get_double (reader->priv->current_node); }
/** * json_object_get_double_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that retrieves the floating point value * stored in @member_name of @object * * See also: json_object_get_member() * * Return value: the floating point value of the object's member * * Since: 0.8 */ gdouble json_object_get_double_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, 0.0); g_return_val_if_fail (member_name != NULL, 0.0); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, 0.0); g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE, 0.0); return json_node_get_double (node); }
/** * json_array_get_double_element: * @array: a #JsonArray * @index_: the index of the element to retrieve * * Conveniently retrieves the floating point value of the element at * @index_ inside @array * * See also: json_array_get_element(), json_node_get_double() * * Return value: the floating point value * * Since: 0.8 */ gdouble json_array_get_double_element (JsonArray *array, guint index_) { JsonNode *node; g_return_val_if_fail (array != NULL, 0.0); g_return_val_if_fail (index_ < array->elements->len, 0.0); node = g_ptr_array_index (array->elements, index_); g_return_val_if_fail (node != NULL, 0.0); g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE, 0.0); return json_node_get_double (node); }
static int output_json_node_value (JsonNode *node, PRN *prn) { GType type = 0; int err = 0; if (null_node(node)) { gretl_errmsg_set("jsonget: got a null node"); return E_DATA; } type = json_node_get_value_type(node); #if 0 fprintf(stderr, "jsonget: node type %s\n", g_type_name(type)); #endif if (!handled_type(type)) { gretl_errmsg_sprintf("jsonget: unhandled object type '%s'", g_type_name(type)); err = E_DATA; } else if (type == G_TYPE_STRING) { const gchar *s = json_node_get_string(node); if (s != NULL) { pputs(prn, s); } else { err = E_DATA; } } else if (type == G_TYPE_DOUBLE) { double x = json_node_get_double(node); pprintf(prn, "%.15g", x); } else { gint64 k = json_node_get_int(node); double x = (double) k; pprintf(prn, "%.15g", x); } return err; }
gdouble Settings::getDouble(const char* path){ JsonNode* node = getNode(path); gdouble value = json_node_get_double (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 (); } }
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; }
/* 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 int real_json_get (JsonParser *parser, const char *pathstr, int *n_objects, PRN *prn) { GError *gerr = NULL; JsonNode *match, *node; JsonPath *path; GType ntype; double x; int err = 0; *n_objects = 0; node = json_parser_get_root(parser); path = json_path_new(); if (!json_path_compile(path, pathstr, &gerr)) { if (gerr != NULL) { gretl_errmsg_sprintf("Failed to compile JsonPath: %s", gerr->message); g_error_free(gerr); } else { gretl_errmsg_set("Failed to compile JsonPath"); } g_object_unref(path); return E_DATA; } match = json_path_match(path, node); if (match == NULL) { /* FIXME : maybe return empty string? */ g_object_unref(path); return E_DATA; } /* in case we get floating-point output */ gretl_push_c_numeric_locale(); if (JSON_NODE_HOLDS_ARRAY(match)) { JsonArray *array; array = json_node_get_array(match); node = json_array_get_element(array, 0); repeat: if (node == NULL) { gretl_errmsg_set("Failed to match JsonPath"); ntype = 0; } else { ntype = json_node_get_value_type(node); } if (!handled_type(ntype)) { if (JSON_NODE_HOLDS_ARRAY(node)) { array = json_node_get_array(node); node = json_array_get_element(array, 0); goto repeat; } else { gretl_errmsg_sprintf("Unhandled array type '%s'", g_type_name(ntype)); err = E_DATA; } } else { int i, n = json_array_get_length(array); for (i=0; i<n; i++) { node = json_array_get_element(array, i); if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(node)); } else { x = json_node_get_double(node); pprintf(prn, "%.15g", x); } if (n > 1) { pputc(prn, '\n'); } } *n_objects = n; } } else { ntype = json_node_get_value_type(match); if (!handled_type(ntype)) { gretl_errmsg_sprintf("Unhandled object type '%s'", g_type_name(ntype)); err = E_DATA; } else { if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(match)); } else { x = json_node_get_double(match); pprintf(prn, "%.15g", x); } *n_objects = 1; } } gretl_pop_c_numeric_locale(); json_node_free(match); g_object_unref(path); return err; }
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; }