[glib/wip/serializable: 5/6] Add encoder and serializer
- From: Emmanuele Bassi <ebassi src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glib/wip/serializable: 5/6] Add encoder and serializer
- Date: Fri, 24 May 2013 14:03:18 +0000 (UTC)
commit bb3e3d01c3f3c8ed66cb6fee2004244130011e5b
Author: Emmanuele Bassi <ebassi gnome org>
Date: Fri May 24 15:00:02 2013 +0100
Add encoder and serializer
This commit will likely be split into four parts: one adding GEncoder;
one adding GSerializable; and two adding the binary and keyfile
encoders. The GBinaryEncoder could be renamed GBufferEncoder or
GDataEncoder.
gio/Makefile.am | 8 +
gio/gbinaryencoder.c | 98 ++++++++
gio/gbinaryencoder.h | 29 +++
gio/gencoder.c | 662 +++++++++++++++++++++++++++++++++++++++++++++++++
gio/gencoder.h | 155 ++++++++++++
gio/gio.h | 4 +
gio/giotypes.h | 4 +
gio/gkeyfileencoder.c | 372 +++++++++++++++++++++++++++
gio/gkeyfileencoder.h | 35 +++
gio/gserializable.c | 95 +++++++
gio/gserializable.h | 81 ++++++
11 files changed, 1543 insertions(+), 0 deletions(-)
---
diff --git a/gio/Makefile.am b/gio/Makefile.am
index ff66263..bbf57f1 100644
--- a/gio/Makefile.am
+++ b/gio/Makefile.am
@@ -337,6 +337,7 @@ libgio_2_0_la_SOURCES = \
gasynchelper.h \
gasyncinitable.c \
gasyncresult.c \
+ gbinaryencoder.c \
gbufferedinputstream.c \
gbufferedoutputstream.c \
gbytesicon.c \
@@ -359,6 +360,7 @@ libgio_2_0_la_SOURCES = \
gemblem.c \
gemblemedicon.h \
gemblemedicon.c \
+ gencoder.c \
gfile.c \
gfileattribute.c \
gfileattribute-priv.h \
@@ -385,6 +387,7 @@ libgio_2_0_la_SOURCES = \
giomodule-priv.h \
gioscheduler.c \
giostream.c \
+ gkeyfileencoder.c \
gloadableicon.c \
gmount.c \
gmemoryinputstream.c \
@@ -415,6 +418,7 @@ libgio_2_0_la_SOURCES = \
gresourcefile.c \
gresourcefile.h \
gseekable.c \
+ gserializable.c \
gsimpleasyncresult.c \
gsimplepermission.c \
gsocket.c \
@@ -518,6 +522,7 @@ gio_headers = \
gappinfo.h \
gasyncinitable.h \
gasyncresult.h \
+ gbinaryencoder.h \
gbufferedinputstream.h \
gbufferedoutputstream.h \
gbytesicon.h \
@@ -532,6 +537,7 @@ gio_headers = \
gdrive.h \
gemblem.h \
gemblemedicon.h \
+ gencoder.h \
gfile.h \
gfileattribute.h \
gfileenumerator.h \
@@ -557,6 +563,7 @@ gio_headers = \
giomodule.h \
gioscheduler.h \
giostream.h \
+ gkeyfileencoder.h \
gloadableicon.h \
gmount.h \
gmemoryinputstream.h \
@@ -579,6 +586,7 @@ gio_headers = \
gresolver.h \
gresource.h \
gseekable.h \
+ gserializable.h \
gsimpleasyncresult.h \
gsimplepermission.h \
gsocket.h \
diff --git a/gio/gbinaryencoder.c b/gio/gbinaryencoder.c
new file mode 100644
index 0000000..dd80ffc
--- /dev/null
+++ b/gio/gbinaryencoder.c
@@ -0,0 +1,98 @@
+#include "config.h"
+
+#include "gbinaryencoder.h"
+#include "gencoder.h"
+#include "gioerror.h"
+#include "glibintl.h"
+
+#include <string.h>
+
+struct _GBinaryEncoder
+{
+ GEncoder parent_instance;
+};
+
+struct _GBinaryEncoderClass
+{
+ GEncoderClass parent_class;
+};
+
+G_DEFINE_TYPE (GBinaryEncoder, g_binary_encoder, G_TYPE_ENCODER)
+
+static gboolean
+g_binary_encoder_read_from_bytes (GEncoder *encoder,
+ GBytes *buffer,
+ GError **error)
+{
+ GError *internal_error;
+ GVariant *v, *entry;
+ GVariantIter iter;
+
+ internal_error = NULL;
+ v = g_variant_parse (G_VARIANT_TYPE ("a{sv}"),
+ g_bytes_get_data (buffer, NULL),
+ NULL,
+ NULL,
+ &internal_error);
+ if (internal_error != NULL)
+ {
+ g_set_error (error, G_IO_ERROR,
+ G_IO_ERROR_INVALID_DATA,
+ "Unable to parse encoded buffer: %s",
+ internal_error->message);
+ g_error_free (internal_error);
+ return FALSE;
+ }
+
+ g_variant_iter_init (&iter, v);
+ while ((entry = g_variant_iter_next_value (&iter)) != NULL)
+ {
+ GVariant *key = g_variant_get_child_value (entry, 0);
+ GVariant *tmp = g_variant_get_child_value (entry, 1);
+ GVariant *value;
+
+ value = g_variant_get_variant (tmp);
+
+ g_encoder_add_key (encoder,
+ g_variant_get_string (key, NULL),
+ value);
+
+ g_variant_unref (value);
+ g_variant_unref (tmp);
+ g_variant_unref (key);
+ }
+
+ g_variant_unref (v);
+
+ return TRUE;
+}
+
+static GBytes *
+g_binary_encoder_write_to_bytes (GEncoder *encoder,
+ GError **error)
+{
+ GVariant *v = g_encoder_close (encoder);
+ char *buf = g_variant_print (v, FALSE);
+
+ return g_bytes_new_take (buf, strlen (buf));
+}
+
+static void
+g_binary_encoder_class_init (GBinaryEncoderClass *klass)
+{
+ GEncoderClass *encoder_class = G_ENCODER_CLASS (klass);
+
+ encoder_class->read_from_bytes = g_binary_encoder_read_from_bytes;
+ encoder_class->write_to_bytes = g_binary_encoder_write_to_bytes;
+}
+
+static void
+g_binary_encoder_init (GBinaryEncoder *self)
+{
+}
+
+GEncoder *
+g_binary_encoder_new (void)
+{
+ return g_object_new (G_TYPE_BINARY_ENCODER, NULL);
+}
diff --git a/gio/gbinaryencoder.h b/gio/gbinaryencoder.h
new file mode 100644
index 0000000..8d52510
--- /dev/null
+++ b/gio/gbinaryencoder.h
@@ -0,0 +1,29 @@
+#ifndef __G_BINARY_ENCODER_H__
+#define __G_BINARY_ENCODER_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_BINARY_ENCODER (g_binary_encoder_get_type ())
+#define G_BINARY_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_BINARY_ENCODER,
GBinaryEncoder))
+#define G_IS_BINARY_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_BINARY_ENCODER))
+#define G_BINARY_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_TYPE_BINARY_ENCODER,
GBinaryEncoderClass))
+#define G_IS_BINARY_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_TYPE_BINARY_ENCODER))
+#define G_BINARY_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_BINARY_ENCODER,
GBinaryEncoderClass))
+
+typedef struct _GBinaryEncoderClass GBinaryEncoderClass;
+
+GLIB_AVAILABLE_IN_2_38
+GType g_binary_encoder_get_type (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_38
+GEncoder * g_binary_encoder_new (void);
+
+G_END_DECLS
+
+#endif /* __G_BINARY_ENCODER_H__ */
diff --git a/gio/gencoder.c b/gio/gencoder.c
new file mode 100644
index 0000000..435ab72
--- /dev/null
+++ b/gio/gencoder.c
@@ -0,0 +1,662 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2013 Emmanuele Bassi <ebassi gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:gencoder
+ * @Title: GEncoder
+ * @Short_Description: Encodes and decodes key and value pairs
+ *
+ * #GEncoder is an abstract class that provides an API to store (encoder) and
+ * retrieve (decode) key, value pairs from memory or disk.
+ *
+ * Implementations of #GEncoder are required to provide the code to read a
+ * data storage in the form of a #GBytes and place its contents into the
+ * #GEncoder, and the code to write the contents of the #GEncoder into a
+ * #GBytes. It is not necessary for a #GEncoder to provide both encoding
+ * and decoding: if the #GEncoder sub-class provides only the implementation
+ * of the #GEncoderClass.read_from_bytes() virtual function it is called a
+ * "decoder"; alternatively, if it only provides the implementation of the
+ * the #GEncoderClass.write_to_bytes() virtual function it is called an
+ * "encoder".
+ */
+
+#include "config.h"
+
+#include "gencoder.h"
+#include "glibintl.h"
+
+#include <string.h>
+
+#define G_ENCODER_PRIVATE(obj) (&G_STRUCT_MEMBER (GEncoderPrivate, (obj), g_encoder_private_offset))
+
+typedef struct _GEncoderPrivate GEncoderPrivate;
+typedef struct _EncoderValue EncoderValue;
+
+#define ENCODER_LOCKED 1
+#define ENCODER_CLOSED 2
+
+struct _GEncoderPrivate
+{
+ GHashTable *values;
+ GVariant *encoded;
+
+ gint flags;
+};
+
+static gint g_encoder_private_offset = 0;
+
+G_DEFINE_ABSTRACT_TYPE (GEncoder, g_encoder, G_TYPE_OBJECT)
+
+static inline void
+g_encoder_lock (GEncoder *encoder)
+{
+ GEncoderPrivate *priv = G_ENCODER_PRIVATE (encoder);
+
+ g_bit_lock (&priv->flags, ENCODER_LOCKED);
+}
+
+static inline void
+g_encoder_unlock (GEncoder *encoder)
+{
+ GEncoderPrivate *priv = G_ENCODER_PRIVATE (encoder);
+
+ g_bit_unlock (&priv->flags, ENCODER_LOCKED);
+}
+
+static inline gboolean
+g_encoder_is_closed (GEncoder *encoder)
+{
+ return (G_ENCODER_PRIVATE (encoder)->flags & ENCODER_CLOSED) != FALSE;
+}
+
+static void
+g_encoder_finalize (GObject *gobject)
+{
+ GEncoderPrivate *priv = G_ENCODER_PRIVATE (gobject);
+
+ if (priv->values != NULL)
+ g_hash_table_unref (priv->values);
+
+ if (priv->encoded != NULL)
+ g_variant_unref (priv->encoded);
+
+ G_OBJECT_CLASS (g_encoder_parent_class)->finalize (gobject);
+}
+
+static void
+g_encoder_real_closed (GEncoder *encoder,
+ GVariant *variant)
+{
+}
+
+static void
+g_encoder_real_value_encoded (GEncoder *encoder,
+ const char *key,
+ GVariant *value)
+{
+}
+
+static gboolean
+g_encoder_real_read_from_bytes (GEncoder *encoder,
+ GBytes *bytes,
+ GError **error)
+{
+ return FALSE;
+}
+
+static GBytes *
+g_encoder_real_write_to_bytes (GEncoder *encoder,
+ GError **error)
+{
+ return NULL;
+}
+
+static void
+g_encoder_class_init (GEncoderClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ klass->closed = g_encoder_real_closed;
+ klass->value_encoded = g_encoder_real_value_encoded;
+ klass->read_from_bytes = g_encoder_real_read_from_bytes;
+ klass->write_to_bytes = g_encoder_real_write_to_bytes;
+
+ gobject_class->finalize = g_encoder_finalize;
+
+ g_type_class_add_private (klass, sizeof (GEncoderPrivate));
+ g_encoder_private_offset = g_type_class_get_instance_private_offset (klass);
+}
+
+static void
+g_encoder_init (GEncoder *self)
+{
+ GEncoderPrivate *priv = G_ENCODER_PRIVATE (self);
+
+ priv->values =
+ g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free,
+ (GDestroyNotify) g_variant_unref);
+}
+
+static inline void
+g_encoder_value_encoded (GEncoder *encoder,
+ const char *key,
+ GVariant *value)
+{
+ G_ENCODER_GET_CLASS (encoder)->value_encoded (encoder, key, value);
+}
+
+static inline gboolean
+g_encoder_add_key_value (GEncoder *encoder,
+ const char *key,
+ GVariant *value)
+{
+ GEncoderPrivate *priv = G_ENCODER_PRIVATE (encoder);
+ gboolean res = TRUE;
+
+ g_encoder_lock (encoder);
+
+ if (g_hash_table_lookup (priv->values, key) != NULL)
+ res = FALSE;
+
+ g_hash_table_replace (priv->values, g_strdup (key), value);
+
+ g_encoder_value_encoded (encoder, key, value);
+
+ g_encoder_unlock (encoder);
+
+ return res;
+}
+
+gboolean
+g_encoder_add_key (GEncoder *encoder,
+ const char *key,
+ GVariant *value)
+{
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (value != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ return g_encoder_add_key_value (encoder, key, g_variant_ref (value));
+}
+
+/**
+ * g_encoder_add_key_data:
+ * @encoder: a #GEncoder
+ * @key: the key for the data
+ * @value: (array length=value_len): the data to store for @key
+ * @value_len: the length of the @value array
+ *
+ * Stores an array of bytes inside @encoder, replacing the current
+ * value for @key if necessary.
+ *
+ * The @encoder makes a copy of the passed @value.
+ *
+ * Return value: %TRUE if the key was newly added, and %FALSE
+ * if the value was replaced.
+ *
+ * Since: 2.38
+ */
+gboolean
+g_encoder_add_key_data (GEncoder *encoder,
+ const char *key,
+ const guint8 *value,
+ gsize value_len)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_fixed_array (G_VARIANT_TYPE ("y"), value, value_len, sizeof (guint8));
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_add_key_string (GEncoder *encoder,
+ const char *key,
+ const char *value)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_string (value);
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_add_key_int64 (GEncoder *encoder,
+ const char *key,
+ gint64 value)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_int64 (value);
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_add_key_int32 (GEncoder *encoder,
+ const char *key,
+ int value)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_int32 (value);
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_add_key_double (GEncoder *encoder,
+ const char *key,
+ double value)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_double (value);
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_add_key_bool (GEncoder *encoder,
+ const char *key,
+ gboolean value)
+{
+ GVariant *ev;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (!g_encoder_is_closed (encoder), FALSE);
+
+ ev = g_variant_new_boolean (value);
+ g_variant_ref_sink (ev);
+
+ return g_encoder_add_key_value (encoder, key, ev);
+}
+
+gboolean
+g_encoder_get_key_data (GEncoder *encoder,
+ const char *key,
+ guint8 **res,
+ gsize *res_len)
+{
+ char *byte_string;
+ GVariant *ev;
+ gsize len;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_BYTESTRING))
+ {
+ g_encoder_unlock (encoder);
+
+ if (res != NULL)
+ *res = NULL;
+
+ if (res_len != NULL)
+ *res_len = 0;
+
+ return FALSE;
+ }
+
+ byte_string = g_variant_dup_bytestring (ev, &len);
+ if (res != NULL)
+ *res = (guint8 *) byte_string;
+ else
+ g_free (byte_string);
+
+ if (res_len != NULL)
+ *res_len = len;
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+gboolean
+g_encoder_get_key_string (GEncoder *encoder,
+ const char *key,
+ char **res)
+{
+ const char *str;
+ GVariant *ev;
+ gsize len;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_STRING))
+ {
+ g_encoder_unlock (encoder);
+
+ if (res != NULL)
+ *res = NULL;
+
+ return FALSE;
+ }
+
+ str = g_variant_get_string (ev, &len);
+ if (res != NULL)
+ *res = g_strndup (str, len);
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+gboolean
+g_encoder_get_key_int64 (GEncoder *encoder,
+ const char *key,
+ gint64 *res)
+{
+ GVariant *ev;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_INT64))
+ {
+ g_encoder_unlock (encoder);
+ return FALSE;
+ }
+
+ if (res != NULL)
+ *res = g_variant_get_int64 (ev);
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+gboolean
+g_encoder_get_key_int32 (GEncoder *encoder,
+ const char *key,
+ gint32 *res)
+{
+ GVariant *ev;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_INT32))
+ {
+ g_encoder_unlock (encoder);
+
+ if (res != NULL)
+ *res = 0;
+
+ return FALSE;
+ }
+
+ if (res != NULL)
+ *res = g_variant_get_int32 (ev);
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+gboolean
+g_encoder_get_key_double (GEncoder *encoder,
+ const char *key,
+ double *res)
+{
+ GVariant *ev;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_DOUBLE))
+ {
+ g_encoder_unlock (encoder);
+
+ if (res != NULL)
+ *res = 0;
+
+ return FALSE;
+ }
+
+ if (res != NULL)
+ *res = g_variant_get_double (ev);
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+gboolean
+g_encoder_get_key_bool (GEncoder *encoder,
+ const char *key,
+ gboolean *res)
+{
+ GVariant *ev;
+
+ g_encoder_lock (encoder);
+
+ ev = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key);
+ if (ev == NULL || !g_variant_is_of_type (ev, G_VARIANT_TYPE_BOOLEAN))
+ {
+ g_encoder_unlock (encoder);
+
+ if (res != NULL)
+ *res = FALSE;
+
+ return FALSE;
+ }
+
+ if (res != NULL)
+ *res = g_variant_get_boolean (ev);
+
+ g_encoder_unlock (encoder);
+
+ return TRUE;
+}
+
+/**
+ * g_encoder_has_key:
+ * @encoder: a #GEncoder
+ * @key: the key to look up
+ *
+ * Checks whether @key is set inside @encoder.
+ *
+ * It is usually more performant to call any of the g_encoder_get_key_*
+ * family of functions without checking for the existence of the key
+ * beforehand.
+ *
+ * Return value: %TRUE if the key exists inside @encoder, and %FALSE
+ * otherwise.
+ *
+ * Since: 2.38
+ */
+gboolean
+g_encoder_has_key (GEncoder *encoder,
+ const char *key)
+{
+ gboolean res;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+
+ g_encoder_lock (encoder);
+
+ res = g_hash_table_lookup (G_ENCODER_PRIVATE (encoder)->values, key) != NULL;
+
+ g_encoder_unlock (encoder);
+
+ return res;
+}
+
+/**
+ * g_encoder_close:
+ * @encoder: a #GEncoder
+ *
+ * Closes a @encoder.
+ *
+ * It is not possible to add or modify a key in @encoder after calling
+ * this function.
+ *
+ * This function should only be called when writing #GEncoder sub-classes
+ * from the implementation of the #GEncoderClass.write_to_bytes() virtual
+ * function.
+ *
+ * Return value: (transfer none): The encoded representation of @encoder,
+ * stored inside a #GVariant with type 'a{sv}'. The returned #GVariant
+ * is owned by the #GEncoder and should not be modified or freed.
+ *
+ * Since: 2.38
+ */
+GVariant *
+g_encoder_close (GEncoder *encoder)
+{
+ GVariantBuilder builder;
+ GEncoderPrivate *priv;
+ GHashTableIter iter;
+ gpointer key, value;
+ GVariant *res;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), NULL);
+
+ priv = G_ENCODER_PRIVATE (encoder);
+
+ g_encoder_lock (encoder);
+
+ priv->flags |= ENCODER_CLOSED;
+
+ g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+
+ if (priv->values == NULL)
+ goto out;
+
+ g_hash_table_iter_init (&iter, priv->values);
+ while (g_hash_table_iter_next (&iter, &key, &value))
+ {
+ GVariant *vkey = g_variant_new_string (key);
+ GVariant *vvalue = g_variant_new_variant (value);
+
+ g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}"));
+ g_variant_builder_add_value (&builder, vkey);
+ g_variant_builder_add_value (&builder, vvalue);
+ g_variant_builder_close (&builder);
+ }
+
+out:
+ res = g_variant_builder_end (&builder);
+ priv->encoded = g_variant_ref_sink (res);
+
+ g_encoder_unlock (encoder);
+
+ G_ENCODER_GET_CLASS (encoder)->closed (encoder, res);
+
+ return res;
+}
+
+/**
+ * g_encoder_read_from_bytes:
+ * @encoder: a #GEncoder
+ * @bytes: a data buffer
+ * @error: (allow-none): return location for a #GError, or %NULL
+ *
+ * Reads the contents of @bytes and decodes them into an @encoder.
+ *
+ * This function calls the #GEncoderClass.read_from_bytes virtual
+ * function implementation for the @encode class.
+ *
+ * Return value: %TRUE if the @bytes buffer was successfully read,
+ * and %FALSE otherwise.
+ *
+ * Since: 2.38
+ */
+gboolean
+g_encoder_read_from_bytes (GEncoder *encoder,
+ GBytes *bytes,
+ GError **error)
+{
+ GEncoderPrivate *priv;
+
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+ g_return_val_if_fail (bytes != NULL, FALSE);
+
+ priv = G_ENCODER_PRIVATE (encoder);
+
+ priv->flags &= ~ENCODER_CLOSED;
+
+ if (priv->values != NULL)
+ g_hash_table_unref (priv->values);
+
+ priv->values =
+ g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free,
+ (GDestroyNotify) g_variant_unref);
+
+ return G_ENCODER_GET_CLASS (encoder)->read_from_bytes (encoder, bytes, error);
+}
+
+/**
+ * g_encoder_write_to_bytes:
+ * @encode: a #GEncoder
+ * @error: (allow-none): return location for a #GError, or %NULL
+ *
+ * Encodes the contents of @encoder and writes them into a #GBytes
+ * buffer.
+ *
+ * This function calls the #GEncoderClass.write_to_bytes virtual
+ * function implementation for the @encode class.
+ *
+ * Return value: (transfer full): a #GBytes containing the encoded
+ * contents of @encoder, or %NULL
+ *
+ * Since: 2.38
+ */
+GBytes *
+g_encoder_write_to_bytes (GEncoder *encoder,
+ GError **error)
+{
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+
+ return G_ENCODER_GET_CLASS (encoder)->write_to_bytes (encoder, error);
+}
diff --git a/gio/gencoder.h b/gio/gencoder.h
new file mode 100644
index 0000000..c9e7660
--- /dev/null
+++ b/gio/gencoder.h
@@ -0,0 +1,155 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2013 Emmanuele Bassi <ebassi gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_ENCODER_H__
+#define __G_ENCODER_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_ENCODER (g_encoder_get_type ())
+#define G_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_ENCODER, GEncoder))
+#define G_IS_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_ENCODER))
+#define G_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_TYPE_ENCODER, GEncoderClass))
+#define G_IS_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_TYPE_ENCODER))
+#define G_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_ENCODER, GEncoderClass))
+
+typedef struct _GEncoderClass GEncoderClass;
+
+/**
+ * GEncoder:
+ *
+ * Class for providing a way to encode and decode state into a buffer.
+ *
+ * Since: 2.38
+ */
+struct _GEncoder
+{
+ GObject parent_instance;
+};
+
+struct _GEncoderClass
+{
+ /*< private >*/
+ GObjectClass parent_class;
+
+ /*< public >*/
+ gboolean (* read_from_bytes) (GEncoder *encoder,
+ GBytes *bytes,
+ GError **error);
+ GBytes * (* write_to_bytes) (GEncoder *encoder,
+ GError **error);
+
+ void (* closed) (GEncoder *encoder,
+ GVariant *variant);
+
+ void (* value_encoded) (GEncoder *encoder,
+ const char *key,
+ GVariant *variant);
+
+ /*< private >*/
+ gpointer _padding[8];
+};
+
+GLIB_AVAILABLE_IN_2_38
+GType g_encoder_get_type (void) G_GNUC_CONST;
+
+/* Encoding values */
+
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key (GEncoder *encoder,
+ const char *key,
+ GVariant *value);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_data (GEncoder *encoder,
+ const char *key,
+ const guint8 *value,
+ gsize value_len);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_string (GEncoder *encoder,
+ const char *key,
+ const char *value);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_int64 (GEncoder *encoder,
+ const char *key,
+ gint64 value);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_int32 (GEncoder *encoder,
+ const char *key,
+ gint32 value);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_double (GEncoder *encoder,
+ const char *key,
+ double value);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_add_key_bool (GEncoder *encoder,
+ const char *key,
+ gboolean value);
+
+/* Decoding values */
+
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_data (GEncoder *encoder,
+ const char *key,
+ guint8 **res,
+ gsize *res_len);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_string (GEncoder *encoder,
+ const char *key,
+ char **res);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_int64 (GEncoder *encoder,
+ const char *key,
+ gint64 *res);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_int32 (GEncoder *encoder,
+ const char *key,
+ gint32 *res);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_double (GEncoder *encoder,
+ const char *key,
+ double *res);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_get_key_bool (GEncoder *encoder,
+ const char *key,
+ gboolean *res);
+
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_has_key (GEncoder *encoder,
+ const char *key);
+GLIB_AVAILABLE_IN_2_38
+GVariant * g_encoder_close (GEncoder *encoder);
+
+GLIB_AVAILABLE_IN_2_38
+gboolean g_encoder_read_from_bytes (GEncoder *encoder,
+ GBytes *bytes,
+ GError **error);
+GLIB_AVAILABLE_IN_2_38
+GBytes * g_encoder_write_to_bytes (GEncoder *encoder,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __G_ENCODER_H__ */
diff --git a/gio/gio.h b/gio/gio.h
index d27b911..ac4d77a 100644
--- a/gio/gio.h
+++ b/gio/gio.h
@@ -36,6 +36,7 @@
#include <gio/gapplicationcommandline.h>
#include <gio/gasyncinitable.h>
#include <gio/gasyncresult.h>
+#include <gio/gbinaryencoder.h>
#include <gio/gbufferedinputstream.h>
#include <gio/gbufferedoutputstream.h>
#include <gio/gbytesicon.h>
@@ -62,6 +63,7 @@
#include <gio/gdbusutils.h>
#include <gio/gdrive.h>
#include <gio/gemblemedicon.h>
+#include <gio/gencoder.h>
#include <gio/gfileattribute.h>
#include <gio/gfileenumerator.h>
#include <gio/gfile.h>
@@ -86,6 +88,7 @@
#include <gio/giomodule.h>
#include <gio/gioscheduler.h>
#include <gio/giostream.h>
+#include <gio/gkeyfileencoder.h>
#include <gio/gloadableicon.h>
#include <gio/gmemoryinputstream.h>
#include <gio/gmemoryoutputstream.h>
@@ -107,6 +110,7 @@
#include <gio/gresolver.h>
#include <gio/gresource.h>
#include <gio/gseekable.h>
+#include <gio/gserializable.h>
#include <gio/gsettingsschema.h>
#include <gio/gsettings.h>
#include <gio/gsimpleaction.h>
diff --git a/gio/giotypes.h b/gio/giotypes.h
index d09bfae..1b4c2b2 100644
--- a/gio/giotypes.h
+++ b/gio/giotypes.h
@@ -46,6 +46,10 @@ typedef struct _GDataInputStream GDataInputStream;
typedef struct _GSimplePermission GSimplePermission;
typedef struct _GZlibCompressor GZlibCompressor;
typedef struct _GZlibDecompressor GZlibDecompressor;
+typedef struct _GEncoder GEncoder;
+typedef struct _GSerializable GSerializable;
+typedef struct _GBinaryEncoder GBinaryEncoder;
+typedef struct _GKeyfileEncoder GKeyfileEncoder;
typedef struct _GSimpleActionGroup GSimpleActionGroup;
typedef struct _GRemoteActionGroup GRemoteActionGroup;
diff --git a/gio/gkeyfileencoder.c b/gio/gkeyfileencoder.c
new file mode 100644
index 0000000..8f9726e
--- /dev/null
+++ b/gio/gkeyfileencoder.c
@@ -0,0 +1,372 @@
+/**
+ * SECTION:gkeyfileencoder
+ * @Title: GKeyfileEncoder
+ * @Short_Description: Encodes and decodes data to key files
+ *
+ * #GKeyfileEncoder is a #GEncoder implementation that stores data in
+ * specially formatted key files.
+ */
+#include "config.h"
+
+#include "gkeyfileencoder.h"
+#include "gencoder.h"
+#include "gioerror.h"
+#include "glibintl.h"
+
+#include <string.h>
+
+#define DEFAULT_SECTION_NAME "General"
+#define TYPE_KEY "Type"
+
+struct _GKeyfileEncoder
+{
+ GEncoder parent_instance;
+
+ char *section_name;
+
+ GKeyFile *key_file;
+};
+
+struct _GKeyfileEncoderClass
+{
+ GEncoderClass parent_class;
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_SECTION_NAME,
+
+ PROP_LAST
+};
+
+static GParamSpec *obj_pspec[PROP_LAST] = { NULL, };
+
+G_DEFINE_TYPE (GKeyfileEncoder, g_keyfile_encoder, G_TYPE_ENCODER)
+
+static void
+g_keyfile_encoder_finalize (GObject *gobject)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (gobject);
+
+ g_free (self->section_name);
+
+ if (self->key_file != NULL)
+ g_key_file_free (self->key_file);
+
+ G_OBJECT_CLASS (g_keyfile_encoder_parent_class)->finalize (gobject);
+};
+
+static void
+g_keyfile_encoder_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (gobject);
+
+ switch (prop_id)
+ {
+ case PROP_SECTION_NAME:
+ g_keyfile_encoder_set_section_name (self, g_value_get_string (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_keyfile_encoder_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (gobject);
+
+ switch (prop_id)
+ {
+ case PROP_SECTION_NAME:
+ g_value_set_string (value, self->section_name);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static gboolean
+g_keyfile_encoder_read_from_bytes (GEncoder *encoder,
+ GBytes *bytes,
+ GError **error)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (encoder);
+ GError *internal_error = NULL;
+ GKeyFile *key_file;
+ gchar **keys;
+ gsize keys_len, i;
+ gboolean res = TRUE;
+
+ if (self->key_file != NULL)
+ g_key_file_free (self->key_file);
+
+ key_file = g_key_file_new ();
+
+ g_key_file_load_from_data (key_file,
+ g_bytes_get_data (bytes, NULL),
+ g_bytes_get_size (bytes),
+ 0,
+ &internal_error);
+ if (internal_error != NULL)
+ goto propagate_error_and_return;
+
+ keys = g_key_file_get_keys (key_file,
+ self->section_name,
+ &keys_len,
+ &internal_error);
+ if (internal_error != NULL)
+ goto propagate_error_and_return;
+
+ for (i = 0; i < keys_len; i++)
+ {
+ GError *key_error = NULL;
+ char *value_type;
+ char *value_str;
+ GVariant *value;
+
+ value_type = g_key_file_get_value (key_file,
+ keys[i],
+ TYPE_KEY,
+ &key_error);
+ if (key_error != NULL)
+ {
+ g_set_error (error, G_IO_ERROR,
+ G_IO_ERROR_INVALID_DATA,
+ "Unable to load encoded data: %s",
+ key_error->message);
+ g_error_free (key_error);
+ res = FALSE;
+ break;
+ }
+
+ value_str = g_key_file_get_value (key_file,
+ self->section_name,
+ keys[i],
+ &key_error);
+ if (key_error != NULL)
+ {
+ g_set_error (error, G_IO_ERROR,
+ G_IO_ERROR_INVALID_DATA,
+ "Unable to load encoded data: %s",
+ key_error->message);
+ g_error_free (key_error);
+ g_free (value_type);
+ res = FALSE;
+ break;
+ }
+
+ value = g_variant_parse (G_VARIANT_TYPE (value_type),
+ value_str,
+ NULL,
+ NULL,
+ &key_error);
+ if (key_error != NULL)
+ {
+ g_set_error (error, G_IO_ERROR,
+ G_IO_ERROR_INVALID_DATA,
+ "Unable to load encoded data: %s",
+ key_error->message);
+ g_error_free (key_error);
+ g_free (value_str);
+ g_free (value_type);
+ res = FALSE;
+ break;
+ }
+
+ g_encoder_add_key (encoder, keys[i], value);
+
+ g_variant_unref (value);
+ g_free (value_str);
+ g_free (value_type);
+ }
+
+ g_strfreev (keys);
+ g_key_file_unref (key_file);
+
+ return res;
+
+propagate_error_and_return:
+ g_propagate_error (error, internal_error);
+
+ return FALSE;
+}
+
+static GBytes *
+g_keyfile_encoder_write_to_bytes (GEncoder *encoder,
+ GError **error)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (encoder);
+ GError *internal_error = NULL;
+ char *data;
+ gsize len;
+
+ g_encoder_close (encoder);
+ if (self->key_file == NULL)
+ return NULL;
+
+ data = g_key_file_to_data (self->key_file, &len, &internal_error);
+ if (internal_error)
+ {
+ g_propagate_error (error, internal_error);
+ return NULL;
+ }
+
+ return g_bytes_new_take (data, len);
+}
+
+static void
+g_keyfile_encoder_closed (GEncoder *encoder,
+ GVariant *data)
+{
+ GKeyfileEncoder *self = G_KEYFILE_ENCODER (encoder);
+ GVariantIter iter;
+ GVariant *entry;
+
+ if (self->key_file != NULL)
+ g_key_file_free (self->key_file);
+
+ self->key_file = g_key_file_new ();
+
+ g_variant_iter_init (&iter, data);
+ while ((entry = g_variant_iter_next_value (&iter)) != NULL)
+ {
+ GVariant *key = g_variant_get_child_value (entry, 0);
+ GVariant *tmp = g_variant_get_child_value (entry, 1);
+ GVariant *value;
+ char *value_str;
+
+ value = g_variant_get_variant (tmp);
+ value_str = g_variant_print (value, FALSE);
+
+ g_key_file_set_value (self->key_file,
+ self->section_name,
+ g_variant_get_string (key, NULL),
+ value_str);
+
+ g_key_file_set_value (self->key_file,
+ g_variant_get_string (key, NULL),
+ TYPE_KEY,
+ (const char *) g_variant_get_type (value));
+
+ g_free (value_str);
+ g_variant_unref (value);
+ g_variant_unref (tmp);
+ g_variant_unref (key);
+ g_variant_unref (entry);
+ }
+}
+
+static void
+g_keyfile_encoder_class_init (GKeyfileEncoderClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GEncoderClass *encoder_class = G_ENCODER_CLASS (klass);
+
+ gobject_class->set_property = g_keyfile_encoder_set_property;
+ gobject_class->get_property = g_keyfile_encoder_get_property;
+ gobject_class->finalize = g_keyfile_encoder_finalize;
+
+ encoder_class->closed = g_keyfile_encoder_closed;
+ encoder_class->read_from_bytes = g_keyfile_encoder_read_from_bytes;
+ encoder_class->write_to_bytes = g_keyfile_encoder_write_to_bytes;
+
+ /**
+ * GKeyfileEncoder:section-name:
+ *
+ * The name of the key file section to use when encoding and decoding
+ * values.
+ *
+ * Since: 2.38
+ */
+ obj_pspec[PROP_SECTION_NAME] =
+ g_param_spec_string ("section-name",
+ "Section Name",
+ "The name of the keyfile section to use when encoding and decoding",
+ DEFAULT_SECTION_NAME,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (gobject_class, PROP_LAST, obj_pspec);
+}
+
+static void
+g_keyfile_encoder_init (GKeyfileEncoder *self)
+{
+ self->section_name = g_strdup (DEFAULT_SECTION_NAME);
+}
+
+/**
+ * g_keyfile_encoder_new:
+ *
+ * Creates a new #GKeyfileEncoder.
+ *
+ * You can use this class to encode and decode data to and from a
+ * specially formated #GKeyFile.
+ *
+ * Return value: (transfer full): the newly created #GKeyfileEncoder.
+ * Use g_object_unref() to free the resources allocated when done.
+ *
+ * Since: 2.38
+ */
+GEncoder *
+g_keyfile_encoder_new (void)
+{
+ return g_object_new (G_TYPE_KEYFILE_ENCODER, NULL);
+}
+
+/**
+ * g_keyfile_encoder_set_section_name:
+ * @encoder: a #GKeyfileEncoder
+ * @section_name: the section used for the keys
+ *
+ * Sets the section name to be used to store the keys.
+ *
+ * Since: 2.38
+ */
+void
+g_keyfile_encoder_set_section_name (GKeyfileEncoder *encoder,
+ const char *section_name)
+{
+ g_return_if_fail (G_IS_KEYFILE_ENCODER (encoder));
+ g_return_if_fail (section_name != NULL);
+
+ if (strcmp (encoder->section_name, section_name) == 0)
+ return;
+
+ g_free (encoder->section_name);
+ encoder->section_name = g_strdup (section_name);
+
+ g_object_notify_by_pspec (G_OBJECT (encoder), obj_pspec[PROP_SECTION_NAME]);
+}
+
+/**
+ * g_keyfile_encoder_get_section_name:
+ * @encoder: a #GKeyfileEncoder
+ *
+ * Retrieves the section name set using g_keyfile_encoder_set_section_name().
+ *
+ * Return value: (transfer none): the section name. The returned string
+ * is owned by the #GKeyfileEncoder and it should not be modified or
+ * freed.
+ *
+ * Since: 2.38
+ */
+const char *
+g_keyfile_encoder_get_section_name (GKeyfileEncoder *encoder)
+{
+ g_return_val_if_fail (G_IS_KEYFILE_ENCODER (encoder), NULL);
+
+ return encoder->section_name;
+}
diff --git a/gio/gkeyfileencoder.h b/gio/gkeyfileencoder.h
new file mode 100644
index 0000000..2d379de
--- /dev/null
+++ b/gio/gkeyfileencoder.h
@@ -0,0 +1,35 @@
+#ifndef __G_KEYFILE_ENCODER_H__
+#define __G_KEYFILE_ENCODER_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_KEYFILE_ENCODER (g_keyfile_encoder_get_type ())
+#define G_KEYFILE_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_KEYFILE_ENCODER,
GKeyfileEncoder))
+#define G_IS_KEYFILE_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_KEYFILE_ENCODER))
+#define G_KEYFILE_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_TYPE_KEYFILE_ENCODER,
GKeyfileEncoderClass))
+#define G_IS_KEYFILE_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_TYPE_KEYFILE_ENCODER))
+#define G_KEYFILE_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_KEYFILE_ENCODER,
GKeyfileEncoderClass))
+
+typedef struct _GKeyfileEncoderClass GKeyfileEncoderClass;
+
+GLIB_AVAILABLE_IN_2_38
+GType g_keyfile_encoder_get_type (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_38
+GEncoder * g_keyfile_encoder_new (void);
+
+GLIB_AVAILABLE_IN_2_38
+void g_keyfile_encoder_set_section_name (GKeyfileEncoder *encoder,
+ const char *section_name);
+GLIB_AVAILABLE_IN_2_38
+const char * g_keyfile_encoder_get_section_name (GKeyfileEncoder *encoder);
+
+G_END_DECLS
+
+#endif /* __G_KEYFILE_ENCODER_H__ */
diff --git a/gio/gserializable.c b/gio/gserializable.c
new file mode 100644
index 0000000..0fa49a4
--- /dev/null
+++ b/gio/gserializable.c
@@ -0,0 +1,95 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2013 Emmanuele Bassi <ebassi gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:gserializable
+ * @Title: #GSerializable
+ *
+ * #GSerializable provides an interface for objects that can be serialized (or
+ * "encoded") and deserialized (or "decoded") through a #GEncoder instance.
+ */
+
+#include "config.h"
+
+#include "gserializable.h"
+#include "gencoder.h"
+#include "glibintl.h"
+
+G_DEFINE_INTERFACE (GSerializable, g_serializable, G_TYPE_OBJECT)
+
+static void
+g_serializable_real_serialize (GSerializable *serializable,
+ GEncoder *encoder)
+{
+}
+
+static gboolean
+g_serializable_real_deserialize (GSerializable *serializable,
+ GEncoder *encoder,
+ GError **error)
+{
+ return FALSE;
+}
+
+static void
+g_serializable_default_init (GSerializableInterface *iface)
+{
+ iface->serialize = g_serializable_real_serialize;
+ iface->deserialize = g_serializable_real_deserialize;
+}
+
+/**
+ * g_serializable_serialize:
+ * @serializable: a #GSerializable
+ * @encoder: a #GEncoder
+ *
+ * Asks the @serializable instance to encode itself into @encoder.
+ *
+ * Since: 2.38
+ */
+void
+g_serializable_serialize (GSerializable *serializable,
+ GEncoder *encoder)
+{
+ g_return_if_fail (G_IS_SERIALIZABLE (serializable));
+ g_return_if_fail (G_IS_ENCODER (encoder));
+
+ G_SERIALIZABLE_GET_IFACE (serializable)->serialize (serializable, encoder);
+}
+
+/**
+ * g_serializable_deserialize:
+ * @serializable: a #GSerializable
+ * @encoder: a #GEncoder
+ *
+ * Asks the @serializable instance to decncode itself from @encoder.
+ *
+ * Since: 2.38
+ */
+gboolean
+g_serializable_deserialize (GSerializable *serializable,
+ GEncoder *encoder,
+ GError **error)
+{
+ g_return_val_if_fail (G_IS_SERIALIZABLE (serializable), FALSE);
+ g_return_val_if_fail (G_IS_ENCODER (encoder), FALSE);
+
+ return G_SERIALIZABLE_GET_IFACE (serializable)->deserialize (serializable, encoder, error);
+}
diff --git a/gio/gserializable.h b/gio/gserializable.h
new file mode 100644
index 0000000..9dbebaf
--- /dev/null
+++ b/gio/gserializable.h
@@ -0,0 +1,81 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2013 Emmanuele Bassi <ebassi gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_SERIALIZABLE_H__
+#define __G_SERIALIZABLE_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SERIALIZABLE (g_serializable_get_type ())
+#define G_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SERIALIZABLE,
GSerializable))
+#define G_IS_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_SERIALIZABLE))
+#define G_SERIALIZABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SERIALIZABLE,
GSerializableInterface))
+
+/**
+ * GSerializable:
+ *
+ * Interface for serializable types.
+ *
+ * Since: 2.38
+ */
+typedef struct _GSerializableInterface GSerializableInterface;
+
+/**
+ * GSerializableInterface:
+ * @serialize: virtual function used to encode a #GSerializable instance
+ * data into a #GEncoder
+ * @deserialize: virtual function used to decode a #GSerializable instance
+ * from the data inside a #GEncoder
+ *
+ * Provides an interface for serializable types.
+ *
+ * Since: 2.38
+ */
+struct _GSerializableInterface
+{
+ GTypeInterface g_iface;
+
+ void (* serialize) (GSerializable *serializable,
+ GEncoder *encoder);
+ gboolean (* deserialize) (GSerializable *serializable,
+ GEncoder *encoder,
+ GError **error);
+};
+
+GLIB_AVAILABLE_IN_2_38
+GType g_serializable_get_type (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_38
+void g_serializable_serialize (GSerializable *serializable,
+ GEncoder *encoder);
+GLIB_AVAILABLE_IN_2_38
+gboolean g_serializable_deserialize (GSerializable *serializable,
+ GEncoder *encoder,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __G_SERIALIZABLE_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
