/* * database.c * * Copyright 2024 Michael Rasmussen * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, * MA 02110-1301, USA. * * */ #include "database.h" #include "lensmaker.h" #include "sqlite-storage.h" enum { PROP_PATH = 1, N_PROPERTIES }; static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static void database_finalize (GObject *object); static void database_dispose (GObject *gobject); typedef struct { /* add your private declarations here */ gchar* path; GList* maker; } DatabasePrivate; struct _Database { GObject parent; /* add your public declarations here */ }; G_DEFINE_TYPE_WITH_PRIVATE(Database, database, G_TYPE_OBJECT) static void database_set_property ( GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { DatabasePrivate *priv = database_get_instance_private(DATABASE (object)); switch (prop_id) { case PROP_PATH: //gchar* s = g_strdup(g_value_get_string (value)); if (priv->path) { g_free(priv->path); init_storage(priv->path); } priv->path = g_strdup(g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void database_get_property ( GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { DatabasePrivate *priv = database_get_instance_private(DATABASE (object)); switch (prop_id) { case PROP_PATH: g_value_set_string (value, priv->path); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void database_add_maker(Database* self, const gchar* name, GError** error) { gchar* err; LensMaker* maker = NULL; gint id; DatabasePrivate *priv = database_get_instance_private(self); *error = NULL; GList* iter = priv->maker; while (iter) { bool found = false; LensMaker* o = iter->data; g_object_get(o, "id", &id, NULL); if (id >= 0) { Maker* m = get_maker(id); if (g_strcmp0(name, m->maker_name) == 0) { found = true; } maker_free(m); if (found) return; } iter = g_list_next(iter); } id = get_maker_id(name); if (id < 0) { id = add_maker(name, &err); if (id < 0) { g_set_error(error, 0, 0, g_strdup(err)); return; } } maker = lens_maker_new(id); lens_maker_set_name(maker, name, error); priv->maker = g_list_append(priv->maker, maker); } void database_remove_maker(Database* self, const gchar* name, GError** error) { gchar* err; LensMaker* maker = NULL; gint id; DatabasePrivate *priv = database_get_instance_private(self); bool found = false; *error = NULL; GList* iter = priv->maker; while (iter) { maker = iter->data; g_object_get(maker, "id", &id, NULL); if (id >= 0) { Maker* m = get_maker(id); if (g_strcmp0(name, m->maker_name) == 0) { found = true; } maker_free(m); if (found) break; } iter = g_list_next(iter); } if (found) { gint fail = delete_maker(name, &err); if (fail) { g_set_error(error, 0, 0, g_strdup(err)); return; } g_object_unref(maker); priv->maker = g_list_delete_link(priv->maker, iter); } } static void database_class_init (DatabaseClass *klass) { GObjectClass *g_object_class; klass->add_maker = database_add_maker; klass->remove_maker = database_remove_maker; g_object_class = G_OBJECT_CLASS (klass); g_object_class->set_property = database_set_property; g_object_class->get_property = database_get_property; obj_properties[PROP_PATH] = g_param_spec_string ("path", "Path", "Path to place of the database file.", NULL /* default value */, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); g_object_class_install_properties (g_object_class, N_PROPERTIES, obj_properties); g_object_class->dispose = database_dispose; g_object_class->finalize = database_finalize; } static void database_dispose (GObject *gobject) { //DatabasePrivate *priv = database_get_instance_private(DATABASE(gobject)); /* In dispose(), you are supposed to free all types referenced from this * object which might themselves hold a reference to self. Generally, * the most simple solution is to unref all members on which you own a * reference. */ /* dispose() might be called multiple times, so we must guard against * calling g_object_unref() on an invalid GObject by setting the member * NULL; g_clear_object() does this for us. * g_clear_object (&priv->input_stream); */ /* Always chain up to the parent class; there is no need to check if * the parent class implements the dispose() virtual function: it is * always guaranteed to do so */ G_OBJECT_CLASS(database_parent_class)->dispose (gobject); } static void free_glist_items(gpointer data, gpointer user_data) { if (data) { LensMaker* maker = LENS_MAKER(data); g_object_unref(maker); } } static void database_finalize (GObject *object) { Database *self; g_return_if_fail (IS_DATABASE (object)); self = DATABASE (object); DatabasePrivate *priv = database_get_instance_private(self); g_free(priv->path); g_list_foreach(priv->maker, (GFunc)free_glist_items, NULL); g_list_free(priv->maker); close_storage(); G_OBJECT_CLASS (database_parent_class)->finalize (object); } static void database_init (Database *self) { DatabasePrivate *priv = database_get_instance_private(self); priv->path = NULL; priv->maker = NULL; } Database *database_new (const gchar* path, GError** error) { g_return_val_if_fail (error == NULL || *error == NULL, NULL); g_return_val_if_fail (path != NULL, NULL); Database* database = NULL; if (init_storage(path)) { g_set_error(error, 0, 0, "Failed to open database"); } else { gchar* p = storage_get_path(); database = DATABASE(g_object_new (TYPE_DATABASE, "path", p, NULL)); g_free(p); } return database; } void database_add_lens_maker(Database* self, const gchar* name, GError** error) { DatabaseClass *klass; g_return_if_fail (IS_DATABASE (self)); g_return_if_fail (error == NULL || *error == NULL); g_return_if_fail (name != NULL); klass = DATABASE_GET_CLASS (self); g_return_if_fail (klass->add_maker != NULL); klass->add_maker(self, name, error); } void database_remove_lens_maker(Database* self, const gchar* name, GError** error) { DatabaseClass *klass; g_return_if_fail (IS_DATABASE (self)); g_return_if_fail (error == NULL || *error == NULL); g_return_if_fail (name != NULL); klass = DATABASE_GET_CLASS (self); g_return_if_fail (klass->remove_maker != NULL); klass->remove_maker(self, name, error); } void database_set_path(Database* self, const gchar* path, GError** error) { g_return_if_fail (IS_DATABASE (self)); g_return_if_fail (path != NULL); DatabasePrivate *priv = database_get_instance_private(self); g_free(priv->path); priv->path = g_strdup(path); } void database_print_lens_makers(Database* self) { g_return_if_fail (IS_DATABASE (self)); DatabasePrivate *priv = database_get_instance_private(self); GList* iter = priv->maker; gint id; gchar* name; while (iter) { LensMaker* maker = LENS_MAKER(iter->data); g_object_get(maker, "id", &id, "lensmaker", &name, NULL); fprintf(stdout, "id: %d name: %s\n", id, name); g_free(name); iter = g_list_next(iter); } } LensMaker* database_get_lens_maker(Database* self, const gchar* name, GError** error) { g_return_val_if_fail (IS_DATABASE (self), NULL); g_return_val_if_fail (name != NULL, NULL); DatabasePrivate *priv = database_get_instance_private(self); GList* iter = priv->maker; gchar* needlle; LensMaker* maker = NULL; bool found = false; while (iter) { maker = LENS_MAKER(iter->data); g_object_get(maker, "lensmaker", &needlle, NULL); if (g_strcmp0(name, needlle) == 0) found = true; g_free(needlle); if (found) break; iter = g_list_next(iter); } LensMaker* l = lens_maker_get_copy(maker, error); if (*error) return NULL; else return l; }