static void
snra_json_node_into_val (JsonNode *element_node, GValue *v)
{
if (JSON_NODE_HOLDS_OBJECT (element_node)) {
GstStructure *child = snra_json_to_gst_structure (element_node);
g_value_init (v, GST_TYPE_STRUCTURE);
gst_value_set_structure (v, child);
} else if (JSON_NODE_HOLDS_ARRAY (element_node)) {
JsonArray *arr = json_node_get_array (element_node);
g_value_init (v, GST_TYPE_ARRAY);
json_array_foreach_element (arr,
(JsonArrayForeach) snra_json_array_add_to_val, v);
} else {
json_node_get_value (element_node, v);
}
}
int rm_json_cache_read(RmTrie *file_trie, const char *json_path) {
#if !HAVE_JSON_GLIB
(void)file_trie;
(void)json_path;
rm_log_info_line(_("caching is not supported due to missing json-glib library."));
return EXIT_FAILURE;
#else
rm_assert_gentle(file_trie);
rm_assert_gentle(json_path);
int result = EXIT_FAILURE;
GError *error = NULL;
size_t keys_in_table = rm_trie_size(file_trie);
JsonParser *parser = json_parser_new();
rm_log_info_line(_("Loading json-cache `%s'"), json_path);
if(!json_parser_load_from_file(parser, json_path, &error)) {
rm_log_warning_line(_("FAILED: %s\n"), error->message);
g_error_free(error);
goto failure;
}
JsonNode *root = json_parser_get_root(parser);
if(JSON_NODE_TYPE(root) != JSON_NODE_ARRAY) {
rm_log_warning_line(_("No valid json cache (no array in /)"));
goto failure;
}
/* Iterate over all objects in it */
json_array_foreach_element(json_node_get_array(root),
(JsonArrayForeach)rm_json_cache_parse_entry,
file_trie);
/* check if some entries were added */
result = (keys_in_table >= rm_trie_size(file_trie));
failure:
if(parser) {
g_object_unref(parser);
}
return result;
#endif
}
i3ipcCon *i3ipc_con_new(i3ipcCon *parent, JsonObject *data, i3ipcConnection *conn) {
i3ipcCon *con;
con = g_object_new(I3IPC_TYPE_CON, NULL);
g_object_ref(conn);
con->priv->conn = conn;
if (!json_object_get_null_member(data, "percent"))
con->priv->percent = json_object_get_double_member(data, "percent");
if (!json_object_get_null_member(data, "window"))
con->priv->window = json_object_get_int_member(data, "window");
if (json_object_has_member(data, "window_properties")) {
JsonObject *window_properties = json_object_get_object_member(data, "window_properties");
if (json_object_has_member(window_properties, "class"))
con->priv->window_class = g_strdup(json_object_get_string_member(window_properties, "class"));
}
if (json_object_has_member(data, "mark")) {
con->priv->mark = g_strdup(json_object_get_string_member(data, "mark"));
}
con->priv->name = g_strdup(json_object_get_string_member(data, "name"));
con->priv->focused = json_object_get_boolean_member(data, "focused");
con->priv->fullscreen_mode = json_object_get_boolean_member(data, "fullscreen_mode");
con->priv->urgent = json_object_get_boolean_member(data, "urgent");
con->priv->layout = g_strdup(json_object_get_string_member(data, "layout"));
con->priv->orientation = g_strdup(json_object_get_string_member(data, "orientation"));
con->priv->current_border_width = json_object_get_int_member(data, "current_border_width");
con->priv->border = g_strdup(json_object_get_string_member(data, "border"));
con->priv->id = json_object_get_int_member(data, "id");
JsonNode *con_type_node = json_object_get_member(data, "type");
/* XXX: In the development version, the "type" property is a string of the
* type, but in the current stable version (4.7.2) it is an integer as
* defined in i3's data header. When the next version comes out, the case
* where type is a number should be removed. */
if (json_node_get_value_type(con_type_node) == G_TYPE_STRING) {
con->priv->type = g_strdup(json_node_get_string(con_type_node));
} else {
int con_type_int = (int)json_node_get_int(con_type_node);
switch (con_type_int)
{
case 0:
con->priv->type = g_strdup("root");
break;
case 1:
con->priv->type = g_strdup("output");
break;
case 2:
case 3:
con->priv->type = g_strdup("con");
break;
case 4:
con->priv->type = g_strdup("workspace");
break;
case 5:
con->priv->type = g_strdup("dockarea");
break;
}
}
if (parent) {
g_object_ref(parent);
con->priv->parent = parent;
}
JsonObject *rect_data = json_object_get_object_member(data, "rect");
con->priv->rect->x = json_object_get_int_member(rect_data, "x");
con->priv->rect->y = json_object_get_int_member(rect_data, "y");
con->priv->rect->width = json_object_get_int_member(rect_data, "width");
con->priv->rect->height = json_object_get_int_member(rect_data, "height");
if (json_object_has_member(data, "deco_rect")) {
JsonObject *deco_rect_data = json_object_get_object_member(data, "deco_rect");
con->priv->deco_rect->x = json_object_get_int_member(deco_rect_data, "x");
con->priv->deco_rect->y = json_object_get_int_member(deco_rect_data, "y");
con->priv->deco_rect->width = json_object_get_int_member(deco_rect_data, "width");
con->priv->deco_rect->height = json_object_get_int_member(deco_rect_data, "height");
}
JsonArray *nodes_array = json_object_get_array_member(data, "nodes");
json_array_foreach_element(nodes_array, i3ipc_con_initialize_nodes, con);
JsonArray *floating_nodes_array = json_object_get_array_member(data, "floating_nodes");
json_array_foreach_element(floating_nodes_array, i3ipc_con_initialize_floating_nodes, con);
JsonArray *focus_array = json_object_get_array_member(data, "focus");
guint len = json_array_get_length(focus_array);
for (int i = 0; i < len; i += 1) {
con->priv->focus = g_list_append(con->priv->focus, GINT_TO_POINTER(json_array_get_int_element(focus_array, i)));
}
return con;
}
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 void ease_flickr_service_real_parse_data (EasePluginImportService* base, const char* jsondata) {
#line 298 "ease-import-flickr-service.c"
EaseFlickrService * self;
JsonObject* obj;
char* stat;
JsonObject* photos;
JsonArray* photo_array;
GError * _inner_error_ = NULL;
self = (EaseFlickrService*) base;
#line 91 "ease-import-flickr-service.vala"
g_return_if_fail (jsondata != NULL);
#line 93 "ease-import-flickr-service.vala"
if (jsondata == NULL) {
#line 93 "ease-import-flickr-service.vala"
return;
#line 312 "ease-import-flickr-service.c"
}
{
#line 97 "ease-import-flickr-service.vala"
json_parser_load_from_data (self->priv->parser, jsondata, -1, &_inner_error_);
#line 317 "ease-import-flickr-service.c"
if (_inner_error_ != NULL) {
goto __catch7_g_error;
}
}
goto __finally7;
__catch7_g_error:
{
GError * e;
e = _inner_error_;
_inner_error_ = NULL;
{
#line 101 "ease-import-flickr-service.vala"
g_error ("ease-import-flickr-service.vala:101: Couldn't parse JSON data: %s", e->message);
#line 331 "ease-import-flickr-service.c"
_g_error_free0 (e);
}
}
__finally7:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
#line 104 "ease-import-flickr-service.vala"
obj = _json_object_ref0 (json_node_get_object (json_parser_get_root (self->priv->parser)));
#line 106 "ease-import-flickr-service.vala"
stat = g_strdup (json_object_get_string_member (obj, "stat"));
#line 107 "ease-import-flickr-service.vala"
if (_vala_strcmp0 (stat, "ok") != 0) {
#line 109 "ease-import-flickr-service.vala"
g_warning ("ease-import-flickr-service.vala:109: The request failed : \n" \
"Error code: %G\n" \
"Message: %s", (double) json_object_get_int_member (obj, "code"), json_object_get_string_member (obj, "message"));
#line 349 "ease-import-flickr-service.c"
_g_free0 (stat);
_json_object_unref0 (obj);
#line 112 "ease-import-flickr-service.vala"
return;
#line 354 "ease-import-flickr-service.c"
}
#line 115 "ease-import-flickr-service.vala"
photos = _json_object_ref0 (json_object_get_object_member (obj, "photos"));
#line 116 "ease-import-flickr-service.vala"
photo_array = _json_array_ref0 (json_object_get_array_member (photos, "photo"));
#line 119 "ease-import-flickr-service.vala"
json_array_foreach_element (photo_array, __lambda70__json_array_foreach, self);
#line 362 "ease-import-flickr-service.c"
_json_array_unref0 (photo_array);
_json_object_unref0 (photos);
_g_free0 (stat);
_json_object_unref0 (obj);
}
static void _process_poll_resp(SoupSession *ss, SoupMessage *msg, gpointer user_data)
{
GWQSession *wqs;
const guint8* data;
gsize size;
SoupBuffer *sBuf;
gchar *tmpCStr;
JsonParser *jParser;
JsonNode *jn;
JsonObject *jo;
gint32 tmpInt;
SoupURI *su;
JsonArray *resJa;
wqs = (GWQSession*)user_data;
GWQ_DBG("poll responsed, retcode=%d, reason:%s\n", msg->status_code, msg->reason_phrase);
if (wqs->st != GWQS_ST_IDLE) {
goto ERR_OUT;
}
if (msg->status_code != 200) {
GWQ_ERR_OUT(ERR_OUT, "\n");
}
sBuf = soup_message_body_flatten(msg->response_body);
if (!sBuf) {
GWQ_ERR_OUT(ERR_OUT, "\n");
}
soup_buffer_get_data(sBuf, &data, &size);
if (!data || size <=0 ) {
GWQ_ERR_OUT(ERR_FREE_SBUF, "\n");
}
GWQ_DBG("bodySize=%d\nbody:%s\n", size, data);
if (!(jParser = json_parser_new())) {
GWQ_ERR_OUT(ERR_FREE_SBUF, "\n");
}
resJa = NULL;
if (!json_parser_load_from_data(jParser, (const gchar*)data, size, NULL)) {
GWQ_ERR("\n");
} else if (!(jn = json_parser_get_root(jParser))
|| !(jo = json_node_get_object(jn))) {
GWQ_ERR("\n");
} else if ((tmpInt = json_object_get_int_member(jo, "retcode"))) {
GWQ_ERR("poll retcode=%d\n", tmpInt);
} else if (!(jn = json_object_get_member(jo, "result"))
|| !(resJa = json_node_get_array(jn))) {
GWQ_ERR("poll no result found\n");
}
if (resJa) {
json_array_foreach_element(resJa, _PollResultArrayForeach, wqs);
}
g_object_unref(jParser);
soup_buffer_free(sBuf);
tmpCStr = g_strdup_printf("clientid=%s&psessionid=%s&t=%ld",
wqs->clientId->str, wqs->psessionid->str, GetNowMillisecond()
);
su = soup_message_get_uri(msg);
soup_uri_set_query(su, tmpCStr);
g_free(tmpCStr);
GWQ_ERR("Fix me : why soup_session_requeue_message() fails here!!!!!!!!!!!!!!!!!!!!!\n");
//soup_session_requeue_message(wqs->sps, msg);
GWQSessionDoPoll(wqs);
return;
ERR_FREE_J_PARSER:
g_object_unref(jParser);
ERR_FREE_SBUF:
soup_buffer_free(sBuf);
ERR_OUT:
soup_session_cancel_message(ss, msg, SOUP_STATUS_CANCELLED);
}
