int
main (int argc, char *argv[])
{
MyFlowArrow *arrow;
MySystem *system;
JsonGenerator *gen = json_generator_new ();
JsonNode *node, *root;
JsonArray *array;
gchar *data;
gsize len;
gtk_init (NULL, NULL);
libgoffice_init ();
root = json_node_new (JSON_NODE_ARRAY);
array = json_array_new ();
arrow =
g_object_new (MY_TYPE_FLOW_ARROW,
"x0", 100.0,
"x1", 200.0,
"y0", 200.0,
"y1", 300.0,
"energy-quantity", -22.0,
"anchor", MY_ANCHOR_NORTH,
"label-text", "test", NULL);
node = json_gobject_serialize (G_OBJECT (arrow));
json_array_add_element (array, node);
system = g_object_new (MY_TYPE_SYSTEM, "x", 100.0, "y", 200.0, NULL);
node = json_gobject_serialize (G_OBJECT (system));
json_array_add_element (array, node);
json_node_set_array (root, array);
json_generator_set_root (gen, root);
json_generator_set_pretty (gen, TRUE);
data = json_generator_to_data (gen, &len);
g_print ("%s\n", data);
libgoffice_shutdown ();
return 0;
}
/**
* json_gobject_to_data:
* @gobject: a #GObject
* @length: (out): return value for the length of the buffer, or %NULL
*
* Serializes a #GObject into a JSON data stream, iterating recursively
* over each property.
*
* If @gobject implements the #JsonSerializableIface interface, it will
* be asked to serialize all its properties; otherwise, the default
* implementation will be use to translate the compatible types into
* JSON native types.
*
* Return value: a JSON data stream representing the passed #GObject
*
* Since: 0.10
*/
gchar *
json_gobject_to_data (GObject *gobject,
gsize *length)
{
JsonGenerator *gen;
JsonNode *root;
gchar *data;
g_return_val_if_fail (G_OBJECT (gobject), NULL);
root = json_gobject_serialize (gobject);
gen = g_object_new (JSON_TYPE_GENERATOR,
"root", root,
"pretty", TRUE,
"indent", 2,
NULL);
data = json_generator_to_data (gen, length);
g_object_unref (gen);
json_node_free (root);
return data;
}
JsonNode *
builder_source_to_json (BuilderSource *self)
{
JsonNode *node;
JsonObject *object;
const gchar *type = NULL;
node = json_gobject_serialize (G_OBJECT (self));
object = json_node_get_object (node);
if (BUILDER_IS_SOURCE_ARCHIVE (self))
type = "archive";
else if (BUILDER_IS_SOURCE_FILE (self))
type = "file";
else if (BUILDER_IS_SOURCE_SCRIPT (self))
type = "script";
else if (BUILDER_IS_SOURCE_SHELL (self))
type = "shell";
else if (BUILDER_IS_SOURCE_PATCH (self))
type = "patch";
else if (BUILDER_IS_SOURCE_GIT (self))
type = "git";
else if (BUILDER_IS_SOURCE_BZR (self))
type = "bzr";
else
g_warning ("Unknown source type");
if (type)
json_object_set_string_member (object, "type", type);
return node;
}
static JsonGenerator *
_model_to_generator (MexQueueModel *model)
{
gint i;
JsonArray *json_array;
JsonNode *root;
JsonGenerator *generator;
json_array = json_array_sized_new (mex_model_get_length (MEX_MODEL (model)));
for (i = 0; i < mex_model_get_length (MEX_MODEL (model)); i++)
{
MexContent *content;
JsonNode *content_node;
content = mex_model_get_content (MEX_MODEL (model), i);
content_node = json_gobject_serialize (G_OBJECT (content));
json_array_add_element (json_array, content_node);
}
generator = json_generator_new ();
root = json_node_new (JSON_NODE_ARRAY);
json_node_set_array (root, json_array);
json_generator_set_root (generator, root);
json_array_unref (json_array);
json_node_free (root);
return generator;
}
void
searpc_set_object_to_ret_object (JsonObject *object, GObject *ret)
{
if (ret == NULL)
json_object_set_null_member (object, "ret");
else {
json_object_set_member (object, "ret", json_gobject_serialize(ret));
g_object_unref (ret);
}
}
static json_t *json_serialize_pspec (const GValue *value)
{
/* Only types in json-glib but G_TYPE_BOXED */
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) {
case G_TYPE_STRING:
if (!g_value_get_string (value))
break;
else
return json_string (g_value_get_string (value));
case G_TYPE_BOOLEAN:
if (g_value_get_boolean (value))
return json_true ();
else return json_false ();
case G_TYPE_INT:
return json_integer (g_value_get_int (value));
case G_TYPE_UINT:
return json_integer (g_value_get_uint (value));
case G_TYPE_LONG:
return json_integer (g_value_get_long (value));
case G_TYPE_ULONG:
return json_integer (g_value_get_ulong (value));
case G_TYPE_INT64:
return json_integer (g_value_get_int64 (value));
case G_TYPE_FLOAT:
return json_real (g_value_get_float (value));
case G_TYPE_DOUBLE:
return json_real (g_value_get_double (value));
case G_TYPE_CHAR:
return json_integer (g_value_get_schar (value));
case G_TYPE_UCHAR:
return json_integer (g_value_get_uchar (value));
case G_TYPE_ENUM:
return json_integer (g_value_get_enum (value));
case G_TYPE_FLAGS:
return json_integer (g_value_get_flags (value));
case G_TYPE_NONE:
break;
case G_TYPE_OBJECT:
{
GObject *object = g_value_get_object (value);
if (object)
return json_gobject_serialize (object);
}
break;
defalut:
g_warning("Unsuppoted type `%s'",g_type_name (G_VALUE_TYPE (value)));
}
return json_null();
}
/*The function is copied from searpc-server.c for convience*/
void
searpc_set_objlist_to_ret_object (json_t *object, GList *ret)
{
GList *ptr;
if (ret == NULL)
json_object_set_new (object, "ret", json_null ());
else {
json_t *array = json_array ();
for (ptr = ret; ptr; ptr = ptr->next)
json_array_append_new (array, json_gobject_serialize (ptr->data));
json_object_set_new (object, "ret", array);
for (ptr = ret; ptr; ptr = ptr->next)
g_object_unref (ptr->data);
g_list_free (ret);
}
}
void
searpc_set_objlist_to_ret_object (JsonObject *object, GList *ret)
{
GList *ptr;
if (ret == NULL)
json_object_set_null_member (object, "ret");
else {
JsonArray *array = json_array_new ();
for (ptr = ret; ptr; ptr = ptr->next)
json_array_add_element (array, json_gobject_serialize (ptr->data));
json_object_set_array_member (object, "ret", array);
for (ptr = ret; ptr; ptr = ptr->next)
g_object_unref (ptr->data);
g_list_free (ret);
}
}
void
gt_favourites_manager_save(GtFavouritesManager* self)
{
GtFavouritesManagerPrivate* priv = gt_favourites_manager_get_instance_private(self);
if (g_list_length(self->favourite_channels) == 0)
return;
JsonArray* jarr = json_array_new();
JsonGenerator* gen = json_generator_new();
JsonNode* final = json_node_new(JSON_NODE_ARRAY);
gchar* fp = FAV_CHANNELS_FILE;
for (GList* l = self->favourite_channels; l != NULL; l = l->next)
{
JsonNode* node = json_gobject_serialize(l->data);
json_array_add_element(jarr, node);
}
final = json_node_init_array(final, jarr);
static JsonNode *
builder_options_serialize_property (JsonSerializable *serializable,
const gchar *property_name,
const GValue *value,
GParamSpec *pspec)
{
if (strcmp (property_name, "arch") == 0)
{
BuilderOptions *self = BUILDER_OPTIONS (serializable);
JsonNode *retval = NULL;
if (self->arch && g_hash_table_size (self->arch) > 0)
{
JsonObject *object;
GHashTableIter iter;
gpointer key, value;
object = json_object_new ();
g_hash_table_iter_init (&iter, self->arch);
while (g_hash_table_iter_next (&iter, &key, &value))
{
JsonNode *child = json_gobject_serialize (value);
json_object_set_member (object, (char *)key, child);
}
retval = json_node_init_object (json_node_alloc (), object);
json_object_unref (object);
}
return retval;
}
else if (strcmp (property_name, "env") == 0)
{
BuilderOptions *self = BUILDER_OPTIONS (serializable);
JsonNode *retval = NULL;
if (self->env && g_strv_length (self->env) > 0)
{
JsonObject *object;
int i;
object = json_object_new ();
for (i = 0; self->env[i] != NULL; i++)
{
JsonNode *str = json_node_new (JSON_NODE_VALUE);
const char *equal;
g_autofree char *member = NULL;
equal = strchr (self->env[i], '=');
if (equal)
{
json_node_set_string (str, equal + 1);
member = g_strndup (self->env[i], equal - self->env[i]);
}
else
{
json_node_set_string (str, "");
member = g_strdup (self->env[i]);
}
json_object_set_member (object, member, str);
}
retval = json_node_init_object (json_node_alloc (), object);
json_object_unref (object);
}
return retval;
}
else
return json_serializable_default_serialize_property (serializable,
property_name,
value,
pspec);
}
