[libgda] GdaSqliteBlobOp: ported to G_DECLARE/G_DEFINE

[Daniel Espinosa Ortiz <despinosa src gnome org>]

commit 27e6f5efd53658bd7ff4ffe60e752a940ff10696
Author: Daniel Espinosa <esodan gmail com>
Date:   Wed Apr 3 17:23:57 2019 -0600

    GdaSqliteBlobOp: ported to G_DECLARE/G_DEFINE

 libgda/sqlite/gda-sqlite-blob-op.c | 100 +++++++++++++------------------------
 libgda/sqlite/gda-sqlite-blob-op.h |  17 +------
 2 files changed, 36 insertions(+), 81 deletions(-)
---
diff --git a/libgda/sqlite/gda-sqlite-blob-op.c b/libgda/sqlite/gda-sqlite-blob-op.c
index 781eff5e9..6d161a50d 100644
--- a/libgda/sqlite/gda-sqlite-blob-op.c
+++ b/libgda/sqlite/gda-sqlite-blob-op.c
@@ -27,60 +27,30 @@
 #include "gda-sqlite-util.h"
 #include <sql-parser/gda-sql-parser.h>
 
-struct _GdaSqliteBlobOpPrivate {
-       GWeakRef      provider;
-       sqlite3_blob  *sblob;
-};
 
 static void gda_sqlite_blob_op_class_init (GdaSqliteBlobOpClass *klass);
-static void gda_sqlite_blob_op_init       (GdaSqliteBlobOp *blob,
-                                          GdaSqliteBlobOpClass *klass);
+static void gda_sqlite_blob_op_init       (GdaSqliteBlobOp *blob);
 static void gda_sqlite_blob_op_finalize   (GObject *object);
 
 static glong gda_sqlite_blob_op_get_length (GdaBlobOp *op);
 static glong gda_sqlite_blob_op_read       (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size);
 static glong gda_sqlite_blob_op_write      (GdaBlobOp *op, GdaBlob *blob, glong offset);
 
-static GObjectClass *parent_class = NULL;
+typedef struct {
+       GWeakRef      provider;
+       sqlite3_blob  *sblob;
+} GdaSqliteBlobOpPrivate;
 
-/*
- * Object init and finalize
- */
-GType
-_gda_sqlite_blob_op_get_type (void)
-{
-       static GType type = 0;
-
-       if (G_UNLIKELY (type == 0)) {
-               static GMutex registering;
-               static const GTypeInfo info = {
-                       sizeof (GdaSqliteBlobOpClass),
-                       (GBaseInitFunc) NULL,
-                       (GBaseFinalizeFunc) NULL,
-                       (GClassInitFunc) gda_sqlite_blob_op_class_init,
-                       NULL,
-                       NULL,
-                       sizeof (GdaSqliteBlobOp),
-                       0,
-                       (GInstanceInitFunc) gda_sqlite_blob_op_init,
-                       0
-               };
-               g_mutex_lock (&registering);
-               if (type == 0)
-                       type = g_type_register_static (GDA_TYPE_BLOB_OP, CLASS_PREFIX "BlobOp", &info, 0);
-               g_mutex_unlock (&registering);
-       }
-       return type;
-}
+G_DEFINE_TYPE_WITH_PRIVATE (GdaSqliteBlobOp, gda_sqlite_blob_op, GDA_TYPE_BLOB_OP)
 
 static void
-gda_sqlite_blob_op_init (GdaSqliteBlobOp *op, G_GNUC_UNUSED GdaSqliteBlobOpClass *klass)
+gda_sqlite_blob_op_init (GdaSqliteBlobOp *op)
 {
        g_return_if_fail (GDA_IS_SQLITE_BLOB_OP (op));
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (op);
 
-       op->priv = g_new0 (GdaSqliteBlobOpPrivate, 1);
-       op->priv->sblob = NULL;
-       g_weak_ref_init (&op->priv->provider, NULL);
+       priv->sblob = NULL;
+       g_weak_ref_init (&priv->provider, NULL);
 }
 
 static void
@@ -89,8 +59,6 @@ gda_sqlite_blob_op_class_init (GdaSqliteBlobOpClass *klass)
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
        GdaBlobOpClass *blob_class = GDA_BLOB_OP_CLASS (klass);
 
-       parent_class = g_type_class_peek_parent (klass);
-
        object_class->finalize = gda_sqlite_blob_op_finalize;
        GDA_BLOB_OP_FUNCTIONS (blob_class->functions)->get_length = gda_sqlite_blob_op_get_length;
        GDA_BLOB_OP_FUNCTIONS (blob_class->functions)->read = gda_sqlite_blob_op_read;
@@ -103,23 +71,22 @@ gda_sqlite_blob_op_finalize (GObject * object)
        GdaSqliteBlobOp *bop = (GdaSqliteBlobOp *) object;
 
        g_return_if_fail (GDA_IS_SQLITE_BLOB_OP (bop));
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (bop);
 
        /* free specific information */
-       if (bop->priv->sblob) {
-               GdaSqliteProvider *prov = g_weak_ref_get (&bop->priv->provider);
+       if (priv->sblob) {
+               GdaSqliteProvider *prov = g_weak_ref_get (&priv->provider);
                if (prov != NULL) {
-                       SQLITE3_CALL (prov, sqlite3_blob_close) (bop->priv->sblob);
+                       SQLITE3_CALL (prov, sqlite3_blob_close) (priv->sblob);
                        g_object_unref (prov);
                }
 #ifdef GDA_DEBUG_NO
                g_print ("CLOSED blob %p\n", bop);
 #endif
        }
-       g_weak_ref_clear (&bop->priv->provider);
-       g_free (bop->priv);
-       bop->priv = NULL;
+       g_weak_ref_clear (&priv->provider);
 
-       parent_class->finalize (object);
+       G_OBJECT_CLASS (gda_sqlite_blob_op_parent_class)->finalize (object);
 }
 
 GdaBlobOp *
@@ -138,6 +105,7 @@ _gda_sqlite_blob_op_new (GdaConnection *cnc,
        g_return_val_if_fail (table_name, NULL);
        g_return_val_if_fail (column_name, NULL);
        g_return_val_if_fail (GDA_IS_SQLITE_PROVIDER (gda_connection_get_provider (cnc)), NULL);
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (bop);
 
        if (db_name) {
                db = (gchar *) db_name;
@@ -170,8 +138,8 @@ _gda_sqlite_blob_op_new (GdaConnection *cnc,
        }
 
        bop = g_object_new (GDA_TYPE_SQLITE_BLOB_OP, "connection", cnc, NULL);
-       bop->priv->sblob = sblob;
-       g_weak_ref_set (&bop->priv->provider, prov);
+       priv->sblob = sblob;
+       g_weak_ref_set (&priv->provider, prov);
 #ifdef GDA_DEBUG_NO
        g_print ("OPENED blob %p\n", bop);
 #endif
@@ -195,12 +163,12 @@ gda_sqlite_blob_op_get_length (GdaBlobOp *op)
 
        g_return_val_if_fail (GDA_IS_SQLITE_BLOB_OP (op), -1);
        bop = GDA_SQLITE_BLOB_OP (op);
-       g_return_val_if_fail (bop->priv, -1);
-       g_return_val_if_fail (bop->priv->sblob, -1);
-       GdaSqliteProvider *prov = g_weak_ref_get (&bop->priv->provider);
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (bop);
+       g_return_val_if_fail (priv->sblob, -1);
+       GdaSqliteProvider *prov = g_weak_ref_get (&priv->provider);
        g_return_val_if_fail (prov != NULL, -1);
 
-       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (bop->priv->sblob);
+       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (priv->sblob);
        g_object_unref (prov);
        return len >= 0 ? len : 0;
 }
@@ -218,8 +186,8 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
 
        g_return_val_if_fail (GDA_IS_SQLITE_BLOB_OP (op), -1);
        bop = GDA_SQLITE_BLOB_OP (op);
-       g_return_val_if_fail (bop->priv, -1);
-       g_return_val_if_fail (bop->priv->sblob, -1);
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (bop);
+       g_return_val_if_fail (priv->sblob, -1);
        if (offset >= G_MAXINT)
                return -1;
        g_return_val_if_fail (blob, -1);
@@ -229,7 +197,7 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
        if (size > G_MAXINT)
                return -1;
 
-       GdaSqliteProvider *prov = g_weak_ref_get (&bop->priv->provider);
+       GdaSqliteProvider *prov = g_weak_ref_get (&priv->provider);
        g_return_val_if_fail (prov != NULL, -1);
 
        bin = gda_blob_get_binary (blob);
@@ -239,7 +207,7 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
        int rsize;
        int len;
 
-       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (bop->priv->sblob);
+       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (priv->sblob);
        if (len < 0){
                g_object_unref (prov);
                return -1;
@@ -257,7 +225,7 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
        if (len - offset < rsize)
                rsize = len - offset;
   
-       rc = SQLITE3_CALL (prov, sqlite3_blob_read) (bop->priv->sblob, buffer, rsize, offset);
+       rc = SQLITE3_CALL (prov, sqlite3_blob_read) (priv->sblob, buffer, rsize, offset);
        if (rc != SQLITE_OK) {
                gda_binary_reset_data (bin);
                g_object_unref (prov);
@@ -282,14 +250,14 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
 
        g_return_val_if_fail (GDA_IS_SQLITE_BLOB_OP (op), -1);
        bop = GDA_SQLITE_BLOB_OP (op);
-       g_return_val_if_fail (bop->priv, -1);
-       g_return_val_if_fail (bop->priv->sblob, -1);
+  GdaSqliteBlobOpPrivate *priv = gda_sqlite_blob_op_get_instance_private (bop);
+       g_return_val_if_fail (priv->sblob, -1);
        g_return_val_if_fail (blob, -1);
 
-       GdaSqliteProvider *prov = g_weak_ref_get (&bop->priv->provider);
+       GdaSqliteProvider *prov = g_weak_ref_get (&priv->provider);
        g_return_val_if_fail (prov != NULL, -1);
 
-       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (bop->priv->sblob);
+       len = SQLITE3_CALL (prov, sqlite3_blob_bytes) (priv->sblob);
        if (len < 0) {
                g_object_unref (prov);
                return -1;
@@ -316,7 +284,7 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
                        else
                                wlen = nread;
 
-                       rc = SQLITE3_CALL (prov, sqlite3_blob_write) (bop->priv->sblob,
+                       rc = SQLITE3_CALL (prov, sqlite3_blob_write) (priv->sblob,
                                                                gda_binary_get_data (gda_blob_get_binary 
(tmpblob)), wlen, offset + nbwritten);
                        if (rc != SQLITE_OK)
                                tmp_written = -1;
@@ -346,7 +314,7 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
                else
                        wlen = gda_binary_get_size (bin);
 
-               rc = SQLITE3_CALL (prov, sqlite3_blob_write) (bop->priv->sblob, gda_binary_get_data (bin), 
wlen, offset);
+               rc = SQLITE3_CALL (prov, sqlite3_blob_write) (priv->sblob, gda_binary_get_data (bin), wlen, 
offset);
                if (rc != SQLITE_OK)
                        nbwritten = -1;
                else
diff --git a/libgda/sqlite/gda-sqlite-blob-op.h b/libgda/sqlite/gda-sqlite-blob-op.h
index 0a1b54489..e8e5aab0a 100644
--- a/libgda/sqlite/gda-sqlite-blob-op.h
+++ b/libgda/sqlite/gda-sqlite-blob-op.h
@@ -24,26 +24,13 @@
 
 G_BEGIN_DECLS
 
-#define GDA_TYPE_SQLITE_BLOB_OP            (_gda_sqlite_blob_op_get_type())
-#define GDA_SQLITE_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SQLITE_BLOB_OP, 
GdaSqliteBlobOp))
-#define GDA_SQLITE_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SQLITE_BLOB_OP, 
GdaSqliteBlobOpClass))
-#define GDA_IS_SQLITE_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_SQLITE_BLOB_OP))
-#define GDA_IS_SQLITE_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_SQLITE_BLOB_OP))
-
-typedef struct _GdaSqliteBlobOp        GdaSqliteBlobOp;
-typedef struct _GdaSqliteBlobOpClass   GdaSqliteBlobOpClass;
-typedef struct _GdaSqliteBlobOpPrivate GdaSqliteBlobOpPrivate;
-
-struct _GdaSqliteBlobOp {
-       GdaBlobOp             parent;
-       GdaSqliteBlobOpPrivate *priv;
-};
+#define GDA_TYPE_SQLITE_BLOB_OP            (gda_sqlite_blob_op_get_type())
+G_DECLARE_DERIVABLE_TYPE(GdaSqliteBlobOp, gda_sqlite_blob_op, GDA, SQLITE_BLOB_OP, GdaBlobOp)
 
 struct _GdaSqliteBlobOpClass {
        GdaBlobOpClass        parent_class;
 };
 
-GType         _gda_sqlite_blob_op_get_type     (void) G_GNUC_CONST;
 GdaBlobOp    *_gda_sqlite_blob_op_new          (GdaConnection *cnc,
                                                const gchar *db_name, const gchar *table_name,
                                                const gchar *column_name, sqlite3_int64 rowid);