luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-02-23 10:42:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add encoder and serializer

Browse Source 
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.
This commit is contained in:
Emmanuele Bassi 2013-05-24 15:00:02 +01:00
parent 4c8893d96e
commit bb3e3d01c3
11 changed files with 1543 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gio/Makefile.am
View File

@ -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 \

98
gio/gbinaryencoder.c Normal file
View File

@ -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);
}

29
gio/gbinaryencoder.h Normal file
View File

@ -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__ */

662
gio/gencoder.c Normal file
View File

@ -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);
}

155
gio/gencoder.h Normal file
View File

@ -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__ */

4
gio/gio.h
View File

@ -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>

4
gio/giotypes.h
View File

@ -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;

372
gio/gkeyfileencoder.c Normal file
View File

@ -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;
}

35
gio/gkeyfileencoder.h Normal file
View File

@ -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__ */

95
gio/gserializable.c Normal file
View File

@ -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);
}

81
gio/gserializable.h Normal file
View File

@ -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__ */