]> git.datanom.net - gtk_lensdatabase.git/blob - src/database.c
On the way
[gtk_lensdatabase.git] / src / database.c
1 /*
2 * database.c
3 *
4 * Copyright 2024 Michael Rasmussen <mir@datanom.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301, USA.
20 *
21 *
22 */
23
24 #include "database.h"
25 #include "lensmaker.h"
26 #include "sqlite-storage.h"
27
28 enum {
29 PROP_PATH = 1,
30 N_PROPERTIES
31 };
32
33 static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
34 static void database_finalize (GObject *object);
35 static void database_dispose (GObject *gobject);
36
37 typedef struct {
38 /* add your private declarations here */
39 gchar* path;
40 GList* maker;
41 } DatabasePrivate;
42
43 struct _Database {
44 GObject parent;
45 /* add your public declarations here */
46 };
47
48 G_DEFINE_TYPE_WITH_PRIVATE(Database, database, G_TYPE_OBJECT)
49
50 static void database_set_property ( GObject *object,
51 guint prop_id,
52 const GValue *value,
53 GParamSpec *pspec) {
54 DatabasePrivate *priv = database_get_instance_private(DATABASE (object));
55
56 switch (prop_id) {
57 case PROP_PATH:
58 //gchar* s = g_strdup(g_value_get_string (value));
59 if (priv->path) {
60 g_free(priv->path);
61 init_storage(priv->path);
62 }
63 priv->path = g_strdup(g_value_get_string (value));
64 break;
65
66 default:
67 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
68 break;
69 }
70 }
71
72 static void database_get_property ( GObject *object,
73 guint prop_id,
74 GValue *value,
75 GParamSpec *pspec) {
76 DatabasePrivate *priv = database_get_instance_private(DATABASE (object));
77
78 switch (prop_id) {
79 case PROP_PATH:
80 g_value_set_string (value, priv->path);
81 break;
82
83 default:
84 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
85 break;
86 }
87 }
88
89 static void database_add_maker(Database* self,
90 const gchar* name,
91 GError** error) {
92 gchar* err;
93 LensMaker* maker = NULL;
94 gint id;
95 DatabasePrivate *priv = database_get_instance_private(self);
96
97 *error = NULL;
98 GList* iter = priv->maker;
99 while (iter) {
100 bool found = false;
101 LensMaker* o = iter->data;
102 g_object_get(o, "id", &id, NULL);
103 if (id >= 0) {
104 Maker* m = get_maker(id);
105 if (g_strcmp0(name, m->maker_name) == 0) {
106 found = true;
107 }
108 maker_free(m);
109 if (found) return;
110 }
111 iter = g_list_next(iter);
112 }
113 id = get_maker_id(name);
114 if (id < 0) {
115 id = add_maker(name, &err);
116 if (id < 0) {
117 g_set_error(error, 0, 0, g_strdup(err));
118 return;
119 }
120 }
121 maker = lens_maker_new(id);
122 lens_maker_set_name(maker, name, error);
123 priv->maker = g_list_append(priv->maker, maker);
124 }
125
126 void database_remove_maker(Database* self, const gchar* name, GError** error) {
127 gchar* err;
128 LensMaker* maker = NULL;
129 gint id;
130 DatabasePrivate *priv = database_get_instance_private(self);
131 bool found = false;
132
133 *error = NULL;
134 GList* iter = priv->maker;
135 while (iter) {
136 maker = iter->data;
137 g_object_get(maker, "id", &id, NULL);
138 if (id >= 0) {
139 Maker* m = get_maker(id);
140 if (g_strcmp0(name, m->maker_name) == 0) {
141 found = true;
142 }
143 maker_free(m);
144 if (found) break;
145 }
146 iter = g_list_next(iter);
147 }
148 if (found) {
149 gint fail = delete_maker(name, &err);
150 if (fail) {
151 g_set_error(error, 0, 0, g_strdup(err));
152 return;
153 }
154 g_object_unref(maker);
155 priv->maker = g_list_delete_link(priv->maker, iter);
156 }
157 }
158
159 static void database_class_init (DatabaseClass *klass) {
160 GObjectClass *g_object_class;
161
162 klass->add_maker = database_add_maker;
163 klass->remove_maker = database_remove_maker;
164
165 g_object_class = G_OBJECT_CLASS (klass);
166
167 g_object_class->set_property = database_set_property;
168 g_object_class->get_property = database_get_property;
169
170 obj_properties[PROP_PATH] =
171 g_param_spec_string ("path",
172 "Path",
173 "Path to place of the database file.",
174 NULL /* default value */,
175 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
176
177 g_object_class_install_properties (g_object_class,
178 N_PROPERTIES,
179 obj_properties);
180
181 g_object_class->dispose = database_dispose;
182 g_object_class->finalize = database_finalize;
183 }
184
185 static void database_dispose (GObject *gobject) {
186 //DatabasePrivate *priv = database_get_instance_private(DATABASE(gobject));
187
188 /* In dispose(), you are supposed to free all types referenced from this
189 * object which might themselves hold a reference to self. Generally,
190 * the most simple solution is to unref all members on which you own a
191 * reference.
192 */
193
194 /* dispose() might be called multiple times, so we must guard against
195 * calling g_object_unref() on an invalid GObject by setting the member
196 * NULL; g_clear_object() does this for us.
197 * g_clear_object (&priv->input_stream);
198 */
199
200 /* Always chain up to the parent class; there is no need to check if
201 * the parent class implements the dispose() virtual function: it is
202 * always guaranteed to do so
203 */
204 G_OBJECT_CLASS(database_parent_class)->dispose (gobject);
205 }
206
207 static void free_glist_items(gpointer data, gpointer user_data) {
208 if (data) {
209 LensMaker* maker = LENS_MAKER(data);
210 g_object_unref(maker);
211 }
212 }
213
214 static void database_finalize (GObject *object) {
215 Database *self;
216
217 g_return_if_fail (IS_DATABASE (object));
218
219 self = DATABASE (object);
220
221 DatabasePrivate *priv = database_get_instance_private(self);
222 g_free(priv->path);
223 g_list_foreach(priv->maker, (GFunc)free_glist_items, NULL);
224 g_list_free(priv->maker);
225 close_storage();
226
227 G_OBJECT_CLASS (database_parent_class)->finalize (object);
228 }
229
230
231 static void database_init (Database *self) {
232 DatabasePrivate *priv = database_get_instance_private(self);
233 priv->path = NULL;
234 priv->maker = NULL;
235 }
236
237
238 Database *database_new (const gchar* path, GError** error) {
239 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
240 g_return_val_if_fail (path != NULL, NULL);
241
242 Database* database = NULL;
243
244 if (init_storage(path)) {
245 g_set_error(error, 0, 0, "Failed to open database");
246 } else {
247 gchar* p = storage_get_path();
248 database = DATABASE(g_object_new (TYPE_DATABASE, "path", p, NULL));
249 g_free(p);
250 }
251
252 return database;
253 }
254
255 void database_add_lens_maker(Database* self,
256 const gchar* name,
257 GError** error) {
258 DatabaseClass *klass;
259
260 g_return_if_fail (IS_DATABASE (self));
261 g_return_if_fail (error == NULL || *error == NULL);
262 g_return_if_fail (name != NULL);
263
264 klass = DATABASE_GET_CLASS (self);
265 g_return_if_fail (klass->add_maker != NULL);
266
267 klass->add_maker(self, name, error);
268 }
269
270 void database_remove_lens_maker(Database* self,
271 const gchar* name,
272 GError** error) {
273 DatabaseClass *klass;
274
275 g_return_if_fail (IS_DATABASE (self));
276 g_return_if_fail (error == NULL || *error == NULL);
277 g_return_if_fail (name != NULL);
278
279 klass = DATABASE_GET_CLASS (self);
280 g_return_if_fail (klass->remove_maker != NULL);
281
282 klass->remove_maker(self, name, error);
283 }
284
285 void database_set_path(Database* self, const gchar* path, GError** error) {
286 g_return_if_fail (IS_DATABASE (self));
287 g_return_if_fail (path != NULL);
288
289 DatabasePrivate *priv = database_get_instance_private(self);
290 g_free(priv->path);
291 priv->path = g_strdup(path);
292 }
293
294 void database_print_lens_makers(Database* self) {
295 g_return_if_fail (IS_DATABASE (self));
296
297 DatabasePrivate *priv = database_get_instance_private(self);
298 GList* iter = priv->maker;
299 gint id;
300 gchar* name;
301
302 while (iter) {
303 LensMaker* maker = LENS_MAKER(iter->data);
304 g_object_get(maker, "id", &id, "lensmaker", &name, NULL);
305 fprintf(stdout, "id: %d name: %s\n", id, name);
306 g_free(name);
307 iter = g_list_next(iter);
308 }
309 }
310
311 LensMaker* database_get_lens_maker(Database* self, const gchar* name, GError** error) {
312 g_return_val_if_fail (IS_DATABASE (self), NULL);
313 g_return_val_if_fail (name != NULL, NULL);
314
315 DatabasePrivate *priv = database_get_instance_private(self);
316 GList* iter = priv->maker;
317 gchar* needlle;
318 LensMaker* maker = NULL;
319 bool found = false;
320
321 while (iter) {
322 maker = LENS_MAKER(iter->data);
323 g_object_get(maker, "lensmaker", &needlle, NULL);
324
325 if (g_strcmp0(name, needlle) == 0)
326 found = true;
327
328 g_free(needlle);
329 if (found)
330 break;
331
332 iter = g_list_next(iter);
333 }
334 LensMaker* l = lens_maker_get_copy(maker, error);
335 if (*error)
336 return NULL;
337 else
338 return l;
339 }
This page took 0.697549 seconds and 6 git commands to generate.