qoferror.c

00001 /*****************************************************************
00002  *            qoferror.c
00003  *
00004  *  Sun Sep 10 19:55:08 2006
00005  *  Copyright  2006  Neil Williams
00006  *  linux@codehelp.co.uk
00007  ****************************************************************/
00008 /*
00009  *  This program is free software; you can redistribute it and/or modify
00010  *  it under the terms of the GNU General Public License as published by
00011  *  the Free Software Foundation; either version 2 of the License, or
00012  *  (at your option) any later version.
00013  *
00014  *  This program is distributed in the hope that it will be useful,
00015  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  *  GNU General Public License for more details.
00018  *
00019  *  You should have received a copy of the GNU General Public License
00020  *  along with this program; if not, write to the Free Software
00021  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00022  */
00023 
00024 #include "config.h"
00025 #include "qof.h"
00026 #include "qoferror-p.h"
00027 #include "qofsession-p.h"
00028 
00029 struct QofError_s
00030 {
00031     QofErrorId id;
00032     gchar * message;
00033     const gchar * filename;
00034     gboolean use_file;
00035     QofTime * qt;
00036 };
00037 
00038 /* All registered errors - hashed only once per session. */
00039 static GHashTable * error_table = NULL;
00040 static gint32 count = 0;
00041 static QofLogModule log_module = QOF_MOD_ERROR;
00042 
00043 void
00044 qof_error_init (void)
00045 {
00046     error_table = g_hash_table_new (g_direct_hash, g_direct_equal);
00047 #ifndef QOF_DISABLE_DEPRECATED
00048     set_deprecated_errors ();
00049 #endif
00050 }
00051 
00052 static void
00053 qof_error_free (QofError * error)
00054 {
00055     if (error->qt)
00056         qof_time_free (error->qt);
00057     g_free (error->message);
00058     g_free (error);
00059 }
00060 
00061 /* clear the table of registered error values */
00062 static void
00063 clear_table (gpointer key, gpointer value, gpointer user_data)
00064 {
00065     qof_error_free ((QofError*)value);
00066 }
00067 
00068 void
00069 qof_error_close (void)
00070 {
00071     g_hash_table_foreach (error_table, clear_table, NULL);
00072     g_hash_table_destroy (error_table);
00073 }
00074 
00075 #ifndef QOF_DISABLE_DEPRECATED
00076 void
00077 deprecated_support (QofErrorId id, const gchar * err_message)
00078 {
00079     QofError * qerr;
00080 
00081     if (id >= ERR_LAST)
00082         return;
00083     qerr = g_new0 (QofError, 1);
00084     qerr->id = id;
00085     qerr->message = g_strdup (err_message);
00086     g_hash_table_insert (error_table, GINT_TO_POINTER(id), qerr);
00087 }
00088 #endif
00089 
00090 QofErrorId
00091 qof_error_register (const gchar * err_message, gboolean use_file)
00092 {
00093     QofError * qerr;
00094 
00095     ENTER (" ");
00096     qerr = g_new0 (QofError, 1);
00097     count++;
00098 #ifndef QOF_DISABLE_DEPRECATED
00099     count += ERR_LAST;
00100 #endif
00101     qerr->id = count;
00102     if (use_file)
00103     {
00104         gchar * spec;
00105 
00106         spec = g_strrstr (err_message, "%s");
00107         use_file = (spec) ? TRUE : FALSE;
00108     }
00109     qerr->use_file = use_file;
00110     qerr->message = g_strdup (err_message);
00111     g_hash_table_insert (error_table, GINT_TO_POINTER(qerr->id), qerr);
00112     LEAVE (" ");
00113     return qerr->id;
00114 }
00115 
00116 void
00117 qof_error_unregister (QofErrorId id)
00118 {
00119     QofError * qerr;
00120     gboolean result;
00121 
00122     ENTER (" ");
00123     qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(id));
00124     qof_error_free (qerr);
00125     result = g_hash_table_remove (error_table, 
00126         GINT_TO_POINTER(id));
00127     if (!result)
00128         LEAVE ("unable to remove registered error.");
00129     LEAVE (" ok.");
00130 }
00131 
00132 void
00133 qof_error_set (QofSession * session, QofErrorId error)
00134 {
00135     QofError * qerr, * set;
00136 
00137     g_return_if_fail (session);
00138     if (error == QOF_SUCCESS)
00139     {
00140         DEBUG (" passed success, not error.");
00141         return;
00142     }
00143     qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(error));
00144     if (!qerr)
00145     {
00146         DEBUG (" failed hash table lookup");
00147         return;
00148     }
00149     session->last_err = error;
00150     if (session->error_message)
00151         g_free (session->error_message);
00152     if (qerr->use_file)
00153         session->error_message = g_strdup_printf (qerr->message,
00154             qof_session_get_url (session));
00155     else
00156         session->error_message = g_strdup (qerr->message);
00157     if (!session->backend)
00158         return;
00159     /* create a new error for the list */
00160     set = g_new0 (QofError, 1);
00161     if (qerr->use_file)
00162         set->message = g_strdup_printf (qerr->message,
00163             qof_session_get_file_path (session));
00164     else
00165         set->message = g_strdup (qerr->message);
00166     set->id = error;
00167     set->qt = qof_time_get_current ();
00168     session->backend->error_stack = 
00169         g_list_prepend (session->backend->error_stack, set);
00170 #ifndef QOF_DISABLE_DEPRECATED
00171     session->backend->last_err = error;
00172 #endif
00173 }
00174 
00175 void
00176 qof_error_set_be (QofBackend * be, QofErrorId error)
00177 {
00178     QofError * qerr, * set;
00179 
00180     g_return_if_fail (be);
00181     if (error == QOF_SUCCESS)
00182         return;
00183     qerr = g_hash_table_lookup (error_table, GINT_TO_POINTER(error));
00184     if (!qerr)
00185         return;
00186     /* create a new error for the list */
00187     set = g_new0 (QofError, 1);
00188     set->message = g_strdup (qerr->message);
00189     set->id = error;
00190     set->qt = qof_time_get_current ();
00191     be->error_stack = g_list_prepend (be->error_stack,
00192         set);
00193 #ifndef QOF_DISABLE_DEPRECATED
00194     be->last_err = error;
00195 #endif
00196 }
00197 
00198 /* clear the list of actual errors */
00199 static void
00200 clear_list (gpointer value, gpointer user_data)
00201 {
00202     qof_error_free ((QofError*)value);
00203 }
00204 
00205 void
00206 qof_error_clear (QofSession * session)
00207 {
00208     g_return_if_fail (session);
00209     if (!session->backend)
00210         return;
00211     g_list_foreach (session->backend->error_stack, clear_list, NULL);
00212     g_list_free (session->backend->error_stack);
00213     session->backend->error_stack = NULL;
00214     if (session->error_message)
00215         g_free (session->error_message);
00216     session->error_message = NULL;
00217     session->last_err = QOF_SUCCESS;
00218 #ifndef QOF_DISABLE_DEPRECATED
00219     session->backend->last_err = QOF_SUCCESS;
00220 #endif
00221 }
00222 
00223 QofErrorId
00224 qof_error_check (QofSession * session)
00225 {
00226     g_return_val_if_fail (session, QOF_FATAL);
00227     return qof_error_check_be (session->backend);
00228 }
00229 
00230 QofErrorId
00231 qof_error_check_be (QofBackend * be)
00232 {
00233     QofError * qerr;
00234     GList * first;
00235 
00236     if (!be)
00237         return QOF_FATAL;
00238     if (g_list_length (be->error_stack) == 0)
00239         return QOF_SUCCESS;
00240     first = g_list_first (be->error_stack);
00241     qerr = (QofError*)first->data;
00242     if (!qerr)
00243         return QOF_FATAL;
00244     return qerr->id;
00245 }
00246 
00247 QofTime *
00248 qof_error_get_time_be (QofBackend * be)
00249 {
00250     QofError * qerr;
00251     GList * first;
00252 
00253     if (g_list_length(be->error_stack) == 0)
00254         return NULL;
00255     first = g_list_first (be->error_stack);
00256     qerr = (QofError*)first->data;
00257     return qerr->qt;
00258 }
00259 
00260 QofTime *
00261 qof_error_get_time (QofSession * session)
00262 {
00263     return qof_error_get_time_be (session->backend);
00264 }
00265 
00266 #ifndef QOF_DISABLE_DEPRECATED
00267 static void
00268 set_previous_error (QofBackend * be)
00269 {
00270     QofError * qerr;
00271     GList * pop;
00272 
00273     if (!be)
00274         return;
00275     if (g_list_length(be->error_stack) == 0)
00276         return;
00277     pop = g_list_last (be->error_stack);
00278     qerr = (QofError*)pop->data;
00279     be->last_err = qerr->id;
00280     be->error_msg = qerr->message;
00281 }
00282 #endif
00283 
00284 QofErrorId
00285 qof_error_get_id (QofSession * session)
00286 {
00287     QofErrorId id;
00288 
00289     g_return_val_if_fail (session, QOF_FATAL);
00290     id = qof_error_get_id_be (session->backend);
00291     {
00292         QofError * qerr;
00293 
00294         qerr = g_hash_table_lookup (error_table, 
00295             GINT_TO_POINTER(id));
00296         if (session->error_message)
00297             g_free (session->error_message);
00298         session->error_message = qerr->message;
00299         session->last_err = id;
00300     }
00301     return id;
00302 }
00303 
00304 QofErrorId
00305 qof_error_get_id_be (QofBackend * be)
00306 {
00307     QofError * qerr;
00308     GList * first;
00309 
00310     if (!be)
00311         return QOF_FATAL;
00312     if (g_list_length (be->error_stack) == 0)
00313         return QOF_SUCCESS;
00314     first = g_list_first (be->error_stack);
00315     qerr = (QofError*)first->data;
00316     if (!qerr)
00317         return QOF_FATAL;
00318     be->error_stack = 
00319         g_list_remove (be->error_stack, qerr);
00320 #ifndef QOF_DISABLE_DEPRECATED
00321     set_previous_error (be);
00322 #endif
00323     return qerr->id;
00324 }
00325 
00326 const gchar *
00327 qof_error_get_message (QofSession * session)
00328 {
00329     const gchar * msg;
00330 
00331     g_return_val_if_fail (session, NULL);
00332     if (!session->backend)
00333         return session->error_message;
00334     msg = qof_error_get_message_be (session->backend);
00335     DEBUG (" msg_1=%s", msg);
00336 #ifndef QOF_DISABLE_DEPRECATED
00337     {
00338         QofError * qerr;
00339 
00340         qerr = g_hash_table_lookup (error_table, 
00341             GINT_TO_POINTER(session->backend->last_err));
00342         if (!qerr)
00343             return NULL;
00344         if (session->error_message)
00345             g_free (session->error_message);
00346         session->error_message = g_strdup(msg);
00347         session->last_err = qerr->id;
00348     }
00349 #endif
00350     return msg;
00351 }
00352 
00353 const gchar *
00354 qof_error_get_message_be (QofBackend * be)
00355 {
00356     QofError * qerr;
00357     GList * first;
00358 
00359     g_return_val_if_fail (be, NULL);
00360     if (g_list_length (be->error_stack) == 0)
00361     {
00362         DEBUG (" empty error stack");
00363         return NULL;
00364     }
00365     first = g_list_first (be->error_stack);
00366     qerr = (QofError*)first->data;
00367     if (!qerr)
00368     {
00369         DEBUG (" empty QofError value");
00370         return NULL;
00371     }
00372     DEBUG (" qerr->message=%s", qerr->message);
00373     be->error_stack = 
00374         g_list_remove (be->error_stack, qerr);
00375 #ifndef QOF_DISABLE_DEPRECATED
00376     be->error_msg = qerr->message;
00377     set_previous_error (be);
00378 #endif
00379     return qerr->message;
00380 }

Generated on Sun Apr 29 00:28:01 2007 for QOF by  doxygen 1.5.1