static gboolean clutter_behaviour_path_parse_custom_node (ClutterScriptable *scriptable, ClutterScript *script, GValue *value, const gchar *name, JsonNode *node) { if (strcmp ("path", name) == 0) { ClutterPath *path; GValue node_value = { 0 }; path = g_object_ref_sink (clutter_path_new ()); json_node_get_value (node, &node_value); if (!G_VALUE_HOLDS (&node_value, G_TYPE_STRING) || !clutter_path_set_description (path, g_value_get_string (&node_value))) g_warning ("Invalid path description"); g_value_unset (&node_value); g_value_init (value, G_TYPE_OBJECT); g_value_take_object (value, path); return TRUE; } /* chain up */ else if (parent_scriptable_iface->parse_custom_node) return parent_scriptable_iface->parse_custom_node (scriptable, script, value, name, node); else return FALSE; }
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); } }
static gchar *dump_json_value(JsonNode * node) { GValue value = { 0, }; GString *buffer; buffer = g_string_new(""); json_node_get_value(node, &value); switch (G_VALUE_TYPE(&value)) { case G_TYPE_INT64: g_string_append_printf(buffer, "%" G_GINT64_FORMAT, g_value_get_int64(&value)); break; case G_TYPE_STRING: { gchar *tmp; tmp = g_strescape(g_value_get_string(&value), json_exceptions); g_string_append(buffer, tmp); g_free(tmp); } break; case G_TYPE_DOUBLE: { gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; g_string_append(buffer, g_ascii_dtostr(buf, sizeof(buf), g_value_get_double(&value))); } break; case G_TYPE_BOOLEAN: g_string_append_printf(buffer, "%s", g_value_get_boolean(&value) ? "true" : "false"); break; default: break; } g_value_unset(&value); return g_string_free(buffer, FALSE); }
static gboolean reader_fill_simple_gvalue (JsonReader *reader, TopicValueType type, GValue *value) { gboolean retval = TRUE; gint64 datetime; json_reader_read_member (reader, "value"); if (json_reader_get_error (reader) != NULL) { json_reader_end_member (reader); return FALSE; } switch (type) { case TYPE_BOOL: case TYPE_INT: case TYPE_DOUBLE: case TYPE_STRING: json_node_get_value (json_reader_get_value (reader), value); break; case TYPE_DATETIME: if (gdata_parser_int64_from_iso8601 (json_reader_get_string_value (reader), &datetime) || gdata_parser_int64_from_date (json_reader_get_string_value (reader), &datetime)) { g_value_init (value, G_TYPE_INT64); g_value_set_int64 (value, datetime); } else { retval = FALSE; } break; case TYPE_NONE: case TYPE_COMPOUND: case TYPE_OBJECT: case TYPE_KEY: case TYPE_URI: default: retval = FALSE; } json_reader_end_member (reader); return retval; }
/* * For a given parent @node, get the child node called @name and return a copy * of the content, or NULL. If the content is the empty string, NULL is * returned. */ char * get_child_node_value (JsonNode *node, const char *name) { JsonNode *subnode; JsonObject *object; GValue value = {0}; const char *string; char *result = NULL; if (!node || !name) return NULL; if (json_node_get_node_type (node) == JSON_NODE_OBJECT) { object = json_node_get_object (node); } else { return NULL; } if (!json_object_has_member (object, name)) { return NULL; } subnode = json_object_get_member (object, name); if (!subnode) return NULL; json_node_get_value (subnode, &value); string = g_value_get_string (&value); if (string && string[0]) { result = g_strdup (string); } g_value_unset (&value); return result; }
gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, JsonNode *node) { GValue node_value = { 0, }; gboolean retval = FALSE; if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED) { JsonNodeType node_type = json_node_get_node_type (node); GType boxed_type = G_VALUE_TYPE (value); if (json_boxed_can_deserialize (boxed_type, node_type)) { gpointer boxed = json_boxed_deserialize (boxed_type, node); g_value_take_boxed (value, boxed); return TRUE; } } switch (JSON_NODE_TYPE (node)) { case JSON_NODE_OBJECT: if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) { GObject *object; object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node)); if (object != NULL) g_value_take_object (value, object); else g_value_set_object (value, NULL); retval = TRUE; } break; case JSON_NODE_ARRAY: if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { JsonArray *array = json_node_get_array (node); guint i, array_len = json_array_get_length (array); GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1); for (i = 0; i < array_len; i++) { JsonNode *val = json_array_get_element (array, i); if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE) continue; if (json_node_get_string (val) != NULL) g_ptr_array_add (str_array, (gpointer) json_node_get_string (val)); } g_ptr_array_add (str_array, NULL); g_value_set_boxed (value, str_array->pdata); g_ptr_array_free (str_array, TRUE); retval = TRUE; } break; case JSON_NODE_VALUE: json_node_get_value (node, &node_value); #if 0 { gchar *node_str = g_strdup_value_contents (&node_value); g_debug ("%s: value type '%s' := node value type '%s' -> '%s'", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (G_VALUE_TYPE (&node_value)), node_str); g_free (node_str); } #endif switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: case G_TYPE_INT64: case G_TYPE_STRING: if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value))) { g_value_copy (&node_value, value); retval = TRUE; } break; case G_TYPE_INT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_int (value, (gint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_CHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint (value, (guint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UCHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_LONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_long (value, (glong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ULONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_ulong (value, (gulong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT64: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint64 (value, (guint64) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_DOUBLE: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_double (value, g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_FLOAT: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_float (value, (gfloat) g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ENUM: { gint enum_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { enum_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = enum_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &enum_value); } if (retval) g_value_set_enum (value, enum_value); } break; case G_TYPE_FLAGS: { gint flags_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { flags_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = flags_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &flags_value); } if (retval) g_value_set_flags (value, flags_value); } break; default: retval = FALSE; break; } g_value_unset (&node_value); break; case JSON_NODE_NULL: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string (value, NULL); retval = TRUE; } else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) { g_value_set_object (value, NULL); retval = TRUE; } else retval = FALSE; break; } return retval; }
static void ui_connection_handle_message(UiConnection *self, const gchar *protocol, const gchar *command, JsonObject *payload, SoupWebsocketConnection *ws) { if (g_strcmp0(protocol, "graph") == 0) { handle_graph_message(self, command, payload, ws); } else if (g_strcmp0(protocol, "network") == 0) { handle_network_message(self, command, payload, ws); } else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "list") == 0) { gint no_components = 0; gchar **operation_names = library_list_components(self->component_lib, &no_components); for (int i=0; i<no_components; i++) { const gchar *op = operation_names[i]; if (op) { JsonObject *component = library_get_component(self->component_lib, op); send_response(ws, "component", "component", component); } } g_strfreev(operation_names); } else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "source") == 0) { const gchar *name = json_object_get_string_member(payload, "name"); gchar *actual_name = library_set_source(self->component_lib, name, json_object_get_string_member(payload, "code") ); if (actual_name) { JsonObject *component = library_get_component(self->component_lib, name); send_response(ws, "component", "component", component); } else { // TODO: error response } g_free(actual_name); } else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "getsource") == 0) { const gchar *name = json_object_get_string_member(payload, "name"); JsonObject *source_info = json_object_new(); // TODO: generalize for subgraphs-as-components if (g_strcmp0(name, self->main_network) == 0) { json_object_set_string_member(source_info, "name", "main"); // FIXME: dont hardcode json_object_set_string_member(source_info, "library", "default"); // FIXME: dont hardcode Network *n = g_hash_table_lookup(self->network_map, self->main_network); g_assert(n); JsonObject *g = graph_save_json(n->graph); gsize len = 0; gchar *code = json_stringify(g, &len); g_assert(len); json_object_set_string_member(source_info, "language", "json"); json_object_set_string_member(source_info, "code", code); } else { json_object_set_string_member(source_info, "name", name); gchar *code = library_get_source(self->component_lib, name); json_object_set_string_member(source_info, "library", "imgflo"); json_object_set_string_member(source_info, "language", "c"); json_object_set_string_member(source_info, "code", code); } send_response(ws, "component", "source", source_info); } else if (g_strcmp0(protocol, "runtime") == 0 && g_strcmp0(command, "getruntime") == 0) { JsonObject *runtime = json_object_new(); json_object_set_string_member(runtime, "version", "0.4"); // protocol version json_object_set_string_member(runtime, "type", "imgflo"); json_object_set_string_member(runtime, "graph", self->main_network); JsonArray *capabilities = json_array_new(); json_array_add_string_element(capabilities, "protocol:component"); json_array_add_string_element(capabilities, "protocol:graph"); json_array_add_string_element(capabilities, "protocol:runtime"); json_array_add_string_element(capabilities, "protocol:network"); json_array_add_string_element(capabilities, "component:getsource"); json_array_add_string_element(capabilities, "component:setsource"); json_object_set_array_member(runtime, "capabilities", capabilities); send_response(ws, "runtime", "runtime", runtime); if (self->main_network) { send_ports(g_hash_table_lookup(self->network_map, self->main_network), ws); } } else if (g_strcmp0(protocol, "runtime") == 0 && g_strcmp0(command, "packet") == 0) { gchar *graph_id = g_strdup(json_object_get_string_member(payload, "graph")); const gchar *port = json_object_get_string_member(payload, "port"); const gchar *event = json_object_get_string_member(payload, "event"); if (!graph_id) { // NoFlo RemoteSubGraph currently does not send graph info graph_id = g_strdup(self->main_network); } Network *network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL; g_free(graph_id); g_return_if_fail(network); if (g_strcmp0(event, "data") == 0) { GValue data = G_VALUE_INIT; json_node_get_value(json_object_get_member(payload, "payload"), &data); network_send_packet(network, port, &data); } else { // TODO: support connect/disconnect? imgflo_warning("Unknown runtime:packet event: %s", event); } } else { imgflo_warning("Unhandled message: protocol='%s', command='%s'", protocol, command); } }
static void handle_graph_message(UiConnection *self, const gchar *command, JsonObject *payload, SoupWebsocketConnection *ws) { g_return_if_fail(payload); Graph *graph = NULL; if (g_strcmp0(command, "clear") != 0) { // All other commands must have graph // TODO: change FBP protocol to use 'graph' instead of 'id'? const gchar *graph_id = json_object_get_string_member(payload, "graph"); Network *net = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL; graph = (net) ? net->graph : NULL; g_return_if_fail(graph); } if (g_strcmp0(command, "clear") == 0) { const gchar *graph_id = json_object_get_string_member(payload, "id"); Graph *graph = graph_new(graph_id, self->component_lib); Network *network = network_new(graph); ui_connection_add_network(self, graph_id, network); } else if (g_strcmp0(command, "addnode") == 0) { graph_add_node(graph, json_object_get_string_member(payload, "id"), json_object_get_string_member(payload, "component") ); } else if (g_strcmp0(command, "removenode") == 0) { graph_remove_node(graph, json_object_get_string_member(payload, "id") ); } else if (g_strcmp0(command, "changenode") == 0) { // Just metadata, ignored } else if (g_strcmp0(command, "addinitial") == 0) { JsonObject *tgt = json_object_get_object_member(payload, "tgt"); JsonObject *src = json_object_get_object_member(payload, "src"); GValue data = G_VALUE_INIT; json_node_get_value(json_object_get_member(src, "data"), &data); graph_add_iip(graph, json_object_get_string_member(tgt, "node"), json_object_get_string_member(tgt, "port"), &data ); g_value_unset(&data); } else if (g_strcmp0(command, "removeinitial") == 0) { JsonObject *tgt = json_object_get_object_member(payload, "tgt"); graph_remove_iip(graph, json_object_get_string_member(tgt, "node"), json_object_get_string_member(tgt, "port") ); } else if (g_strcmp0(command, "addedge") == 0) { JsonObject *src = json_object_get_object_member(payload, "src"); JsonObject *tgt = json_object_get_object_member(payload, "tgt"); graph_add_edge(graph, json_object_get_string_member(src, "node"), json_object_get_string_member(src, "port"), json_object_get_string_member(tgt, "node"), json_object_get_string_member(tgt, "port") ); } else if (g_strcmp0(command, "removeedge") == 0) { JsonObject *src = json_object_get_object_member(payload, "src"); JsonObject *tgt = json_object_get_object_member(payload, "tgt"); graph_remove_edge(graph, json_object_get_string_member(src, "node"), json_object_get_string_member(src, "port"), json_object_get_string_member(tgt, "node"), json_object_get_string_member(tgt, "port") ); } else if (g_strcmp0(command, "changeedge") == 0) { // Just metadata, ignored } else { imgflo_warning("Unhandled message on protocol 'graph', command='%s'", command); } }
static void attach (GeglOperation *operation) { JsonOp *self = (JsonOp *)operation; GeglNode *gegl = operation->node; JsonArray *connections; GList *l; // Processes JsonObject *root = self->json_root; JsonObject *processes = json_object_get_object_member(root, "processes"); GList *process_names = json_object_get_members(processes); for (l = process_names; l != NULL; l = l->next) { const gchar *name = l->data; JsonObject *proc = json_object_get_object_member(processes, name); const gchar *component = json_object_get_string_member(proc, "component"); gchar *opname = component2geglop(component); GeglNode *node = gegl_node_new_child (gegl, "operation", opname, NULL); gegl_operation_meta_watch_node (operation, node); g_assert(node); g_hash_table_insert(self->nodes, (gpointer)g_strdup(name), (gpointer)node); g_free(opname); } g_list_free(process_names); // Connections connections = json_object_get_array_member(root, "connections"); g_assert(connections); for (int i=0; i<json_array_get_length(connections); i++) { JsonObject *conn = json_array_get_object_element(connections, i); JsonObject *tgt = json_object_get_object_member(conn, "tgt"); const gchar *tgt_proc = json_object_get_string_member(tgt, "process"); const gchar *tgt_port = json_object_get_string_member(tgt, "port"); GeglNode *tgt_node = g_hash_table_lookup(self->nodes, tgt_proc); JsonNode *srcnode; g_assert(tgt_node); srcnode = json_object_get_member(conn, "src"); if (srcnode) { // Connection JsonObject *src = json_object_get_object_member(conn, "src"); const gchar *src_proc = json_object_get_string_member(src, "process"); const gchar *src_port = json_object_get_string_member(src, "port"); GeglNode *src_node = g_hash_table_lookup(self->nodes, src_proc); g_assert(src_node); gegl_node_connect_to (src_node, src_port, tgt_node, tgt_port); } else { // IIP JsonNode *datanode = json_object_get_member(conn, "data"); GValue value = G_VALUE_INIT; GParamSpec *paramspec; g_assert(JSON_NODE_HOLDS_VALUE(datanode)); json_node_get_value(datanode, &value); paramspec = gegl_node_find_property(tgt_node, tgt_port); set_prop(tgt_node, tgt_port, paramspec, &value); g_value_unset(&value); } } // Exported ports if (json_object_has_member(root, "inports")) { JsonObject *inports = json_object_get_object_member(root, "inports"); GList *inport_names = json_object_get_members(inports); for (l = inport_names; l != NULL; l = l->next) { const gchar *name = l->data; JsonObject *conn = json_object_get_object_member(inports, name); const gchar *proc = json_object_get_string_member(conn, "process"); const gchar *port = json_object_get_string_member(conn, "port"); GeglNode *node = g_hash_table_lookup(self->nodes, proc); g_assert(node); if (g_strcmp0(name, "input") == 0) { GeglNode *input = gegl_node_get_input_proxy (gegl, "input"); gegl_node_connect_to (input, "output", node, "input"); } else { gegl_operation_meta_redirect (operation, name, node, port); } } g_list_free(inport_names); } if (json_object_has_member(root, "outports")) { JsonObject *outports = json_object_get_object_member(root, "outports"); GList *outport_names = json_object_get_members(outports); for (l = outport_names; l != NULL; l = l->next) { const gchar *name = l->data; JsonObject *conn = json_object_get_object_member(outports, name); const gchar *proc = json_object_get_string_member(conn, "process"); const gchar *port = json_object_get_string_member(conn, "port"); GeglNode *node = g_hash_table_lookup(self->nodes, proc); g_assert(node); if (g_strcmp0(name, "output") == 0) { GeglNode *proxy = gegl_node_get_output_proxy (gegl, "output"); gegl_node_connect_to (node, port, proxy, "input"); } else { g_warning("Unsupported output '%s' exported in .json file", name); } } g_list_free(outport_names); } }
//Constructor. GobjectImplScalar::GobjectImplScalar(JsonNode * const node):mNode(node),mValue(){ if (mNode && ((json_node_get_node_type(((mNode))) == (JSON_NODE_VALUE)))) { json_node_get_value(mNode,&mValue); //Fetch the value if possible. } }