[libgda] Sealing GdaBinary: API change
- From: Daniel Espinosa Ortiz <despinosa src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libgda] Sealing GdaBinary: API change
- Date: Thu, 21 Apr 2016 15:28:10 +0000 (UTC)
commit db94bed1bdca380f2106ff3b08a9d391e2964590
Author: Daniel Espinosa <esodan gmail com>
Date: Wed Apr 20 23:37:31 2016 -0500
Sealing GdaBinary: API change
libgda-report/engine/rt-parser.c | 61 ++--
libgda-report/engine/rt-parser.h | 2 +-
libgda-ui/data-entries/common-bin.c | 47 ++--
libgda-ui/data-entries/plugins/common-pict.c | 44 ++--
libgda-ui/data-entries/plugins/gdaui-entry-pict.c | 12 +-
libgda-ui/data-entries/plugins/gdaui-entry-rt.c | 22 +-
libgda-ui/data-entries/plugins/gdaui-entry-text.c | 20 +-
libgda-ui/gdaui-raw-grid.c | 10 +-
libgda/dir-blob-op.c | 37 ++--
libgda/gda-blob-op.c | 4 +-
libgda/gda-data-model-dir.c | 18 +-
libgda/gda-data-pivot.c | 14 +-
libgda/gda-util.c | 8 +-
libgda/gda-value.c | 306 ++++++++++++++-----
libgda/gda-value.h | 48 ++--
libgda/gda-xa-transaction.c | 26 +-
libgda/handlers/gda-handler-bin.c | 10 +-
libgda/sqlite/gda-sqlite-blob-op.c | 39 ++--
libgda/sqlite/gda-sqlite-handler-bin.c | 33 +-
libgda/sqlite/gda-sqlite-provider.c | 35 +--
libgda/sqlite/gda-sqlite-recordset.c | 17 +-
libgda/sqlite/virtual/gda-vprovider-data-model.c | 25 +-
providers/postgres/gda-postgres-blob-op.c | 38 ++--
providers/postgres/gda-postgres-handler-bin.c | 4 +-
providers/postgres/gda-postgres-provider.c | 4 +-
providers/postgres/gda-postgres-recordset.c | 14 +-
.../skel-implementation/capi/gda-capi-blob-op.c | 32 +-
providers/web/gda-web-blob-op.c | 29 +-
testing/gdaui-test-data-entries.c | 4 +-
tools/common/t-app.c | 13 +-
30 files changed, 561 insertions(+), 415 deletions(-)
---
diff --git a/libgda-report/engine/rt-parser.c b/libgda-report/engine/rt-parser.c
index af619ea..4047957 100644
--- a/libgda-report/engine/rt-parser.c
+++ b/libgda-report/engine/rt-parser.c
@@ -427,7 +427,7 @@ rt_dump_tree_offset (RtNode *tree, gint offset)
g_free (copy);
g_print ("]\n");
}
- else if (tree->binary.data) {
+ else if (gda_binary_get_data (tree->binary)) {
g_print ("BINARY\n");
}
else
@@ -472,7 +472,7 @@ rt_dump_tree_to_string (RtNode *tree, GString *string)
}
g_string_append (string, "]|");
}
- else if (tree->binary.data)
+ else if (gda_binary_get_data (tree->binary))
g_string_append (string, "BINARY|");
else
g_string_append_c (string, '|');
@@ -500,8 +500,7 @@ rt_free_node (RtNode *node)
if (node->next)
rt_free_node (node->next);
g_free (node->text);
- if (node->binary.data)
- g_free (node->binary.data);
+ gda_binary_free (node->binary);
g_free (node);
}
@@ -520,8 +519,8 @@ merge_text_node_child (RtNode *tree)
if (! child)
return FALSE;
- if ((tree->markup == RT_MARKUP_NONE) && !tree->binary.data &&
- (child->markup == RT_MARKUP_NONE) && ! child->child && child->text && !child->binary.data) {
+ if ((tree->markup == RT_MARKUP_NONE) && !gda_binary_get_data (tree->binary) &&
+ (child->markup == RT_MARKUP_NONE) && ! child->child && child->text && !gda_binary_get_data
(child->binary)) {
if (tree->text) {
gchar *tmp;
tmp = tree->text;
@@ -551,8 +550,8 @@ merge_text_node_siblings (RtNode *tree)
if (! tree->next)
break;
RtNode *next = tree->next;
- if ((tree->markup == RT_MARKUP_NONE) && !tree->binary.data &&
- (next->markup == RT_MARKUP_NONE) && !next->binary.data &&
+ if ((tree->markup == RT_MARKUP_NONE) && !gda_binary_get_data (tree->binary) &&
+ (next->markup == RT_MARKUP_NONE) && !gda_binary_get_data (next->binary) &&
! next->child && next->text) {
if (tree->text) {
gchar *tmp;
@@ -581,17 +580,15 @@ merge_text_node_siblings (RtNode *tree)
static gboolean
merge_single_child_text (RtNode *tree)
{
- if (! (tree->text || tree->binary.data) &&
+ if (! (tree->text || gda_binary_get_data (tree->binary)) &&
tree->child && !tree->child->next &&
! tree->child->child &&
- (tree->child->text || tree->child->binary.data) &&
+ (tree->child->text || gda_binary_get_data (tree->child->binary)) &&
(tree->child->markup == RT_MARKUP_NONE)) {
tree->text = tree->child->text;
tree->child->text = NULL;
- tree->binary.data = tree->child->binary.data;
- tree->child->binary.data = NULL;
- tree->binary.binary_length = tree->child->binary.binary_length;
- tree->child->binary.binary_length = 0;
+ gda_binary_set_data (tree->binary, gda_binary_get_data (tree->child->binary),
gda_binary_get_size (tree->child->binary));
+ gda_binary_reset_data (tree->child->binary);
rt_free_node (tree->child);
tree->child = NULL;
return TRUE;
@@ -855,6 +852,7 @@ rt_parse_text (const gchar *text)
TextTag *current = NULL;
retnode = g_new0 (RtNode, 1);
+ retnode->binary = gda_binary_new ();
contextnode = retnode;
ptr = text;
@@ -878,6 +876,7 @@ rt_parse_text (const gchar *text)
gchar *part;
RtNode *node;
node = g_new0 (RtNode, 1);
+ node->binary = gda_binary_new ();
node->parent = contextnode;
node->markup = RT_MARKUP_NONE;
if (prev == text)
@@ -906,6 +905,7 @@ rt_parse_text (const gchar *text)
else {
RtNode *n;
n = g_new0 (RtNode, 1);
+ n->binary = gda_binary_new ();
n->parent = contextnode;
n->markup = RT_MARKUP_PARA;
n->text = array [i];
@@ -919,7 +919,9 @@ rt_parse_text (const gchar *text)
else {
gchar *tmp;
tmp = remove_newlines_from_base64 (part);
- node->binary.data = g_base64_decode_inplace (tmp, (gsize*) &
node->binary.binary_length);
+ gsize size;
+ guchar *buffer = g_base64_decode_inplace (tmp, & size);
+ gda_binary_set_data (node->binary, buffer, size);
}
}
else {
@@ -961,7 +963,7 @@ rt_parse_text (const gchar *text)
tmp, NULL);
g_free (tmp);
}
- else if (lnode->binary.data) {
+ else if (gda_binary_get_data (lnode->binary))
{
TO_IMPLEMENT;
}
else
@@ -985,6 +987,7 @@ rt_parse_text (const gchar *text)
if (! tag_matched) {
RtNode *node;
node = g_new0 (RtNode, 1);
+ node->binary = gda_binary_new ();
node->parent = contextnode;
node->offset = ssol;
node->markup = internal_markup_to_external (mt, &(node->offset));
@@ -1001,6 +1004,7 @@ rt_parse_text (const gchar *text)
for (; i < node->offset; i++) {
RtNode *tmpn;
tmpn = g_new0 (RtNode, 1);
+ tmpn->binary = gda_binary_new ();
tmpn->parent = contextnode;
tmpn->markup = RT_MARKUP_LIST;
tmpn->offset = i;
@@ -1018,6 +1022,7 @@ rt_parse_text (const gchar *text)
for (i = 0; i < node->offset; i++) {
RtNode *tmpn;
tmpn = g_new0 (RtNode, 1);
+ tmpn->binary = gda_binary_new ();
tmpn->parent = contextnode;
tmpn->markup = RT_MARKUP_LIST;
tmpn->offset = i;
@@ -1169,9 +1174,9 @@ rich_text_node_to_docbook (RenderingContext *context, xmlNodePtr top_parent, RtN
#ifdef HAVE_GDKPIXBUF
GdkPixdata pixdata;
- if (rtnode->binary.data &&
- gdk_pixdata_deserialize (&pixdata, rtnode->binary.binary_length,
- (guint8*) rtnode->binary.data, NULL)) {
+ if (gda_binary_get_data (rtnode->binary) &&
+ gdk_pixdata_deserialize (&pixdata, gda_binary_get_size (rtnode->binary),
+ (guint8*) gda_binary_get_data (rtnode->binary), NULL)) {
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_from_pixdata (&pixdata, TRUE, NULL);
if (pixbuf) {
@@ -1189,9 +1194,9 @@ rich_text_node_to_docbook (RenderingContext *context, xmlNodePtr top_parent, RtN
#endif
if (!saved) {
- if (rtnode->binary.data &&
- g_file_set_contents (file, (gchar*) rtnode->binary.data,
- rtnode->binary.binary_length, NULL)) {
+ if (gda_binary_get_data (rtnode->binary) &&
+ g_file_set_contents (file, (gchar*) gda_binary_get_data (rtnode->binary),
+ gda_binary_get_size (rtnode->binary), NULL)) {
g_print ("Writen BIN file '%s'\n", file);
saved = TRUE;
type = 2;
@@ -1381,9 +1386,9 @@ rich_text_node_to_html (RenderingContext *context, xmlNodePtr top_parent, RtNode
#ifdef HAVE_GDKPIXBUF
GdkPixdata pixdata;
- if (rtnode->binary.data &&
- gdk_pixdata_deserialize (&pixdata, rtnode->binary.binary_length,
- (guint8*) rtnode->binary.data, NULL)) {
+ if (gda_binary_get_data (rtnode->binary) &&
+ gdk_pixdata_deserialize (&pixdata, gda_binary_get_size (rtnode->binary),
+ (guint8*) gda_binary_get_data (rtnode->binary), NULL)) {
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_from_pixdata (&pixdata, TRUE, NULL);
if (pixbuf) {
@@ -1401,9 +1406,9 @@ rich_text_node_to_html (RenderingContext *context, xmlNodePtr top_parent, RtNode
#endif
if (!saved) {
- if (rtnode->binary.data &&
- g_file_set_contents (file, (gchar*) rtnode->binary.data,
- rtnode->binary.binary_length, NULL)) {
+ if (gda_binary_get_data (rtnode->binary) &&
+ g_file_set_contents (file, (gchar*) gda_binary_get_data (rtnode->binary),
+ gda_binary_get_size (rtnode->binary), NULL)) {
g_print ("Writen BIN file '%s'\n", file);
saved = TRUE;
type = 2;
diff --git a/libgda-report/engine/rt-parser.h b/libgda-report/engine/rt-parser.h
index 1d5c530..ce14e11 100644
--- a/libgda-report/engine/rt-parser.h
+++ b/libgda-report/engine/rt-parser.h
@@ -56,7 +56,7 @@ struct _RtNode {
RtMarkup markup;
gint offset;
gchar *text;
- GdaBinary binary;
+ GdaBinary *binary;
};
RtNode *rt_parse_text (const gchar *text);
diff --git a/libgda-ui/data-entries/common-bin.c b/libgda-ui/data-entries/common-bin.c
index 638d793..e9ab33e 100644
--- a/libgda-ui/data-entries/common-bin.c
+++ b/libgda-ui/data-entries/common-bin.c
@@ -81,9 +81,8 @@ file_load_cb (GtkWidget *button, BinMenu *menu)
if (g_file_get_contents (filename, &data, &length, &error)) {
GdaBinary *bin;
GValue *nvalue;
- bin = g_new0 (GdaBinary, 1);
- bin->data = (guchar*) data;
- bin->binary_length = length;
+ bin = gda_binary_new ();
+ gda_binary_set_data (bin, (guchar*) data, length);
nvalue = gda_value_new (GDA_TYPE_BINARY);
gda_value_take_binary (nvalue, bin);
@@ -119,24 +118,24 @@ export_data (BinMenu *menu, const gchar *filename, GError **error)
if (menu->entry_type == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (menu->tmpvalue);
- allok = g_file_set_contents (filename, (gchar *) bin->data,
- bin->binary_length, error);
+ allok = g_file_set_contents (filename, (gchar *) gda_binary_get_data (bin),
+ gda_binary_get_size (bin), error);
}
else if (menu->entry_type == GDA_TYPE_BLOB) {
GdaBlob *blob;
blob = (GdaBlob*) gda_value_get_blob (menu->tmpvalue);
- if (blob->op) {
+ if (gda_blob_get_op (blob)) {
GValue *dest_value;
GdaBlob *dest_blob;
dest_value = gda_value_new_blob_from_file (filename);
dest_blob = (GdaBlob*) gda_value_get_blob (dest_value);
- allok = gda_blob_op_write_all (dest_blob->op, (GdaBlob*) blob);
+ allok = gda_blob_op_write_all (gda_blob_get_op (dest_blob), (GdaBlob*) blob);
gda_value_free (dest_value);
}
else
- allok = g_file_set_contents (filename, (gchar *) ((GdaBinary*)blob)->data,
- ((GdaBinary*)blob)->binary_length, error);
+ allok = g_file_set_contents (filename, (gchar *) gda_binary_get_data
(gda_blob_get_binary (blob)),
+ gda_binary_get_size (gda_blob_get_binary (blob)), error);
}
else
g_assert_not_reached ();
@@ -297,7 +296,7 @@ common_bin_get_description (BinMenu *binmenu)
if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- size = format_size (bin->binary_length);
+ size = format_size (gda_binary_get_size (bin));
g_string_append (string, size);
g_free (size);
}
@@ -305,10 +304,10 @@ common_bin_get_description (BinMenu *binmenu)
const GdaBlob *blob;
GdaBinary *bin;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
- if (blob->op) {
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob)) {
glong len;
- len = gda_blob_op_get_length (blob->op);
+ len = gda_blob_op_get_length (gda_blob_get_op (blob));
if (len >= 0) {
size = format_size (len);
g_string_append (string, size);
@@ -318,7 +317,7 @@ common_bin_get_description (BinMenu *binmenu)
g_string_append (string, _("Unknown size"));
}
else {
- size = format_size (bin->binary_length);
+ size = format_size (gda_binary_get_size (bin));
g_string_append (string, size);
g_free (size);
}
@@ -486,29 +485,29 @@ adjust_ctype (BinMenu *binmenu)
if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- binmenu->ctype = g_content_type_guess (NULL, bin->data, (gsize) bin->binary_length,
NULL);
+ binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data (bin), (gsize)
gda_binary_get_size (bin), NULL);
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_BLOB) {
const GdaBlob *blob;
GdaBinary *bin;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
- if (blob->op) {
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob)) {
glong len;
- len = gda_blob_op_get_length (blob->op);
+ len = gda_blob_op_get_length (gda_blob_get_op (blob));
if (len >= 0) {
GdaBlob *blob2;
blob2 = (GdaBlob*) gda_blob_copy ((gpointer) blob);
- gda_blob_op_read (blob2->op, blob2, 0, 1024);
- bin = (GdaBinary *) blob2;
- binmenu->ctype = g_content_type_guess (NULL, bin->data,
- (gsize) bin->binary_length, NULL);
+ gda_blob_op_read (gda_blob_get_op (blob2), blob2, 0, 1024);
+ bin = gda_blob_get_binary (blob2);
+ binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data
(bin),
+ (gsize) gda_binary_get_size (bin),
NULL);
gda_blob_free ((gpointer) blob2);
}
}
else
- binmenu->ctype = g_content_type_guess (NULL, bin->data,
- (gsize) bin->binary_length, NULL);
+ binmenu->ctype = g_content_type_guess (NULL, gda_binary_get_data (bin),
+ (gsize) gda_binary_get_size (bin),
NULL);
}
else
g_assert_not_reached ();
diff --git a/libgda-ui/data-entries/plugins/common-pict.c b/libgda-ui/data-entries/plugins/common-pict.c
index efd7000..d75ac7a 100644
--- a/libgda-ui/data-entries/plugins/common-pict.c
+++ b/libgda-ui/data-entries/plugins/common-pict.c
@@ -53,24 +53,24 @@ common_pict_load_data (PictOptions *options, const GValue *value, PictBinData *b
blob = (GdaBlob *) gda_value_get_blob ((GValue *) value);
g_assert (blob);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
- if (bin->binary_length > 0) {
- bindata->data = g_new (guchar, bin->binary_length);
- bindata->data_length = bin->binary_length;
- memcpy (bindata->data, bin->data, bin->binary_length);
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op
(blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
+ if (gda_binary_get_size (bin) > 0) {
+ bindata->data = g_new (guchar, gda_binary_get_size (bin));
+ bindata->data_length = gda_binary_get_size (bin);
+ memcpy (bindata->data, gda_binary_get_data (bin), gda_binary_get_size
(bin));
}
}
else if (G_VALUE_TYPE ((GValue *) value) == GDA_TYPE_BINARY) {
GdaBinary *bin;
bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
- if (bin && bin->binary_length > 0) {
- bindata->data = g_new (guchar, bin->binary_length);
- bindata->data_length = bin->binary_length;
- memcpy (bindata->data, bin->data, bin->binary_length);
+ if (bin && gda_binary_get_size (bin) > 0) {
+ bindata->data = g_new (guchar, gda_binary_get_size (bin));
+ bindata->data_length = gda_binary_get_size (bin);
+ memcpy (bindata->data, gda_binary_get_data (bin), gda_binary_get_size
(bin));
}
else {
*out_icon_name = "dialog-error";
@@ -588,19 +588,19 @@ common_pict_add_cached_pixbuf (PictOptions *options, const GValue *value, GdkPix
const GdaBinary *bin;
bin = gda_value_get_binary (value);
hash = g_new (gint, 1);
- *hash = compute_hash (bin->data, bin->binary_length);
+ *hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
g_hash_table_insert (options->pixbuf_hash, hash, g_object_ref (pixbuf));
}
else if (GDA_VALUE_HOLDS_BLOB (value)) {
const GdaBinary *bin;
const GdaBlob *blob;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
+ bin = gda_binary_get_binary (blob);
if (bin) {
- if (!bin->data && blob->op)
- gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
+ if (!gda_binary_get_data (bin) && gda_blob_get_op (blob))
+ gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
hash = g_new (gint, 1);
- *hash = compute_hash (bin->data, bin->binary_length);
+ *hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
g_hash_table_insert (options->pixbuf_hash, hash, g_object_ref (pixbuf));
}
}
@@ -623,7 +623,7 @@ common_pict_fetch_cached_pixbuf (PictOptions *options, const GValue *value)
const GdaBinary *bin;
bin = gda_value_get_binary (value);
if (bin) {
- hash = compute_hash (bin->data, bin->binary_length);
+ hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
pixbuf = g_hash_table_lookup (options->pixbuf_hash, &hash);
}
}
@@ -631,11 +631,11 @@ common_pict_fetch_cached_pixbuf (PictOptions *options, const GValue *value)
const GdaBinary *bin;
const GdaBlob *blob;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
+ bin = gda_blob_get_binary (blob);
if (bin) {
- if (!bin->data && blob->op)
- gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
- hash = compute_hash (bin->data, bin->binary_length);
+ if (!gda_binary_get_data (bin) && gda_blob_get_op (blob))
+ gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+ hash = compute_hash (gda_binary_get_data (bin), gda_binary_get_size (bin));
pixbuf = g_hash_table_lookup (options->pixbuf_hash, &hash);
}
}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
b/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
index 965e6e2..de74068 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-pict.c
@@ -483,12 +483,12 @@ value_is_equal_to (GdauiEntryWrapper *mgwrap, const GValue *value)
blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
g_assert (blob);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
if (mgpict->priv->bindata.data)
- return !memcmp (bin->data, mgpict->priv->bindata.data, MIN
(mgpict->priv->bindata.data_length, bin->binary_length));
+ return !memcmp (gda_binary_get_data (bin), mgpict->priv->bindata.data, MIN
(mgpict->priv->bindata.data_length, gda_binary_get_size (bin)));
else
return FALSE;
}
@@ -497,7 +497,7 @@ value_is_equal_to (GdauiEntryWrapper *mgwrap, const GValue *value)
bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
if (bin && mgpict->priv->bindata.data)
- return !memcmp (bin->data, mgpict->priv->bindata.data, MIN
(mgpict->priv->bindata.data_length, bin->binary_length));
+ return !memcmp (gda_binary_get_data (bin), mgpict->priv->bindata.data, MIN
(mgpict->priv->bindata.data_length, gda_binary_get_size (bin)));
else
return FALSE;
}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-rt.c b/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
index 7739bb3..e1816d0 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-rt.c
@@ -1,4 +1,4 @@
-/*
+ /*
* Copyright (C) 2010 - 2015 Vivien Malerba <malerba gnome-db org>
* Copyright (C) 2011 Murray Cumming <murrayc murrayc com>
*
@@ -191,24 +191,24 @@ real_set_value (GdauiEntryWrapper *mgwrap, const GValue *value)
const GdaBlob *blob;
GdaBinary *bin;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
- if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_op
(blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+ if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size
(bin), NULL)) {
gdaui_rt_editor_set_contents (GDAUI_RT_EDITOR (mgtxt->priv->view),
- (gchar*) bin->data,
- bin->binary_length);
+ (gchar*) gda_binary_get_data (bin),
+ gda_binary_get_size (bin));
done = TRUE;
}
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
+ if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size
(bin), NULL)) {
gdaui_rt_editor_set_contents (GDAUI_RT_EDITOR (mgtxt->priv->view),
- (gchar*) bin->data,
- bin->binary_length);
+ (gchar*) gda_binary_get_data (bin),
+ gda_binary_get_size (bin));
done = TRUE;
}
}
diff --git a/libgda-ui/data-entries/plugins/gdaui-entry-text.c
b/libgda-ui/data-entries/plugins/gdaui-entry-text.c
index e447b19..346655a 100644
--- a/libgda-ui/data-entries/plugins/gdaui-entry-text.c
+++ b/libgda-ui/data-entries/plugins/gdaui-entry-text.c
@@ -320,22 +320,22 @@ real_set_value (GdauiEntryWrapper *mgwrap, const GValue *value)
const GdaBlob *blob;
GdaBinary *bin;
blob = gda_value_get_blob (value);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, (GdaBlob*) blob);
- if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
- gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) bin->data,
- bin->binary_length);
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op
(blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), (GdaBlob*) blob);
+ if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size
(bin), NULL)) {
+ gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*)
gda_binary_get_data (bin),
+ gda_binary_get_size (bin));
done = TRUE;
}
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- if (g_utf8_validate ((gchar*) bin->data, bin->binary_length, NULL)) {
- gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*) bin->data,
- bin->binary_length);
+ if (g_utf8_validate ((gchar*) gda_binary_get_data (bin), gda_binary_get_size
(bin), NULL)) {
+ gtk_text_buffer_set_text (mgtxt->priv->buffer, (gchar*)
gda_binary_get_data (bin),
+ gda_binary_get_size (bin));
done = TRUE;
}
}
diff --git a/libgda-ui/gdaui-raw-grid.c b/libgda-ui/gdaui-raw-grid.c
index 4bd1e96..88dcd99 100644
--- a/libgda-ui/gdaui-raw-grid.c
+++ b/libgda-ui/gdaui-raw-grid.c
@@ -1703,16 +1703,16 @@ menu_copy_row_cb (GtkWidget *widget, GdauiRawGrid *grid)
GdaBlob *blob;
blob = (GdaBlob *) gda_value_get_blob ((GValue *) cvalue);
g_assert (blob);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
}
if (bin) {
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf = NULL;
loader = gdk_pixbuf_loader_new ();
- if (gdk_pixbuf_loader_write (loader, bin->data, bin->binary_length, NULL)) {
+ if (gdk_pixbuf_loader_write (loader, gda_binary_get_data (bin), gda_binary_get_size
(bin), NULL)) {
if (gdk_pixbuf_loader_close (loader, NULL)) {
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
g_object_ref (pixbuf);
diff --git a/libgda/dir-blob-op.c b/libgda/dir-blob-op.c
index 15a7a79..617d871 100644
--- a/libgda/dir-blob-op.c
+++ b/libgda/dir-blob-op.c
@@ -180,6 +180,7 @@ gda_dir_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
GdaBinary *bin;
FILE *file;
size_t nread;
+ guchar *buffer;
g_return_val_if_fail (GDA_IS_DIR_BLOB_OP (op), -1);
dirop = GDA_DIR_BLOB_OP (op);
@@ -199,14 +200,11 @@ gda_dir_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
return -1;
}
- bin = (GdaBinary *) blob;
- if (bin->data) {
- g_free (bin->data);
- bin->data = NULL;
- }
- bin->data = g_new0 (guchar, size);
- nread = fread ((char *) (bin->data), 1, size, file);
- bin->binary_length = nread;
+ bin = gda_blob_get_binary (blob);
+ gda_binary_reset_data (bin);
+ buffer = g_new0 (guchar, size);
+ nread = fread ((char *) (buffer), 1, size, file);
+ gda_binary_set_data (bin, buffer, nread);
fclose (file);
return nread;
@@ -240,25 +238,26 @@ gda_dir_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
}
}
- if (blob->op && (blob->op != op)) {
+ if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
/* use data through blob->op */
#define buf_size 16384
gint nread = 0;
- GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
- gda_blob_set_op (tmpblob, blob->op);
+ GdaBlob *tmpblob = gda_blob_new ();
+ gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
nbwritten = 0;
- for (nread = gda_blob_op_read (tmpblob->op, tmpblob, 0, buf_size);
+ for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, 0, buf_size);
nread > 0;
- nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
- GdaBinary *bin = (GdaBinary *) tmpblob;
+ nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
+ GdaBinary *bin = gda_blob_get_binary (tmpblob);
glong tmp_written;
- tmp_written = fwrite ((char *) (bin->data), sizeof (guchar), bin->binary_length,
file);
- if (tmp_written < bin->binary_length) {
+ guchar *buffer;
+ tmp_written = fwrite ((char *) (buffer), sizeof (guchar), gda_binary_get_size (bin),
file);
+ if (tmp_written < gda_binary_get_size (bin)) {
/* error writing stream */
fclose (file);
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
return -1;
}
nbwritten += tmp_written;
@@ -267,11 +266,11 @@ gda_dir_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
break;
}
fclose (file);
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
}
else {
bin = (GdaBinary *) blob;
- nbwritten = fwrite ((char *) (bin->data), 1, bin->binary_length, file);
+ nbwritten = fwrite ((char *) (gda_binary_get_data (bin)), 1, gda_binary_get_size (bin), file);
fclose (file);
}
diff --git a/libgda/gda-blob-op.c b/libgda/gda-blob-op.c
index 530495f..53c44b2 100644
--- a/libgda/gda-blob-op.c
+++ b/libgda/gda-blob-op.c
@@ -332,9 +332,9 @@ gda_blob_op_read_all (GdaBlobOp *op, GdaBlob *blob)
g_return_val_if_fail (GDA_IS_BLOB_OP (op), FALSE);
g_return_val_if_fail (blob, FALSE);
- len = gda_blob_op_get_length (blob->op);
+ len = gda_blob_op_get_length (gda_blob_get_op (blob));
if (len >= 0)
- return (gda_blob_op_read (blob->op, blob, 0, len) < 0) ? FALSE : TRUE;
+ return (gda_blob_op_read (gda_blob_get_op (blob), blob, 0, len) < 0) ? FALSE : TRUE;
else
return FALSE;
}
diff --git a/libgda/gda-data-model-dir.c b/libgda/gda-data-model-dir.c
index ee05652..e63177e 100644
--- a/libgda/gda-data-model-dir.c
+++ b/libgda/gda-data-model-dir.c
@@ -832,7 +832,7 @@ gda_data_model_dir_get_value_at (GdaDataModel *model, gint col, gint row, GError
GdaBlobOp *op;
gchar *filename;
- blob = g_new0 (GdaBlob, 1);
+ blob = gda_blob_new ();
/* file mapping in mem */
filename = compute_filename (imodel, frow);
@@ -1029,8 +1029,8 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
if (frow->data_value) {
GdaBlob *blob;
blob = (GdaBlob *) gda_value_get_blob
(frow->data_value);
- if (blob && blob->op)
- _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP
(blob->op),
+ if (blob && gda_blob_get_op (blob))
+ _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP
(gda_blob_get_op (blob)),
new_filename);
}
}
@@ -1105,8 +1105,8 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
if (frow->data_value) {
GdaBlob *blob;
blob = (GdaBlob *) gda_value_get_blob (frow->data_value);
- if (blob && blob->op)
- _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op),
+ if (blob && gda_blob_get_op (blob))
+ _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (gda_blob_get_op
(blob)),
new_filename);
}
}
@@ -1125,7 +1125,7 @@ gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GEr
}
else if (gda_value_is_null (value)) {
/* create a new empty blob */
- blob = g_new0 (GdaBlob, 1);
+ blob = gda_blob_new ();
}
if (blob) {
@@ -1239,11 +1239,11 @@ gda_data_model_dir_append_values (GdaDataModel *model, const GList *values, GErr
gboolean bin_to_free = FALSE;
complete_filename = g_build_filename (dirname, filename, NULL);
if (!bin_data) {
- bin_data = g_new0 (GdaBinary, 1);
+ bin_data = gda_binary_new ();
bin_to_free = TRUE;
}
- if (g_file_set_contents (complete_filename, (gchar *) bin_data->data,
- bin_data->binary_length, NULL)) {
+ if (g_file_set_contents (complete_filename, (gchar *) gda_binary_get_data (bin_data),
+ gda_binary_get_size (bin_data), NULL)) {
FileRow *row;
row = file_row_new ();
diff --git a/libgda/gda-data-pivot.c b/libgda/gda-data-pivot.c
index 56bdece..a2896c2 100644
--- a/libgda/gda-data-pivot.c
+++ b/libgda/gda-data-pivot.c
@@ -2035,17 +2035,19 @@ _gda_value_hash (gconstpointer key)
if (vt == GDA_TYPE_BLOB) {
GdaBlob *blob;
blob = (GdaBlob*) gda_value_get_blob ((GValue *) v);
- bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
+ bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
}
else
bin = gda_value_get_binary ((GValue *) v);
if (bin) {
glong l;
- for (l = 0; l < bin->binary_length; l++)
- res += (guint) bin->data [l];
+ for (l = 0; l < gda_binary_get_size (bin); l++) {
+ guchar* p = gda_binary_get_data (bin);
+ res += (guint) p[l];
+ }
}
}
else {
diff --git a/libgda/gda-util.c b/libgda/gda-util.c
index 7a76e12..8b96a29 100644
--- a/libgda/gda-util.c
+++ b/libgda/gda-util.c
@@ -506,10 +506,10 @@ gda_utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlNodePtr parent,
/* force reading the whole blob */
const GdaBlob *blob = gda_value_get_blob (value);
if (blob) {
- const GdaBinary *bin = &(blob->data);
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length
(blob->op)))
- gda_blob_op_read_all (blob->op, (GdaBlob*)
blob);
+ const GdaBinary *bin = gda_blob_get_binary (blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) !=
gda_blob_op_get_length (gda_blob_get_op (blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob),
(GdaBlob*) blob);
}
str = gda_value_stringify (value);
}
diff --git a/libgda/gda-value.c b/libgda/gda-value.c
index 80076f4..532c19b 100644
--- a/libgda/gda-value.c
+++ b/libgda/gda-value.c
@@ -394,6 +394,13 @@ gda_default_get_type (void)
}
+// GdaBinary
+
+struct _GdaBinary {
+ guchar *data;
+ glong binary_length;
+};
+
/*
* Register the GdaBinary type in the GType system
*/
@@ -450,6 +457,126 @@ gda_binary_get_type (void)
return type;
}
+
+/*
+ * Register the GdaBlob type in the GType system
+ */
+/* Transform a String GValue to a GdaBlob*/
+static void
+string_to_blob (const GValue *src, GValue *dest)
+{
+ GdaBlob *blob;
+ const gchar *as_string;
+
+ g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
+ GDA_VALUE_HOLDS_BLOB (dest));
+
+ as_string = g_value_get_string (src);
+
+ blob = gda_string_to_blob (as_string);
+ g_return_if_fail (blob);
+ gda_value_take_blob (dest, blob);
+}
+
+static void
+blob_to_string (const GValue *src, GValue *dest)
+{
+ gchar *str;
+
+ g_return_if_fail (G_VALUE_HOLDS_STRING (dest) &&
+ GDA_VALUE_HOLDS_BLOB (src));
+
+ str = gda_blob_to_string ((GdaBlob *) gda_value_get_blob ((GValue *) src), 0);
+
+ g_value_take_string (dest, str);
+}
+
+/**
+ * gda_binary_new:
+ *
+ * Creates a new #GdaBinary coping data.
+ *
+ * Returns: (transfer full): the newly created #GdaBinary.
+ */
+GdaBinary*
+gda_binary_new (void)
+{
+ GdaBinary *binary = g_new0 (GdaBinary, 1);
+
+ binary->data = NULL;
+ binary->binary_length = 0;
+
+ return (GdaBinary*) binary;
+}
+
+/**
+ * gda_binary_set_data:
+ * @val: (array length=size): value to be copied by #GdaBinary.
+ * @size: the size of the memory pool pointer to by @val.
+ *
+ * Set binary data to a #GdaBinary, holding a copy of the data.
+ *
+ * Returns: (transfer full): the newly created #GdaBinary.
+ */
+void
+gda_binary_set_data (GdaBinary *binary, const guchar *val, glong size)
+{
+ g_return_if_fail (binary);
+ g_return_if_fail (val);
+ if (binary->data != NULL)
+ g_free (binary->data);
+ binary->data = g_memdup (val, size);
+ binary->binary_length = size;
+}
+
+
+/**
+ * gda_binary_get_data:
+ *
+ * Returns: (transfer none): associated data to #GdaBinary.
+ */
+gpointer
+gda_binary_get_data (GdaBinary *binary)
+{
+ g_return_val_if_fail (binary, NULL);
+
+ return binary->data;
+}
+
+
+
+/**
+ * gda_binary_reset_data:
+ *
+ * Frees data referenced by #GdaBinary
+ *
+ */
+void
+gda_binary_reset_data (GdaBinary *binary)
+{
+ g_return_if_fail (binary);
+
+ if (binary->data != NULL)
+ g_free (binary->data);
+ binary->data = NULL;
+ binary->binary_length = 0;
+}
+
+
+/**
+ * gda_binary_get_size:
+ *
+ * Returns: size of associated data to #GdaBinary or -1 in case of error.
+ */
+glong
+gda_binary_get_size (GdaBinary *binary)
+{
+ g_return_val_if_fail (binary, -1);
+
+ return binary->binary_length;
+}
+
+
/**
* gda_binary_copy:
* @boxed: source to get a copy from.
@@ -460,10 +587,9 @@ gda_binary_get_type (void)
*
* Free-function: gda_binary_free
*/
-gpointer
-gda_binary_copy (gpointer boxed)
+GdaBinary*
+gda_binary_copy (GdaBinary *src)
{
- GdaBinary *src = (GdaBinary*) boxed;
GdaBinary *copy = NULL;
g_return_val_if_fail (src, NULL);
@@ -482,48 +608,53 @@ gda_binary_copy (gpointer boxed)
* Deallocates all memory associated to the given #GdaBinary.
*/
void
-gda_binary_free (gpointer boxed)
+gda_binary_free (GdaBinary *binary)
{
- GdaBinary *binary = (GdaBinary*) boxed;
-
g_return_if_fail (binary);
- g_free (binary->data);
+ if (binary->data)
+ g_free (binary->data);
g_free (binary);
}
-/*
- * Register the GdaBlob type in the GType system
+/**
+ * gda_value_new_binary: (skip)
+ * @val: value to set for the new #GValue.
+ * @size: the size of the memory pool pointer to by @val.
+ *
+ * Makes a new #GValue of type #GDA_TYPE_BINARY with value @val.
+ *
+ * Returns: (transfer full): the newly created #GValue.
+ *
+ * Free-function: gda_value_free
*/
-/* Transform a String GValue to a GdaBlob*/
-static void
-string_to_blob (const GValue *src, GValue *dest)
+GValue *
+gda_value_new_binary (const guchar *val, glong size)
{
- GdaBlob *blob;
- const gchar *as_string;
+ GValue *value;
+ GdaBinary binary;
- g_return_if_fail (G_VALUE_HOLDS_STRING (src) &&
- GDA_VALUE_HOLDS_BLOB (dest));
+ /* We use the const on the function parameter to make this clearer,
+ * but it would be awkward to keep the const in the struct.
+ */
+ binary.data = (guchar*)val;
+ binary.binary_length = size;
- as_string = g_value_get_string (src);
+ value = g_new0 (GValue, 1);
+ gda_value_set_binary (value, &binary);
- blob = gda_string_to_blob (as_string);
- g_return_if_fail (blob);
- gda_value_take_blob (dest, blob);
+ return value;
}
-static void
-blob_to_string (const GValue *src, GValue *dest)
-{
- gchar *str;
- g_return_if_fail (G_VALUE_HOLDS_STRING (dest) &&
- GDA_VALUE_HOLDS_BLOB (src));
- str = gda_blob_to_string ((GdaBlob *) gda_value_get_blob ((GValue *) src), 0);
+// GdaBlob
+
+struct _GdaBlob {
+ GdaBinary *data;
+ GdaBlobOp *op;
+};
- g_value_take_string (dest, str);
-}
GType
gda_blob_get_type (void)
@@ -548,31 +679,74 @@ gda_blob_get_type (void)
}
/**
+ * gda_blob_new:
+ *
+ * Creates a new #GdaBlob.
+
+ * Returns: (transfer full): a newly allocated #GdaBlob.
+ */
+GdaBlob*
+gda_blob_new (void)
+{
+ GdaBlob* blob = g_new0 (GdaBlob, 1);
+ blob->data = gda_binary_new ();
+
+ return (GdaBlob*) blob;
+}
+
+/**
+ * gda_blob_get_binary:
+ *
+ * Returns: (transfer none): associated #GdaBinary.
+ */
+GdaBinary*
+gda_blob_get_binary (GdaBlob *blob)
+{
+ g_return_val_if_fail (blob, NULL);
+
+ return blob->data;
+}
+
+/**
+ * gda_blob_get_op:
+ *
+ * Returns: (transfer none): associated #GdaBlobOp.
+ */
+GdaBlobOp*
+gda_blob_get_op (GdaBlob *blob)
+{
+ g_return_val_if_fail (blob, NULL);
+
+ return blob->op;
+}
+
+
+/**
* gda_blob_copy:
- * @boxed: source to get a copy from.
+ * @src: source to get a copy from.
*
* Creates a new #GdaBlob structure from an existing one.
* Returns: (transfer full): a newly allocated #GdaBlob which contains a copy of information in @boxed.
*
- * Free-function: gda_blob_free
*/
-gpointer
-gda_blob_copy (gpointer boxed)
+GdaBlob*
+gda_blob_copy (GdaBlob *src)
{
- GdaBlob *src = (GdaBlob*) boxed;
GdaBlob *copy = NULL;
- g_return_val_if_fail (src, NULL);
+ g_return_val_if_fail (src != NULL, NULL);
copy = g_new0 (GdaBlob, 1);
- if (((GdaBinary *)src)->data) {
- ((GdaBinary *)copy)->data = g_memdup (((GdaBinary *)src)->data, ((GdaBinary
*)src)->binary_length);
- ((GdaBinary *)copy)->binary_length = ((GdaBinary *)src)->binary_length;
- }
+ copy->data = gda_binary_new ();
+ if (src->data == NULL) return copy;
+ if (src->data->data)
+ gda_binary_set_data (copy->data,
+ gda_binary_get_data (src->data),
+ gda_binary_get_size (src->data));
gda_blob_set_op (copy, src->op);
- return copy;
+ return (GdaBlob*) copy;
}
/**
@@ -582,17 +756,16 @@ gda_blob_copy (gpointer boxed)
* Deallocates all memory associated to the given #GdaBlob.
*/
void
-gda_blob_free (gpointer boxed)
+gda_blob_free (GdaBlob *blob)
{
- GdaBlob *blob = (GdaBlob*) boxed;
-
g_return_if_fail (blob);
if (blob->op) {
g_object_unref (blob->op);
blob->op = NULL;
}
- gda_binary_free ((GdaBinary *) blob);
+ gda_binary_free (blob->data);
+ g_free (blob);
}
/**
@@ -605,6 +778,8 @@ gda_blob_free (gpointer boxed)
void
gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op)
{
+ g_return_if_fail (blob);
+
if (blob->op) {
g_object_unref (blob->op);
blob->op = NULL;
@@ -1539,34 +1714,7 @@ gda_value_new_default (const gchar *default_val)
return value;
}
-/**
- * gda_value_new_binary: (skip)
- * @val: value to set for the new #GValue.
- * @size: the size of the memory pool pointer to by @val.
- *
- * Makes a new #GValue of type #GDA_TYPE_BINARY with value @val.
- *
- * Returns: (transfer full): the newly created #GValue.
- *
- * Free-function: gda_value_free
- */
-GValue *
-gda_value_new_binary (const guchar *val, glong size)
-{
- GValue *value;
- GdaBinary binary;
-
- /* We use the const on the function parameter to make this clearer,
- * but it would be awkward to keep the const in the struct.
- */
- binary.data = (guchar*)val;
- binary.binary_length = size;
-
- value = g_new0 (GValue, 1);
- gda_value_set_binary (value, &binary);
- return value;
-}
/**
* gda_value_new_blob: (skip)
@@ -1586,18 +1734,14 @@ gda_value_new_blob (const guchar *val, glong size)
GdaBlob *blob;
GdaBinary *bin;
- blob = g_new0 (GdaBlob, 1);
- bin = (GdaBinary*)(blob);
- bin->data = g_new (guchar, size);
- memcpy ((gpointer) bin->data, (gpointer) val, size); /* Flawfinder: ignore */
- bin->binary_length = size;
- blob->op = NULL;
-
- value = g_new0 (GValue, 1);
+ blob = gda_blob_new ();
+ bin = gda_blob_get_binary (blob);
+ gda_binary_set_data (bin, val, size);
+ value = g_new0 (GValue, 1);
g_value_init (value, GDA_TYPE_BLOB);
- g_value_take_boxed (value, blob);
+ g_value_take_boxed (value, blob);
- return value;
+ return value;
}
/**
diff --git a/libgda/gda-value.h b/libgda/gda-value.h
index 1037aaf..b915d2d 100644
--- a/libgda/gda-value.h
+++ b/libgda/gda-value.h
@@ -138,10 +138,22 @@ typedef struct {
* @data: (array length=binary_length): the actual data as an array
* @binary_length: length of @data
*/
-typedef struct {
- guchar *data;
- glong binary_length;
-} GdaBinary;
+typedef struct _GdaBinary GdaBinary;
+
+GValue* gda_value_new_binary (const guchar *val, glong size);
+const GdaBinary* gda_value_get_binary
(const GValue *value);
+void gda_value_set_binary (GValue *value, const GdaBinary *binary);
+void gda_value_take_binary (GValue *value, GdaBinary *binary);
+
+
+GType gda_binary_get_type (void) G_GNUC_CONST;
+GdaBinary* gda_binary_new (void);
+glong gda_binary_get_size (GdaBinary* binary);
+gpointer gda_binary_get_data (GdaBinary* binary);
+void gda_binary_reset_data (GdaBinary* binary);
+void gda_binary_set_data (GdaBinary *binary, const guchar *val, glong size);
+GdaBinary* gda_binary_copy (GdaBinary *src);
+void gda_binary_free (GdaBinary *binary);
/**
* GdaBlob:
@@ -152,10 +164,17 @@ typedef struct {
* @op is generally set up by database providers when giving access to an existing BLOB in
* a database, but can be modified if needed using gda_blob_set_op().
*/
-typedef struct {
- GdaBinary data;
- GdaBlobOp *op;
-} GdaBlob;
+typedef struct _GdaBlob GdaBlob;
+
+
+GType gda_blob_get_type (void) G_GNUC_CONST;
+GdaBlob* gda_blob_new (void);
+GdaBinary* gda_blob_get_binary (GdaBlob *blob);
+GdaBlobOp* gda_blob_get_op (GdaBlob *blob);
+GdaBlob* gda_blob_copy (GdaBlob *src);
+void gda_blob_free (GdaBlob *blob);
+void gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op);
+
#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))
@@ -200,7 +219,6 @@ GValue *gda_value_new (GType type);
GValue *gda_value_new_null (void);
GValue *gda_value_new_default (const gchar *default_val);
-GValue *gda_value_new_binary (const guchar *val, glong size);
GValue *gda_value_new_blob (const guchar *val, glong size);
GValue *gda_value_new_blob_from_file (const gchar *filename);
GValue *gda_value_new_time_from_timet (time_t val);
@@ -216,9 +234,6 @@ gboolean gda_value_is_null (const GValue *value);
gboolean gda_value_is_number (const GValue *value);
GValue *gda_value_copy (const GValue *value);
-const GdaBinary *gda_value_get_binary (const GValue *value);
-void gda_value_set_binary (GValue *value, const GdaBinary *binary);
-void gda_value_take_binary (GValue *value, GdaBinary *binary);
const GdaBlob *gda_value_get_blob (const GValue *value);
void gda_value_set_blob (GValue *value, const GdaBlob *blob);
@@ -280,15 +295,6 @@ GType gda_geometricpoint_get_type (void) G_GNUC_CONS
gpointer gda_geometricpoint_copy (gpointer boxed);
void gda_geometricpoint_free (gpointer boxed);
-GType gda_binary_get_type (void) G_GNUC_CONST;
-gpointer gda_binary_copy (gpointer boxed);
-void gda_binary_free (gpointer boxed);
-
-GType gda_blob_get_type (void) G_GNUC_CONST;
-gpointer gda_blob_copy (gpointer boxed);
-void gda_blob_free (gpointer boxed);
-void gda_blob_set_op (GdaBlob *blob, GdaBlobOp *op);
-
GType gda_short_get_type (void) G_GNUC_CONST;
GType gda_ushort_get_type (void) G_GNUC_CONST;
diff --git a/libgda/gda-xa-transaction.c b/libgda/gda-xa-transaction.c
index 5b56ff6..d6bb8b0 100644
--- a/libgda/gda-xa-transaction.c
+++ b/libgda/gda-xa-transaction.c
@@ -293,9 +293,8 @@ gda_xa_transaction_register_connection (GdaXaTransaction *xa_trans, GdaConnecti
const GdaBinary *ebranch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
if (ebranch) {
- bin = g_new0 (GdaBinary, 1);
- bin->data = (guchar*) g_strdup (branch);
- bin->binary_length = strlen (branch) + 1;
+ bin = gda_binary_new ();
+ gda_binary_set_data (bin, branch, strlen (branch) + 1);
g_hash_table_insert (xa_trans->priv->cnc_hash, cnc, bin);
return TRUE;
}
@@ -325,9 +324,8 @@ gda_xa_transaction_register_connection (GdaXaTransaction *xa_trans, GdaConnecti
xa_trans->priv->non_xa_cnc = cnc;
}
- bin = g_new0 (GdaBinary, 1);
- bin->data = (guchar*) g_strdup (branch);
- bin->binary_length = strlen (branch) + 1;
+ bin = gda_binary_new ();
+ gda_binary_set_data (bin, branch, strlen (branch) + 1);
xa_trans->priv->cnc_list = g_list_prepend (xa_trans->priv->cnc_list, cnc);
g_hash_table_insert (xa_trans->priv->cnc_hash, cnc, bin);
g_object_ref (cnc);
@@ -388,7 +386,7 @@ gda_xa_transaction_begin (GdaXaTransaction *xa_trans, GError **error)
const GdaBinary *branch;
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder:
ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
if (! _gda_server_provider_xa_start (prov, cnc, &(xa_trans->priv->xid), error))
break;
}
@@ -412,7 +410,7 @@ gda_xa_transaction_begin (GdaXaTransaction *xa_trans, GError **error)
const GdaBinary *branch;
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /*
Flawfinder: ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
}
else {
@@ -469,7 +467,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
if (!_gda_server_provider_xa_end (prov, cnc, &(xa_trans->priv->xid), error))
break;
@@ -491,7 +489,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
prov = gda_connection_get_provider (cnc);
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /*
Flawfinder: ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
}
}
@@ -516,7 +514,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
prov = gda_connection_get_provider (cnc);
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /*
Flawfinder: ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), NULL);
}
}
@@ -535,7 +533,7 @@ gda_xa_transaction_commit (GdaXaTransaction *xa_trans, GSList **cnc_to_recover,
prov = gda_connection_get_provider (cnc);
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder: ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
if (! _gda_server_provider_xa_commit (prov, cnc, &(xa_trans->priv->xid), error) &&
cnc_to_recover)
*cnc_to_recover = g_slist_prepend (*cnc_to_recover, cnc);
@@ -572,7 +570,7 @@ gda_xa_transaction_rollback (GdaXaTransaction *xa_trans, GError **error)
const GdaBinary *branch;
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder:
ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
GError *lerror = NULL;
_gda_server_provider_xa_rollback (prov, cnc, &(xa_trans->priv->xid), &lerror);
if (error && !*error)
@@ -628,7 +626,7 @@ gda_xa_transaction_commit_recovered (GdaXaTransaction *xa_trans, GSList **cnc_to
branch = g_hash_table_lookup (xa_trans->priv->cnc_hash, cnc);
memcpy (xa_trans->priv->xid.data + xa_trans->priv->xid.gtrid_length, /* Flawfinder:
ignore */
- branch->data, branch->binary_length);
+ gda_binary_get_data (branch), gda_binary_get_size (branch));
for (xlist = recov_xid_list; xlist; xlist = xlist->next) {
GdaXaTransactionId *xid = (GdaXaTransactionId*) xlist->data;
if (!xid)
diff --git a/libgda/handlers/gda-handler-bin.c b/libgda/handlers/gda-handler-bin.c
index 88fb8ae..5dfef1d 100644
--- a/libgda/handlers/gda-handler-bin.c
+++ b/libgda/handlers/gda-handler-bin.c
@@ -186,9 +186,9 @@ gda_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface, const G
GdaBinary *bin;
blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op (blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
gchar *str, *str2;
str = gda_binary_to_string (bin, 0);
@@ -213,8 +213,8 @@ gda_handler_bin_get_str_from_value (G_GNUC_UNUSED GdaDataHandler *iface, const G
else {
GdaBlob *blob;
blob = (GdaBlob*) gda_value_get_blob ((GValue *) value);
- if (blob->op)
- gda_blob_op_read_all (blob->op, blob);
+ if (gda_blob_get_op (blob))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
retval = gda_binary_to_string ((GdaBinary *) blob, 0);
}
}
diff --git a/libgda/sqlite/gda-sqlite-blob-op.c b/libgda/sqlite/gda-sqlite-blob-op.c
index d973253..e7fade4 100644
--- a/libgda/sqlite/gda-sqlite-blob-op.c
+++ b/libgda/sqlite/gda-sqlite-blob-op.c
@@ -198,6 +198,7 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
{
GdaSqliteBlobOp *bop;
GdaBinary *bin;
+ gpointer buffer = NULL;
int rc;
g_return_val_if_fail (GDA_IS_SQLITE_BLOB_OP (op), -1);
@@ -213,11 +214,8 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
if (size > G_MAXINT)
return -1;
- bin = (GdaBinary *) blob;
- if (bin->data)
- g_free (bin->data);
- bin->data = g_new0 (guchar, size);
- bin->binary_length = 0;
+ bin = gda_blob_get_binary (blob);
+ gda_binary_set_data (bin, (guchar*) "", 0);
/* fetch blob data using C API into bin->data, and set bin->binary_length */
int rsize;
@@ -235,16 +233,15 @@ gda_sqlite_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
if (len - offset < rsize)
rsize = len - offset;
-
- rc = SQLITE3_CALL (sqlite3_blob_read) (bop->priv->sblob, bin->data, rsize, offset);
+
+ rc = SQLITE3_CALL (sqlite3_blob_read) (bop->priv->sblob, buffer, rsize, offset);
if (rc != SQLITE_OK) {
- g_free (bin->data);
- bin->data = NULL;
+ gda_binary_reset_data (bin);
return -1;
}
- bin->binary_length = rsize;
+ gda_binary_set_data (bin, buffer, rsize);
- return bin->binary_length;
+ return gda_binary_get_size (bin);
}
/*
@@ -268,18 +265,18 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
if (len < 0)
return -1;
- if (blob->op && (blob->op != op)) {
+ if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
/* use data through blob->op */
#define buf_size 16384
gint nread = 0;
- GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
- gda_blob_set_op (tmpblob, blob->op);
+ GdaBlob *tmpblob = gda_blob_new ();
+ gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
nbwritten = 0;
- for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+ for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
nread > 0;
- nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+ nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
int tmp_written;
int rc;
int wlen;
@@ -290,7 +287,7 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
wlen = nread;
rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob,
- ((GdaBinary *)tmpblob)->data, wlen, offset +
nbwritten);
+ gda_binary_get_data (gda_blob_get_binary
(tmpblob)), wlen, offset + nbwritten);
if (rc != SQLITE_OK)
tmp_written = -1;
else
@@ -312,13 +309,13 @@ gda_sqlite_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
/* write blob using bin->data and bin->binary_length */
int rc;
int wlen;
- bin = (GdaBinary *) blob;
- if (bin->binary_length + offset > len)
+ bin = gda_blob_get_binary (blob);
+ if (gda_binary_get_size (bin) + offset > len)
wlen = len - offset;
else
- wlen = bin->binary_length;
+ wlen = gda_binary_get_size (bin);
- rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob, bin->data, wlen, offset);
+ rc = SQLITE3_CALL (sqlite3_blob_write) (bop->priv->sblob, gda_binary_get_data (bin), wlen,
offset);
if (rc != SQLITE_OK)
nbwritten = -1;
else
diff --git a/libgda/sqlite/gda-sqlite-handler-bin.c b/libgda/sqlite/gda-sqlite-handler-bin.c
index 42e3e3a..d0282bb 100644
--- a/libgda/sqlite/gda-sqlite-handler-bin.c
+++ b/libgda/sqlite/gda-sqlite-handler-bin.c
@@ -165,13 +165,13 @@ gda_sqlite_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
gint i;
bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
- retval = g_new0 (gchar, bin->binary_length * 2 + 4);
+ retval = g_new0 (gchar, gda_binary_get_size (bin) * 2 + 4);
retval [0] = 'x';
retval [1] = '\'';
- for (i = 0; i < bin->binary_length; i++) {
+ for (i = 0; i < gda_binary_get_size (bin); i++) {
guchar *ptr;
- ptr = bin->data + i;
+ ptr = gda_binary_get_data (bin) + i;
if ((*ptr >> 4) <= 9)
retval [2*i + 2] = (*ptr >> 4) + '0';
else
@@ -181,7 +181,7 @@ gda_sqlite_handler_bin_get_sql_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
else
retval [2*i + 3] = (*ptr & 0xF) + 'A' - 10;
}
- retval [bin->binary_length * 2 + 2] = '\'';
+ retval [gda_binary_get_size (bin) * 2 + 2] = '\'';
return retval;
}
@@ -196,11 +196,11 @@ gda_sqlite_handler_bin_get_str_from_value (G_GNUC_UNUSED GdaDataHandler *iface,
gint i;
bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
- retval = g_new0 (gchar, bin->binary_length * 2 + 1);
- for (i = 0; i < bin->binary_length; i++) {
+ retval = g_new0 (gchar, gda_binary_get_size (bin) * 2 + 1);
+ for (i = 0; i < gda_binary_get_size (bin); i++) {
guchar *ptr;
- ptr = bin->data + i;
+ ptr = gda_binary_get_data (bin) + i;
if ((*ptr >> 4) <= 9)
retval [2*i] = (*ptr >> 4) + '0';
else
@@ -242,13 +242,14 @@ gda_sqlite_handler_bin_get_value_from_sql (G_GNUC_UNUSED GdaDataHandler *iface,
(sql[n] == '\'')) {
GdaBinary *bin;
- bin = g_new0 (GdaBinary, 1);
+ bin = gda_binary_new ();
if (n > 3) {
gint i;
- bin->data = g_new0 (guchar, (n-3)/2);
+ guchar* buffer = g_new0 (guchar, (n-3)/2);
for (i = 2; i < n-1; i += 2)
- bin->data [i/2 - 1] = (hex_to_int (sql[i]) << 4) | hex_to_int (sql
[i+1]);
- bin->binary_length = n-3;
+ buffer [i/2 - 1] = (hex_to_int (sql[i]) << 4) | hex_to_int (sql
[i+1]);
+ gda_binary_set_data (bin, buffer, n-3);
+ g_free (buffer);
}
value = gda_value_new (GDA_TYPE_BINARY);
@@ -271,15 +272,15 @@ gda_sqlite_handler_bin_get_value_from_str (G_GNUC_UNUSED GdaDataHandler *iface,
if (! (n % 2)) {
GdaBinary *bin;
- bin = g_new0 (GdaBinary, 1);
+ bin = gda_binary_new ();
+ guchar* buffer = NULL;
if (n > 0) {
gint i;
- bin->data = g_new0 (guchar, n/2);
+ buffer = g_new0 (guchar, n/2);
for (i = 0; i < n; i += 2)
- bin->data [i/2] = (hex_to_int (str[i]) << 4) | hex_to_int (str [i+1]);
- bin->binary_length = n;
+ buffer [i/2] = (hex_to_int (str[i]) << 4) | hex_to_int (str [i+1]);
}
-
+ gda_binary_set_data (bin, buffer, n);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_take_binary (value, bin);
}
diff --git a/libgda/sqlite/gda-sqlite-provider.c b/libgda/sqlite/gda-sqlite-provider.c
index 931909d..a909cb8 100644
--- a/libgda/sqlite/gda-sqlite-provider.c
+++ b/libgda/sqlite/gda-sqlite-provider.c
@@ -3197,10 +3197,10 @@ gda_sqlite_provider_statement_execute (GdaServerProvider *provider, GdaConnectio
const gchar *str = NULL;
/* force reading the complete BLOB into memory */
- if (blob->op)
- blob_len = gda_blob_op_get_length (blob->op);
+ if (gda_blob_get_op (blob))
+ blob_len = gda_blob_op_get_length (gda_blob_get_op (blob));
else
- blob_len = ((GdaBinary*) blob)->binary_length;
+ blob_len = gda_binary_get_size (gda_blob_get_binary (blob));
if (blob_len < 0)
str = _("Can't get BLOB's length");
else if (blob_len >= G_MAXINT)
@@ -3241,7 +3241,7 @@ gda_sqlite_provider_statement_execute (GdaServerProvider *provider, GdaConnectio
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
GdaBinary *bin = (GdaBinary *) gda_value_get_binary (value);
SQLITE3_CALL (sqlite3_bind_blob) (ps->sqlite_stmt, i,
- bin->data, bin->binary_length, SQLITE_TRANSIENT);
+ gda_binary_get_data (bin), gda_binary_get_size
(bin), SQLITE_TRANSIENT);
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_TIME) {
GString *string;
@@ -3575,20 +3575,20 @@ scalar_gda_hex_print_func (sqlite3_context *context, int argc, sqlite3_value **a
return;
}
- bin = g_new0 (GdaBinary, 1);
- bin->data = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
- if (!bin->data) {
- g_free (bin);
+ bin = gda_binary_new ();
+ guchar* buffer = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
+ if (!buffer) {
+ gda_binary_free (bin);
SQLITE3_CALL (sqlite3_result_null) (context);
return;
}
- bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+ glong length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+ gda_binary_set_data (bin, buffer, length);
+ g_free (free);
gda_value_take_binary ((value = gda_value_new (GDA_TYPE_BINARY)), bin);
dh = gda_data_handler_get_default (GDA_TYPE_BINARY);
str = gda_data_handler_get_str_from_value (dh, value);
- bin->data = NULL;
- bin->binary_length = 0;
gda_value_free (value);
SQLITE3_CALL (sqlite3_result_text) (context, str, -1, g_free);
}
@@ -3607,20 +3607,19 @@ scalar_gda_hex_print_func2 (sqlite3_context *context, int argc, sqlite3_value **
return;
}
- bin = g_new0 (GdaBinary, 1);
- bin->data = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
- if (!bin->data) {
- g_free (bin);
+ bin = gda_binary_new ();
+ guchar* buffer = (guchar*) SQLITE3_CALL (sqlite3_value_blob) (argv [0]);
+ if (!buffer) {
+ gda_binary_free (bin);
SQLITE3_CALL (sqlite3_result_null) (context);
return;
}
- bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+ glong length = SQLITE3_CALL (sqlite3_value_bytes) (argv [0]);
+ gda_binary_set_data (bin, buffer, length);
gda_value_take_binary ((value = gda_value_new (GDA_TYPE_BINARY)), bin);
dh = gda_data_handler_get_default (GDA_TYPE_BINARY);
str = gda_data_handler_get_str_from_value (dh, value);
- bin->data = NULL;
- bin->binary_length = 0;
gda_value_free (value);
size = SQLITE3_CALL (sqlite3_value_int) (argv [1]);
diff --git a/libgda/sqlite/gda-sqlite-recordset.c b/libgda/sqlite/gda-sqlite-recordset.c
index 43518b4..677ecaf 100644
--- a/libgda/sqlite/gda-sqlite-recordset.c
+++ b/libgda/sqlite/gda-sqlite-recordset.c
@@ -351,6 +351,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
GdaSqlitePStmt *ps;
GdaRow *prow = NULL;
GdaConnection *cnc;
+ glong length;
cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
cdata = (SqliteConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
@@ -466,16 +467,12 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
else if (type == GDA_TYPE_BINARY) {
GdaBinary *bin;
- bin = g_new0 (GdaBinary, 1);
- bin->binary_length = SQLITE3_CALL (sqlite3_column_bytes)
(ps->sqlite_stmt, real_col);
- if (bin->binary_length > 0) {
- bin->data = g_new (guchar, bin->binary_length);
- memcpy (bin->data, SQLITE3_CALL (sqlite3_column_blob)
(ps->sqlite_stmt, /* Flawfinder: ignore */
-
real_col),
- bin->binary_length);
+ bin = gda_binary_new ();
+ length = SQLITE3_CALL (sqlite3_column_bytes) (ps->sqlite_stmt,
real_col);
+ if (length > 0) {
+ gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_column_blob)
(ps->sqlite_stmt, /* Flawfinder: ignore */
+
real_col), length);
}
- else
- bin->binary_length = 0;
gda_value_take_binary (value, bin);
}
else if (type == GDA_TYPE_BLOB) {
@@ -517,7 +514,7 @@ fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **er
}
else {
GdaBlob *blob;
- blob = g_new0 (GdaBlob, 1);
+ blob = gda_blob_new ();
gda_blob_set_op (blob, bop);
g_object_unref (bop);
gda_value_take_blob (value, blob);
diff --git a/libgda/sqlite/virtual/gda-vprovider-data-model.c
b/libgda/sqlite/virtual/gda-vprovider-data-model.c
index 0393eaf..ad448f6 100644
--- a/libgda/sqlite/virtual/gda-vprovider-data-model.c
+++ b/libgda/sqlite/virtual/gda-vprovider-data-model.c
@@ -1042,15 +1042,17 @@ virtualColumn (sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
GdaBinary *bin;
blob = (GdaBlob *) gda_value_get_blob (value);
bin = (GdaBinary *) blob;
- if (blob->op &&
- (bin->binary_length != gda_blob_op_get_length (blob->op)))
- gda_blob_op_read_all (blob->op, blob);
- SQLITE3_CALL (sqlite3_result_blob) (ctx, blob->data.data, blob->data.binary_length,
SQLITE_TRANSIENT);
+ if (gda_blob_get_op (blob) &&
+ (gda_binary_get_size (bin) != gda_blob_op_get_length (gda_blob_get_op(blob))))
+ gda_blob_op_read_all (gda_blob_get_op (blob), blob);
+ SQLITE3_CALL (sqlite3_result_blob) (ctx, gda_binary_get_data (gda_blob_get_binary (blob)),
+ gda_binary_get_size (gda_blob_get_binary (blob)),
+ SQLITE_TRANSIENT);
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- SQLITE3_CALL (sqlite3_result_blob) (ctx, bin->data, bin->binary_length, SQLITE_TRANSIENT);
+ SQLITE3_CALL (sqlite3_result_blob) (ctx, gda_binary_get_data (bin), gda_binary_get_size
(bin), SQLITE_TRANSIENT);
}
else {
gchar *str = gda_value_stringify (value);
@@ -1091,15 +1093,12 @@ create_value_from_sqlite3_value_notype (sqlite3_value *svalue)
case SQLITE_BLOB: {
GdaBinary *bin;
g_value_init (value, GDA_TYPE_BINARY);
- bin = g_new0 (GdaBinary, 1);
- bin->binary_length = SQLITE3_CALL (sqlite3_value_bytes) (svalue);
- if (bin->binary_length > 0) {
- bin->data = g_new (guchar, bin->binary_length);
- memcpy (bin->data, SQLITE3_CALL (sqlite3_value_blob) (svalue),
- bin->binary_length);
+ bin = gda_binary_new ();
+ glong length = SQLITE3_CALL (sqlite3_value_bytes) (svalue);
+ if (length > 0) {
+ gpointer data = g_new (guchar, length);
+ gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_value_blob) (svalue), length);
}
- else
- bin->binary_length = 0;
gda_value_take_binary (value, bin);
break;
}
diff --git a/providers/postgres/gda-postgres-blob-op.c b/providers/postgres/gda-postgres-blob-op.c
index ef2c070..ede0b74 100644
--- a/providers/postgres/gda-postgres-blob-op.c
+++ b/providers/postgres/gda-postgres-blob-op.c
@@ -334,17 +334,17 @@ gda_postgres_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong siz
goto out_error;
}
- bin = (GdaBinary *) blob;
- if (bin->data)
- g_free (bin->data);
- bin->data = g_new0 (guchar, size);
- bin->binary_length = lo_read (pconn, pgop->priv->fd, (char *) (bin->data), size);
+ bin = gda_blob_get_binary (blob);
+ gda_binary_reset_data (bin);
+ guchar *buffer = g_new0 (guchar, size);
+ glong l = lo_read (pconn, pgop->priv->fd, (char *) (buffer), size);
+ gda_binary_set_data (bin, buffer, l);
blob_op_close (pgop);
if (transaction_started)
gda_connection_rollback_transaction (pgop->priv->cnc, NULL, NULL);
- return bin->binary_length;
+ return gda_binary_get_size (bin);
out_error:
blob_op_close (pgop);
@@ -380,25 +380,25 @@ gda_postgres_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
goto out_error;
}
- if (blob->op && (blob->op != op)) {
+ if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
/* use data through blob->op */
#define buf_size 16384
gint nread = 0;
- GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
- gda_blob_set_op (tmpblob, blob->op);
+ GdaBlob *tmpblob = gda_blob_new ();
+ gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
nbwritten = 0;
- for (nread = gda_blob_op_read (tmpblob->op, tmpblob, 0, buf_size);
+ for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, 0, buf_size);
nread > 0;
- nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
- GdaBinary *bin = (GdaBinary *) tmpblob;
+ nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
+ GdaBinary *bin = gda_blob_get_binary (tmpblob);
glong tmp_written;
- tmp_written = lo_write (pconn, pgop->priv->fd, (char*) bin->data,
- bin->binary_length);
- if (tmp_written < bin->binary_length) {
+ tmp_written = lo_write (pconn, pgop->priv->fd, (char*) gda_binary_get_data (bin),
+ gda_binary_get_size (bin));
+ if (tmp_written < gda_binary_get_size (bin)) {
_gda_postgres_make_error (pgop->priv->cnc, pconn, NULL, NULL);
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
goto out_error;
}
nbwritten += tmp_written;
@@ -406,12 +406,12 @@ gda_postgres_blob_op_write (GdaBlobOp *op, GdaBlob *blob, glong offset)
/* nothing more to read */
break;
}
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
}
else {
/* use data in (GdaBinary *) blob */
- GdaBinary *bin = (GdaBinary *) blob;
- nbwritten = lo_write (pconn, pgop->priv->fd, (char*) bin->data, bin->binary_length);
+ GdaBinary *bin = gda_blob_get_binary (blob);
+ nbwritten = lo_write (pconn, pgop->priv->fd, (char*) gda_binary_get_data (bin),
gda_binary_get_size (bin));
if (nbwritten == -1) {
_gda_postgres_make_error (pgop->priv->cnc, pconn, NULL, NULL);
goto out_error;
diff --git a/providers/postgres/gda-postgres-handler-bin.c b/providers/postgres/gda-postgres-handler-bin.c
index 4daf9d6..44a3f0e 100644
--- a/providers/postgres/gda-postgres-handler-bin.c
+++ b/providers/postgres/gda-postgres-handler-bin.c
@@ -194,8 +194,8 @@ gda_postgres_handler_bin_get_sql_from_value (GdaDataHandler *iface, const GValue
/*tmp = PQescapeByteaConn (cdata->pconn, data, length, &retlength);*/
}
else
- tmp = (gchar *) PQescapeBytea (data->data,
- data->binary_length, &retlength);
+ tmp = (gchar *) PQescapeBytea (gda_binary_get_data (data),
+ gda_binary_get_size (data), &retlength);
if (tmp) {
retval = g_strdup_printf ("'%s'", tmp);
PQfreemem (tmp);
diff --git a/providers/postgres/gda-postgres-provider.c b/providers/postgres/gda-postgres-provider.c
index fde3d04..154f86b 100644
--- a/providers/postgres/gda-postgres-provider.c
+++ b/providers/postgres/gda-postgres-provider.c
@@ -2208,8 +2208,8 @@ gda_postgres_provider_statement_execute (GdaServerProvider *provider, GdaConnect
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
/* directly bin binary data */
GdaBinary *bin = (GdaBinary *) gda_value_get_binary ((GValue *) value);
- param_values [i] = (gchar*) bin->data;
- param_lengths [i] = bin->binary_length;
+ param_values [i] = (gchar*) gda_binary_get_data (bin);
+ param_lengths [i] = gda_binary_get_size (bin);
param_formats [i] = 1; /* binary format */
param_mem [i] = TRUE; /* don't free later */
}
diff --git a/providers/postgres/gda-postgres-recordset.c b/providers/postgres/gda-postgres-recordset.c
index 2d95007..43687ca 100644
--- a/providers/postgres/gda-postgres-recordset.c
+++ b/providers/postgres/gda-postgres-recordset.c
@@ -737,9 +737,8 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
}
if (! *ptr) {
GdaBinary *bin;
- bin = g_new (GdaBinary, 1);
- bin->data = unescaped;
- bin->binary_length = pqlength;
+ bin = gda_binary_new ();
+ gda_binary_set_data (bin, unescaped, pqlength);
gda_value_take_binary (value, bin);
valueset = TRUE;
}
@@ -748,10 +747,9 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
else {
unescaped = PQunescapeBytea ((guchar*) thevalue, &pqlength);
if (unescaped) {
- GdaBinary bin;
- bin.data = unescaped;
- bin.binary_length = pqlength;
- gda_value_set_binary (value, &bin);
+ GdaBinary* bin = gda_binary_new ();
+ gda_binary_set_data (bin, unescaped, pqlength);
+ gda_value_take_binary (value, bin);
PQfreemem (unescaped);
valueset = TRUE;
}
@@ -771,7 +769,7 @@ set_value (GdaConnection *cnc, GdaRow *row, GValue *value, GType type, const gch
else if (type == GDA_TYPE_BLOB) {
GdaBlob *blob;
GdaBlobOp *op;
- blob = g_new0 (GdaBlob, 1);
+ blob = gda_blob_new ();
op = gda_postgres_blob_op_new_with_id (cnc, thevalue);
gda_blob_set_op (blob, op);
g_object_unref (op);
diff --git a/providers/skel-implementation/capi/gda-capi-blob-op.c
b/providers/skel-implementation/capi/gda-capi-blob-op.c
index fc72351..ef37acf 100644
--- a/providers/skel-implementation/capi/gda-capi-blob-op.c
+++ b/providers/skel-implementation/capi/gda-capi-blob-op.c
@@ -164,16 +164,18 @@ gda_capi_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
return -1;
g_return_val_if_fail (blob, -1);
- bin = (GdaBinary *) blob;
- if (bin->data)
- g_free (bin->data);
- bin->data = g_new0 (guchar, size);
- bin->binary_length = 0;
+ bin = gda_blob_get_binary (blob);
+ if (gda_binary_get_data (bin))
+ gda_binary_reset_data (bin);
+ g_free (gda_binary_get_data (bin));
+ guchar* buffer = g_new0 (guchar, size);
+ gda_binary_set_data (bin, buffer, size);
+ g_free (buffer);
/* fetch blob data using C API into bin->data, and set bin->binary_length */
TO_IMPLEMENT;
- return bin->binary_length;
+ return gda_binary_get_size (bin);
}
/*
@@ -192,25 +194,25 @@ gda_capi_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset
g_return_val_if_fail (GDA_IS_CONNECTION (bop->priv->cnc), -1);
g_return_val_if_fail (blob, -1);
- if (blob->op && (blob->op != op)) {
+ if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
/* use data through blob->op */
#define buf_size 16384
gint nread = 0;
- GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
- gda_blob_set_op (tmpblob, blob->op);
+ GdaBlob *tmpblob = gda_blob_new ();
+ gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
nbwritten = 0;
- for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+ for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
nread > 0;
- nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+ nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
glong tmp_written;
tmp_written = -1; TO_IMPLEMENT;
if (tmp_written < 0) {
/* treat error */
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
return -1;
}
nbwritten += tmp_written;
@@ -218,12 +220,12 @@ gda_capi_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset
/* nothing more to read */
break;
}
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
}
else {
/* write blob using bin->data and bin->binary_length */
- bin = (GdaBinary *) blob;
- g_warning("bin not used. length=%ld", bin->binary_length); /* Avoids a compiler warning. */
+ bin = gda_blob_get_binary (blob);
+ g_warning("bin not used. length=%ld", gda_binary_get_size (bin)); /* Avoids a compiler
warning. */
nbwritten = -1; TO_IMPLEMENT;
}
diff --git a/providers/web/gda-web-blob-op.c b/providers/web/gda-web-blob-op.c
index d98ccab..d79c143 100644
--- a/providers/web/gda-web-blob-op.c
+++ b/providers/web/gda-web-blob-op.c
@@ -162,16 +162,15 @@ gda_web_blob_op_read (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size)
return -1;
g_return_val_if_fail (blob, -1);
- bin = (GdaBinary *) blob;
- if (bin->data)
- g_free (bin->data);
- bin->data = g_new0 (guchar, size);
- bin->binary_length = 0;
+ bin = gda_blob_get_binary (blob);
+ gda_binary_reset_data (bin);
+ guchar *buffer = g_new0 (guchar, size);
+ gda_binary_set_data (bin, buffer, 0);
/* fetch blob data using C API into bin->data, and set bin->binary_length */
TO_IMPLEMENT;
- return bin->binary_length;
+ return gda_binary_get_size (bin);
}
/*
@@ -190,25 +189,25 @@ gda_web_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset)
g_return_val_if_fail (GDA_IS_CONNECTION (bop->priv->cnc), -1);
g_return_val_if_fail (blob, -1);
- if (blob->op && (blob->op != op)) {
+ if (gda_blob_get_op (blob) && (gda_blob_get_op (blob) != op)) {
/* use data through blob->op */
#define buf_size 16384
gint nread = 0;
- GdaBlob *tmpblob = g_new0 (GdaBlob, 1);
- gda_blob_set_op (tmpblob, blob->op);
+ GdaBlob *tmpblob = gda_blob_new ();
+ gda_blob_set_op (tmpblob, gda_blob_get_op (blob));
nbwritten = 0;
- for (nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size);
+ for (nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size);
nread > 0;
- nread = gda_blob_op_read (tmpblob->op, tmpblob, nbwritten, buf_size)) {
+ nread = gda_blob_op_read (gda_blob_get_op (tmpblob), tmpblob, nbwritten, buf_size)) {
glong tmp_written;
tmp_written = -1; TO_IMPLEMENT;
if (tmp_written < 0) {
/* treat error */
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
return -1;
}
nbwritten += tmp_written;
@@ -216,12 +215,12 @@ gda_web_blob_op_write (GdaBlobOp *op, GdaBlob *blob, G_GNUC_UNUSED glong offset)
/* nothing more to read */
break;
}
- gda_blob_free ((gpointer) tmpblob);
+ gda_blob_free (tmpblob);
}
else {
/* write blob using bin->data and bin->binary_length */
- bin = (GdaBinary *) blob;
- g_warning("bin not used. length=%ld", bin->binary_length); /* Avoids a compiler warning. */
+ bin = gda_blob_get_binary (blob);
+ g_warning("bin not used. length=%ld", gda_binary_get_size (bin)); /* Avoids a compiler
warning. */
nbwritten = -1; TO_IMPLEMENT;
}
diff --git a/testing/gdaui-test-data-entries.c b/testing/gdaui-test-data-entries.c
index 0724b20..e7ac06d 100644
--- a/testing/gdaui-test-data-entries.c
+++ b/testing/gdaui-test-data-entries.c
@@ -924,12 +924,12 @@ entry_contents_or_attrs_changed (GtkWidget *entry, G_GNUC_UNUSED gpointer data)
if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
const GdaBinary *bin;
bin = gda_value_get_binary (value);
- strval = g_strdup_printf ("Binary data, size=%ld", bin->binary_length);
+ strval = g_strdup_printf ("Binary data, size=%ld", gda_binary_get_size (bin));
}
else if (G_VALUE_TYPE (value) == GDA_TYPE_BLOB) {
const GdaBlob *blob;
blob = gda_value_get_blob (value);
- strval = g_strdup_printf ("Blob data, size=%ld", ((GdaBinary*) blob)->binary_length);
+ strval = g_strdup_printf ("Blob data, size=%ld", gda_binary_get_size
(gda_blob_get_binary (blob)));
}
else
strval = gda_data_handler_get_sql_from_value (dh, value);
diff --git a/tools/common/t-app.c b/tools/common/t-app.c
index cc147df..6797d35 100644
--- a/tools/common/t-app.c
+++ b/tools/common/t-app.c
@@ -4539,7 +4539,7 @@ extra_command_export (ToolCommand *command, guint argc, const gchar **argv,
GValue *vblob = gda_value_new_blob_from_file (filename);
GdaBlob *tblob = (GdaBlob*) gda_value_get_blob (vblob);
const GdaBlob *fblob = gda_value_get_blob (value);
- if (gda_blob_op_write (tblob->op, (GdaBlob*) fblob, 0) < 0)
+ if (gda_blob_op_write (gda_blob_get_op (tblob), (GdaBlob*) fblob, 0) < 0)
g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR,
"%s", _("Could not write file"));
else
@@ -4549,16 +4549,17 @@ extra_command_export (ToolCommand *command, guint argc, const gchar **argv,
else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) {
GValue *vblob = gda_value_new_blob_from_file (filename);
GdaBlob *tblob = (GdaBlob*) gda_value_get_blob (vblob);
- GdaBlob *fblob = g_new0 (GdaBlob, 1);
+ GdaBlob *fblob = gda_blob_new ();
const GdaBinary *fbin = gda_value_get_binary (value);
- ((GdaBinary *) fblob)->data = fbin->data;
- ((GdaBinary *) fblob)->binary_length = fbin->binary_length;
- if (gda_blob_op_write (tblob->op, (GdaBlob*) fblob, 0) < 0)
+ gda_binary_set_data (gda_blob_get_binary (fblob),
+ gda_binary_get_data (fbin),
+ gda_binary_get_size (fbin));
+ if (gda_blob_op_write (gda_blob_get_op (tblob), (GdaBlob*) fblob, 0) < 0)
g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR,
"%s", _("Could not write file"));
else
done = TRUE;
- g_free (fblob);
+ gda_blob_free (fblob);
gda_value_free (vblob);
}
else {
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
