static GValue * gdaui_entry_wrapper_get_value (GdauiDataEntry *iface) { GValue *value = NULL; GdauiEntryWrapper *wrapper; g_return_val_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface), NULL); wrapper = (GdauiEntryWrapper*) iface; if (wrapper->priv->null_forced) value = gda_value_new_null (); else { if (wrapper->priv->default_forced) { if (G_VALUE_TYPE (wrapper->priv->value_default) == wrapper->priv->type) value = gda_value_copy (wrapper->priv->value_default); else value = gda_value_new_null (); } else { check_correct_init (wrapper); value = (wrapper->priv->real_class->real_get_value) (wrapper); } } return value; }
/* Interface implementation */ static void gdaui_entry_wrapper_set_value_type (GdauiDataEntry *iface, GType type) { GdauiEntryWrapper *wrapper; g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface)); wrapper = (GdauiEntryWrapper*) iface; if (wrapper->priv->type != type) { GValue *value; if (wrapper->priv->value_ref) { gda_value_free (wrapper->priv->value_ref); wrapper->priv->value_ref = NULL; } if (wrapper->priv->value_default) { gda_value_free (wrapper->priv->value_default); wrapper->priv->value_default = NULL; } wrapper->priv->type = type; wrapper->priv->value_default = gda_value_new_null (); /* Set original value */ value = gda_value_new_null (); gdaui_entry_wrapper_set_ref_value (GDAUI_DATA_ENTRY (wrapper), value); gda_value_free (value); } }
/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_size (FileRow *row, const gchar *complete_filename) { struct stat filestat; gboolean changed = TRUE; if (! g_stat (complete_filename, &filestat)) { if (row->size_value && (G_VALUE_TYPE (row->size_value) == G_TYPE_UINT) && (g_value_get_uint (row->size_value) == (guint)filestat.st_size)) changed = FALSE; else { if (row->size_value) gda_value_free (row->size_value); g_value_set_uint (row->size_value = gda_value_new (G_TYPE_UINT), filestat.st_size); } } else { if (row->size_value && gda_value_is_null (row->size_value)) changed = FALSE; else { if (row->size_value) gda_value_free (row->size_value); row->size_value = gda_value_new_null (); } } return changed; }
static void gdaui_entry_wrapper_set_value_default (GdauiDataEntry *iface, const GValue *value) { GdauiEntryWrapper *wrapper; g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface)); wrapper = (GdauiEntryWrapper*) iface; if (wrapper->priv->value_default) gda_value_free (wrapper->priv->value_default); if (value) wrapper->priv->value_default = gda_value_copy ((GValue *) value); else wrapper->priv->value_default = gda_value_new_null (); if (wrapper->priv->default_forced) { if (G_VALUE_TYPE (wrapper->priv->value_default) == wrapper->priv->type) { check_correct_init (wrapper); block_signals (wrapper); gdaui_entry_wrapper_set_value (iface, wrapper->priv->value_default); unblock_signals (wrapper); wrapper->priv->default_forced = TRUE; } else { check_correct_init (wrapper); (*wrapper->priv->real_class->real_set_value) (wrapper, NULL); } gdaui_entry_wrapper_emit_signal (wrapper); } }
/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_mime (FileRow *row, const gchar *complete_filename) { gboolean changed = TRUE; GValue *value = NULL; #ifdef HAVE_GIO GFile *file; GFileInfo *info; file = g_file_new_for_path (complete_filename); info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (info) { value = gda_value_new (G_TYPE_STRING); g_value_set_string (value, g_file_info_get_content_type (info)); g_object_unref (info); } else value = gda_value_new_null (); g_object_unref (file); #else value = gda_value_new_null (); #endif if (value) { if (row->mime_value && (G_VALUE_TYPE (row->mime_value) == G_TYPE_STRING) && !gda_value_compare (row->mime_value, value)) changed = FALSE; else { if (row->mime_value) gda_value_free (row->mime_value); row->mime_value = value; } } else { if (row->mime_value && gda_value_is_null (row->mime_value)) changed = FALSE; else { if (row->mime_value) gda_value_free (row->mime_value); row->mime_value = gda_value_new_null (); } } return changed; }
/** * gda_data_handler_get_value_from_sql: * @dh: an object which implements the #GdaDataHandler interface * @sql: (allow-none) (transfer none): an SQL string, or %NULL * @type: a GType * * Creates a new GValue which represents the SQL value given as argument. This is * the opposite of the function gda_data_handler_get_sql_from_value(). The type argument * is used to determine the real data type requested for the returned value. * * If the @sql string is %NULL, then the returned GValue is of type GDA_TYPE_NULL; * if the @sql string does not correspond to a valid SQL string for the requested type, then * the %NULL is returned. * * Returns: (transfer full): the new #GValue or %NULL on error */ GValue * gda_data_handler_get_value_from_sql (GdaDataHandler *dh, const gchar *sql, GType type) { g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL); g_return_val_if_fail (_accepts_g_type (dh, type), NULL); if (!sql) return gda_value_new_null (); if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) (dh, sql, type); return NULL; }
static void gdaui_entry_wrapper_set_ref_value (GdauiDataEntry *iface, const GValue *value) { GdauiEntryWrapper *wrapper; gboolean changed = TRUE; GValue *evalue; g_return_if_fail (GDAUI_IS_ENTRY_WRAPPER (iface)); wrapper = (GdauiEntryWrapper*) iface; check_correct_init (wrapper); /* compare existing value and the one provided as argument */ if (wrapper->priv->real_class->value_is_equal_to) changed = ! wrapper->priv->real_class->value_is_equal_to (wrapper, value); else { evalue = gdaui_entry_wrapper_get_value (iface); g_assert (evalue); if ((!value || (G_VALUE_TYPE (value) == GDA_TYPE_NULL)) && (G_VALUE_TYPE (evalue) == GDA_TYPE_NULL)) changed = FALSE; else if (!gda_value_differ ((GValue *) value, evalue)) changed = FALSE; gda_value_free (evalue); } /* get rid on any existing orig value */ if (wrapper->priv->value_ref) { gda_value_free (wrapper->priv->value_ref); wrapper->priv->value_ref = NULL; } /* apply changes, if any */ if (changed) { block_signals (wrapper); gdaui_entry_wrapper_set_value (iface, value); unblock_signals (wrapper); } if (value) { g_return_if_fail ((G_VALUE_TYPE ((GValue *) value) == wrapper->priv->type) || (G_VALUE_TYPE ((GValue *) value) == GDA_TYPE_NULL)); wrapper->priv->value_ref = gda_value_copy ((GValue *) value); } else wrapper->priv->value_ref = gda_value_new_null (); /* signal changes if any */ if (changed) gdaui_entry_wrapper_emit_signal (wrapper); }
/** * gda_data_handler_get_value_from_str: * @dh: an object which implements the #GdaDataHandler interface * @str: (allow-none) (transfer none): a string or %NULL * @type: a GType * * Creates a new GValue which represents the @str value given as argument. This is * the opposite of the function gda_data_handler_get_str_from_value(). The type argument * is used to determine the real data type requested for the returned value. * * If the @str string is %NULL, then the returned GValue is of type GDA_TYPE_NULL; * if the @str string does not correspond to a valid string for the requested type, then * %NULL is returned. * * Note: the @str string must be in the current locale representation * * Returns: (transfer full): the new #GValue or %NULL on error */ GValue * gda_data_handler_get_value_from_str (GdaDataHandler *dh, const gchar *str, GType type) { g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL); g_return_val_if_fail (_accepts_g_type (dh, type), NULL); if (!str) return gda_value_new_null (); if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_str) return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_str) (dh, str, type); else { /* if the get_value_from_str() method is not implemented, then we try the get_value_from_sql() method */ if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_value_from_sql) (dh, str, type); } return NULL; }
static GValue * real_get_value (GdauiEntryWrapper *mgwrap) { GValue *value; GdauiEntryString *mgstr; GdaDataHandler *dh; g_return_val_if_fail (GDAUI_IS_ENTRY_STRING (mgwrap), NULL); mgstr = GDAUI_ENTRY_STRING (mgwrap); GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr); dh = gdaui_data_entry_get_handler (GDAUI_DATA_ENTRY (mgwrap)); if (! priv->multiline) { gchar *cstr; cstr = gdaui_entry_get_text (GDAUI_ENTRY (priv->entry)); value = gda_data_handler_get_value_from_str (dh, cstr, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap))); g_free (cstr); } else { GtkTextIter start, end; gchar *str; gtk_text_buffer_get_start_iter (priv->buffer, &start); gtk_text_buffer_get_end_iter (priv->buffer, &end); str = gtk_text_buffer_get_text (priv->buffer, &start, &end, FALSE); value = gda_data_handler_get_value_from_str (dh, str, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap))); g_free (str); } if (!value) { /* in case the gda_data_handler_get_value_from_str() returned an error because the contents of the GtkEntry cannot be interpreted as a GValue */ value = gda_value_new_null (); } return value; }
static gboolean do_test (ATest *test) { GdaSqlParser *parser; GdaStatement *stmt; GError *error = NULL; gchar *tmp; g_print ("** test %s\n", test->id); parser = gda_sql_parser_new (); GdaSet *params; GValue *nv; GdaHolder *holder; stmt = gda_sql_parser_parse_string (parser, test->sql, NULL, &error); g_object_unref (parser); if (!stmt) { g_print ("Parsing error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } if (! gda_statement_get_parameters (stmt, ¶ms, &error)) { g_print ("Error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } g_assert (gda_set_set_holder_value (params, NULL, "name", "zzz")); nv = gda_value_new_null (); holder = gda_set_get_holder (params, "id"); g_assert (gda_holder_set_value (holder, nv, NULL)); gda_value_free (nv); GdaSqlStatement *sqlst; g_object_get (stmt, "structure", &sqlst, NULL); sqlst = gda_rewrite_sql_statement_for_null_parameters (sqlst, params, NULL, &error); if (!sqlst) { g_print ("Rewrite error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } g_object_set (stmt, "structure", sqlst, NULL); /* SQL rendering */ tmp = gda_statement_to_sql_extended (stmt, NULL, NULL, GDA_STATEMENT_SQL_PARAMS_SHORT, NULL, &error); if (!tmp) { g_print ("Rendering error: %s\n", error && error->message ? error->message : "No detail"); return FALSE; } /*g_print ("SQL after mod: [%s]\n", tmp);*/ g_free (tmp); tmp = gda_sql_statement_serialize (sqlst); if (!tmp) { g_print ("Error: gda_sql_statement_serialize() failed\n"); return FALSE; } else if (strcmp (test->result, tmp)) { g_print ("Exp: [%s]\nGot: [%s]\n", test->result, tmp); return FALSE; } g_free (tmp); gda_sql_statement_free (sqlst); g_object_unref (stmt); return TRUE; }
/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_md5sum (FileRow *row, const gchar *complete_filename) { gboolean changed = TRUE; GValue *value = NULL; /* MD5 computation */ MD5_CTX context; unsigned char digest[16]; /* Flawfinder: ignore */ GString *md5str; gint i; int fd; gpointer map; guint length; HANDLE view; /* file mapping in mem */ length = g_value_get_uint (row->size_value); if (length == 0) goto md5end; fd = open (complete_filename, O_RDONLY); /* Flawfinder: ignore */ if (fd < 0) goto md5end; #ifndef G_OS_WIN32 map = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, 0); if (map == MAP_FAILED) { close (fd); goto md5end; } #else view = CreateFileMapping ((HANDLE) fd, NULL, PAGE_READONLY|SEC_COMMIT, 0,0 , NULL); if (!view) { close (fd); goto md5end; } map = MapViewOfFile (view, FILE_MAP_READ, 0, 0, length); if (!map) { close (fd); goto md5end; } #endif /* !G_OS_WIN32 */ MD5Init (&context); MD5Update (&context, map, length); MD5Final (digest, &context); md5str = g_string_new (""); for (i = 0; i < 16; i++) g_string_append_printf (md5str, "%02x", digest[i]); value = gda_value_new (G_TYPE_STRING); g_value_take_string (value, md5str->str); g_string_free (md5str, FALSE); #ifndef G_OS_WIN32 munmap (map, length); #else UnmapViewOfFile (map); #endif /* !G_OS_WIN32 */ close (fd); md5end: if (value) { if (row->md5sum_value && (G_VALUE_TYPE (row->md5sum_value) == G_TYPE_STRING) && !gda_value_compare (row->md5sum_value, value)) changed = FALSE; else { if (row->md5sum_value) gda_value_free (row->md5sum_value); row->md5sum_value = value; } } else { if (row->md5sum_value && gda_value_is_null (row->md5sum_value)) changed = FALSE; else { if (row->md5sum_value) gda_value_free (row->md5sum_value); row->md5sum_value = gda_value_new_null (); } } return changed; }