]> git.datanom.net - gtk_lensdatabase.git/blobdiff - src/database.c
On the way
[gtk_lensdatabase.git] / src / database.c
index df476433d91eea3edc8f6a23c72eb5f47d478570..ce244b47142a262f48dfd14a99b72af2efc69974 100644 (file)
  */
 
 #include "database.h"
+#include "lensmaker.h"
+#include "sqlite-storage.h"
 
-struct _DatabasePrivate
-{
-  /* add your private declarations here */
-  gpointer delete_me;
+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);
 
-G_DEFINE_TYPE (Database, database, G_TYPE_OBJECT)
+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.
+       */
 
-static void
-database_class_init (DatabaseClass *klass)
-{
-  GObjectClass *g_object_class;
+       /* 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;
+}
 
-  g_object_class = G_OBJECT_CLASS (klass);
 
-  g_object_class->finalize = database_finalize;
+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);
 
-  g_type_class_add_private ((gpointer)klass, sizeof (DatabasePrivate));
+       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);
+}
 
-static void
-database_finalize (GObject *object)
-{
-  Database *self;
+void database_remove_lens_maker(Database*              self,
+                                                               const gchar*    name,
+                                                               GError**                error) {
+       DatabaseClass *klass;
 
-  g_return_if_fail (IS_DATABASE (object));
+       g_return_if_fail (IS_DATABASE (self));
+       g_return_if_fail (error == NULL || *error == NULL);
+       g_return_if_fail (name != NULL);
 
-  self = DATABASE (object);
+       klass = DATABASE_GET_CLASS (self);
+       g_return_if_fail (klass->remove_maker != NULL);
 
-  G_OBJECT_CLASS (database_parent_class)->finalize (object);
+       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);
 
-static void
-database_init (Database *self)
-{
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TYPE_DATABASE, DatabasePrivate);
+       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;
 
-GObject *
-database_new (void)
-{
-  return g_object_new (TYPE_DATABASE, NULL);
+               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;
 }
This page took 0.528085 seconds and 5 git commands to generate.