QOF  0.8.7
qoferror.c
1 /*****************************************************************
2  * qoferror.c
3  *
4  * Sun Sep 10 19:55:08 2006
5  * Copyright 2006-2008 Neil Williams
6  * linux@codehelp.co.uk
7  ****************************************************************/
8 /*
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22  */
23 
24 #include "config.h"
25 #include "qof.h"
26 #include "qoferror-p.h"
27 #include "qofsession-p.h"
28 
29 struct QofError_s
30 {
31  QofErrorId id;
32  gchar * message;
33  const gchar * filename;
34  gboolean use_file;
35  QofTime * qt;
36 };
37 
38 /* All registered errors - hashed only once per session. */
39 static GHashTable * error_table = NULL;
40 static gint32 count = 0;
41 static QofLogModule log_module = QOF_MOD_ERROR;
42 
43 void
44 qof_error_init (void)
45 {
46  error_table = g_hash_table_new (g_direct_hash, g_direct_equal);
47 }
48 
49 static void
50 qof_error_free (QofError * error)
51 {
52  if (error->qt)
53  qof_time_free (error->qt);
54  g_free (error->message);
55  g_free (error);
56 }
57 
58 /* clear the table of registered error values */
59 static void
60 clear_table (gpointer key, gpointer value, gpointer user_data)
61 {
62  qof_error_free ((QofError*)value);
63 }
64 
65 void
66 qof_error_close (void)
67 {
68  g_hash_table_foreach (error_table, clear_table, NULL);
69  g_hash_table_destroy (error_table);
70 }
71 
73 qof_error_register (const gchar * err_message, gboolean use_file)
74 {
75  QofError * qerr;
76 
77  ENTER (" ");
78  qerr = g_new0 (QofError, 1);
79  count++;
80  qerr->id = count;
81  if (use_file)
82  {
83  gchar * spec;
84 
85  spec = g_strrstr (err_message, "%s");
86  use_file = (spec) ? TRUE : FALSE;
87  }
88  qerr->use_file = use_file;
89  qerr->message = g_strdup (err_message);
90  g_hash_table_insert (error_table, GINT_TO_POINTER(qerr->id), qerr);
91  LEAVE (" ");
92  return qerr->id;
93 }
94 
95 void
97 {
98  QofError * qerr;
99  gboolean result;
100 
101  ENTER (" ");
102  qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(id));
103  qof_error_free (qerr);
104  result = g_hash_table_remove (error_table,
105  GINT_TO_POINTER(id));
106  if (!result)
107  LEAVE ("unable to remove registered error.");
108  LEAVE (" ok.");
109 }
110 
111 void
113 {
114  QofError * qerr, * set;
115 
116  g_return_if_fail (session);
117  if (error == QOF_SUCCESS)
118  {
119  DEBUG (" passed success, not error.");
120  return;
121  }
122  qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(error));
123  if (!qerr)
124  {
125  DEBUG (" failed hash table lookup");
126  return;
127  }
128  session->last_err = error;
129  if (session->error_message)
130  g_free (session->error_message);
131  if (qerr->use_file)
132  session->error_message = g_strdup_printf (qerr->message,
133  qof_session_get_url (session));
134  else
135  session->error_message = g_strdup (qerr->message);
136  if (!session->backend)
137  return;
138  /* create a new error for the list */
139  set = g_new0 (QofError, 1);
140  if (qerr->use_file)
141  set->message = g_strdup_printf (qerr->message,
142  qof_session_get_file_path (session));
143  else
144  set->message = g_strdup (qerr->message);
145  set->id = error;
146  set->qt = qof_time_get_current ();
147  session->backend->error_stack =
148  g_list_prepend (session->backend->error_stack, set);
149 }
150 
151 void
152 qof_error_set_be (QofBackend * be, QofErrorId error)
153 {
154  QofError * qerr, * set;
155 
156  g_return_if_fail (be);
157  if (error == QOF_SUCCESS)
158  return;
159  qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(error));
160  if (!qerr)
161  return;
162  /* create a new error for the list */
163  set = g_new0 (QofError, 1);
164  if (qerr->use_file)
165  set->message = g_strdup_printf (qerr->message, be->fullpath);
166  else
167  set->message = g_strdup (qerr->message);
168  set->id = error;
169  set->qt = qof_time_get_current ();
170  be->error_stack = g_list_prepend (be->error_stack,
171  set);
172 }
173 
174 /* clear the list of actual errors */
175 static void
176 clear_list (gpointer value, gpointer user_data)
177 {
178  qof_error_free ((QofError*)value);
179 }
180 
181 void
183 {
184  g_return_if_fail (session);
185  if (!session->backend)
186  return;
187  g_list_foreach (session->backend->error_stack, clear_list, NULL);
188  g_list_free (session->backend->error_stack);
189  session->backend->error_stack = NULL;
190  if (session->error_message)
191  g_free (session->error_message);
192  session->error_message = NULL;
193  session->last_err = QOF_SUCCESS;
194 }
195 
198 {
199  g_return_val_if_fail (session, QOF_FATAL);
200  return qof_error_check_be (session->backend);
201 }
202 
205 {
206  QofError * qerr;
207  GList * first;
208 
209  if (!be)
210  return QOF_FATAL;
211  if (g_list_length (be->error_stack) == 0)
212  return QOF_SUCCESS;
213  first = g_list_first (be->error_stack);
214  qerr = (QofError*)first->data;
215  if (!qerr)
216  return QOF_FATAL;
217  return qerr->id;
218 }
219 
220 QofTime *
222 {
223  QofError * qerr;
224  GList * first;
225 
226  if (g_list_length(be->error_stack) == 0)
227  return NULL;
228  first = g_list_first (be->error_stack);
229  qerr = (QofError*)first->data;
230  return qerr->qt;
231 }
232 
233 QofTime *
235 {
236  return qof_error_get_time_be (session->backend);
237 }
238 
241 {
242  QofErrorId id;
243 
244  g_return_val_if_fail (session, QOF_FATAL);
245  id = QOF_SUCCESS;
246  id = qof_error_get_id_be (session->backend);
247  {
248  QofError * qerr;
249 
250  qerr = g_hash_table_lookup (error_table,
251  GINT_TO_POINTER(id));
252  if (!qerr)
253  {
254  DEBUG (" empty QofError value");
255  return QOF_FATAL;
256  }
257  if (session->error_message)
258  g_free (session->error_message);
259  session->error_message = qerr->message;
260  session->last_err = id;
261  }
262  return id;
263 }
264 
267 {
268  QofError * qerr;
269  GList * first;
270 
271  if (!be)
272  return QOF_FATAL;
273  if (g_list_length (be->error_stack) == 0)
274  return QOF_SUCCESS;
275  first = g_list_first (be->error_stack);
276  qerr = (QofError*)first->data;
277  if (!qerr)
278  return QOF_FATAL;
279  be->error_stack =
280  g_list_remove (be->error_stack, qerr);
281  return qerr->id;
282 }
283 
284 const gchar *
286 {
287  const gchar * msg;
288 
289  g_return_val_if_fail (session, NULL);
290  if (!session->backend)
291  return session->error_message;
292  msg = qof_error_get_message_be (session->backend);
293  DEBUG (" msg_1=%s", msg);
294  return msg;
295 }
296 
297 const gchar *
299 {
300  QofError * qerr;
301  GList * first;
302 
303  g_return_val_if_fail (be, NULL);
304  if (g_list_length (be->error_stack) == 0)
305  {
306  DEBUG (" empty error stack");
307  return NULL;
308  }
309  first = g_list_first (be->error_stack);
310  qerr = (QofError*)first->data;
311  if (!qerr)
312  {
313  DEBUG (" empty QofError value");
314  return NULL;
315  }
316  DEBUG (" qerr->message=%s", qerr->message);
317  be->error_stack =
318  g_list_remove (be->error_stack, qerr);
319  return qerr->message;
320 }
QofErrorId qof_error_register(const gchar *err_message, gboolean use_file)
Generate and register a new error.
Definition: qoferror.c:73
gchar * fullpath
Definition: qofbackend-p.h:332
QofTime * qof_error_get_time(QofSession *session)
Alternative for applications.
Definition: qoferror.c:234
QofErrorId qof_error_check(QofSession *session)
Definition: qoferror.c:197
gint32 QofErrorId
The ID of this error.
Definition: qofbackend.h:54
QofErrorId qof_error_check_be(QofBackend *be)
Check for errors.
Definition: qoferror.c:204
#define LEAVE(format, args...)
Definition: qoflog.h:227
QofTime * qof_time_get_current(void)
Get the current QofTime.
Definition: qoftime.c:362
QofTime * qof_error_get_time_be(QofBackend *be)
Get the time of the most recent error.
Definition: qoferror.c:221
const gchar * qof_error_get_message(QofSession *session)
Alternative for applications.
Definition: qoferror.c:285
void qof_error_set(QofSession *session, QofErrorId error)
Add an error to the stack for this session.
Definition: qoferror.c:112
struct QofError_s QofError
Definition: qoferror.h:118
void qof_time_free(QofTime *qt)
Free a QofTime when no longer required.
Definition: qoftime.c:56
#define QOF_SUCCESS
Definition: qoferror.h:124
#define DEBUG(format, args...)
Definition: qoflog.h:208
const gchar * qof_session_get_file_path(QofSession *session)
Definition: qofsession.c:189
QofErrorId qof_error_get_id(QofSession *session)
Alternative for applications.
Definition: qoferror.c:240
#define QOF_MOD_ERROR
Definition: qoferror.h:121
struct QofTime64 QofTime
Use a 64-bit signed int QofTime.
Definition: qoftime.h:112
void qof_error_clear(QofSession *session)
clear the error stack for the session.
Definition: qoferror.c:182
void qof_error_unregister(QofErrorId id)
Unregister an error.
Definition: qoferror.c:96
#define QOF_FATAL
general error value
Definition: qoferror.h:131
QofErrorId last_err
Definition: qofsession-p.h:53
const gchar * qof_error_get_message_be(QofBackend *be)
Pop the most recent error and get the message.
Definition: qoferror.c:298
#define ENTER(format, args...)
Definition: qoflog.h:217
const gchar * QofLogModule
Definition: qofid.h:85
QofErrorId qof_error_get_id_be(QofBackend *be)
Pop the most recent error from the backend stack.
Definition: qoferror.c:266
gchar * error_message
Definition: qofsession-p.h:56