QOF  0.8.0
qofutil.c
00001 /********************************************************************\
00002  * qofutil.c -- QOF utility functions                               *
00003  * Copyright (C) 1997 Robin D. Clark                                *
00004  * Copyright (C) 1997-2001,2004 Linas Vepstas <linas@linas.org>     *
00005  * Copyright 2006,2008  Neil Williams  <linux@codehelp.co.uk>       *
00006  *                                                                  *
00007  * This program is free software; you can redistribute it and/or    *
00008  * modify it under the terms of the GNU General Public License as   *
00009  * published by the Free Software Foundation; either version 2 of   *
00010  * the License, or (at your option) any later version.              *
00011  *                                                                  *
00012  * This program is distributed in the hope that it will be useful,  *
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
00015  * GNU General Public License for more details.                     *
00016  *                                                                  *
00017  * You should have received a copy of the GNU General Public License*
00018  * along with this program; if not, contact:                        *
00019  *                                                                  *
00020  * Free Software Foundation           Voice:  +1-617-542-5942       *
00021  * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
00022  * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
00023  *                                                                  *
00024  *   Author: Rob Clark (rclark@cs.hmc.edu)                          *
00025  *   Author: Linas Vepstas (linas@linas.org)                        *
00026 \********************************************************************/
00027 
00028 #include "config.h"
00029 
00030 #include <errno.h>
00031 #include <ctype.h>
00032 #include <glib.h>
00033 #include <stdlib.h>
00034 #include <string.h>
00035 #include <math.h>
00036 #include "qof.h"
00037 #include "qofundo-p.h"
00038 #include "qofbook-p.h"
00039 
00040 static QofLogModule log_module = QOF_MOD_UTIL;
00041 
00042 /* Search for str2 in first nchar chars of str1, ignore case..  Return
00043  * pointer to first match, or null.  */
00044 gchar *
00045 strncasestr (const guchar * str1, const guchar * str2, size_t len)
00046 {
00047     while (*str1 && len--)
00048     {
00049         if (toupper (*str1) == toupper (*str2))
00050         {
00051             if (strncasecmp (str1, str2, strlen (str2)) == 0)
00052                 return (gchar *) str1;
00053         }
00054         str1++;
00055     }
00056     return NULL;
00057 }
00058 
00059 #ifndef HAVE_STRCASESTR
00060 /* Search for str2 in str1, ignore case.  Return pointer to first
00061  * match, or null.  */
00062 gchar *
00063 strcasestr (const gchar * str1, const gchar * str2)
00064 {
00065     size_t len = strlen (str1);
00066     gchar *retval = strncasestr (str1, str2, len);
00067     return retval;
00068 }
00069 #endif
00070 
00072 gint
00073 safe_strcmp (const gchar * da, const gchar * db)
00074 {
00075     if ((da) && (db))
00076     {
00077         if ((da) != (db))
00078         {
00079             gint retval = strcmp ((da), (db));
00080             /* if strings differ, return */
00081             if (retval)
00082                 return retval;
00083         }
00084     }
00085     else if ((!(da)) && (db))
00086         return -1;
00087     else if ((da) && (!(db)))
00088         return +1;
00089     return 0;
00090 }
00091 
00092 gint
00093 safe_strcasecmp (const gchar * da, const gchar * db)
00094 {
00095     if ((da) && (db))
00096     {
00097         if ((da) != (db))
00098         {
00099             gint retval = strcasecmp ((da), (db));
00100             /* if strings differ, return */
00101             if (retval)
00102                 return retval;
00103         }
00104     }
00105     else if ((!(da)) && (db))
00106         return -1;
00107     else if ((da) && (!(db)))
00108         return +1;
00109     return 0;
00110 }
00111 
00112 inline gint
00113 null_strcmp (const gchar * da, const gchar * db)
00114 {
00115     if (da && db)
00116         return strcmp (da, db);
00117     if (!da && db && 0 == db[0])
00118         return 0;
00119     if (!db && da && 0 == da[0])
00120         return 0;
00121     if (!da && db)
00122         return -1;
00123     if (da && !db)
00124         return +1;
00125     return 0;
00126 }
00127 
00128 #define MAX_DIGITS 50
00129 
00130 /* inverse of strtoul */
00131 gchar *
00132 ultostr (gulong val, gint base)
00133 {
00134     gchar buf[MAX_DIGITS];
00135     gulong broke[MAX_DIGITS];
00136     gint i;
00137     gulong places = 0, reval;
00138 
00139     if ((2 > base) || (36 < base))
00140         return NULL;
00141 
00142     /* count digits */
00143     places = 0;
00144     for (i = 0; i < MAX_DIGITS; i++)
00145     {
00146         broke[i] = val;
00147         places++;
00148         val /= base;
00149         if (0 == val)
00150             break;
00151     }
00152 
00153     /* normalize */
00154     reval = 0;
00155     for (i = places - 2; i >= 0; i--)
00156     {
00157         reval += broke[i + 1];
00158         reval *= base;
00159         broke[i] -= reval;
00160     }
00161 
00162     /* print */
00163     for (i = 0; i < (gint) places; i++)
00164     {
00165         if (10 > broke[i])
00166         {
00167             buf[places - 1 - i] = 0x30 + broke[i];  /* ascii digit zero */
00168         }
00169         else
00170         {
00171             buf[places - 1 - i] = 0x41 - 10 + broke[i]; /* ascii capital A */
00172         }
00173     }
00174     buf[places] = 0x0;
00175 
00176     return g_strdup (buf);
00177 }
00178 
00179 inline gint
00180 qof_util_double_compare (gdouble d1, gdouble d2)
00181 {
00182     if (isnan (d1) && isnan (d2))
00183         return 0;
00184     if (d1 < d2)
00185         return -1;
00186     if (d1 > d2)
00187         return 1;
00188     return 0;
00189 }
00190 
00191 /* =================================================================== */
00192 /* returns TRUE if the string is a number, possibly with whitespace */
00193 /* =================================================================== */
00194 
00195 gboolean
00196 qof_util_string_isnum (const guchar * s)
00197 {
00198     if (s == NULL)
00199         return FALSE;
00200     if (*s == 0)
00201         return FALSE;
00202 
00203     while (*s && isspace (*s))
00204         s++;
00205 
00206     if (*s == 0)
00207         return FALSE;
00208     if (!isdigit (*s))
00209         return FALSE;
00210 
00211     while (*s && isdigit (*s))
00212         s++;
00213 
00214     if (*s == 0)
00215         return TRUE;
00216 
00217     while (*s && isspace (*s))
00218         s++;
00219 
00220     if (*s == 0)
00221         return TRUE;
00222 
00223     return FALSE;
00224 }
00225 
00226 /* =================================================================== */
00227 /* Return NULL if the field is whitespace (blank, tab, formfeed etc.)  
00228  * Else return pointer to first non-whitespace character. */
00229 /* =================================================================== */
00230 
00231 const gchar *
00232 qof_util_whitespace_filter (const gchar * val)
00233 {
00234     size_t len;
00235     if (!val)
00236         return NULL;
00237 
00238     len = strspn (val, "\a\b\t\n\v\f\r ");
00239     if (0 == val[len])
00240         return NULL;
00241     return val + len;
00242 }
00243 
00244 /* =================================================================== */
00245 /* Return integer 1 if the string starts with 't' or 'T' or contains the 
00246  * word 'true' or 'TRUE'; if string is a number, return that number. */
00247 /* =================================================================== */
00248 
00249 gint
00250 qof_util_bool_to_int (const gchar * val)
00251 {
00252     const gchar *p = qof_util_whitespace_filter (val);
00253     if (!p)
00254         return 0;
00255     if ('t' == p[0])
00256         return 1;
00257     if ('T' == p[0])
00258         return 1;
00259     if ('y' == p[0])
00260         return 1;
00261     if ('Y' == p[0])
00262         return 1;
00263     if (strstr (p, "true"))
00264         return 1;
00265     if (strstr (p, "TRUE"))
00266         return 1;
00267     if (strstr (p, "yes"))
00268         return 1;
00269     if (strstr (p, "YES"))
00270         return 1;
00271     return atoi (val);
00272 }
00273 
00274 /* =================================================================== */
00275 /* Entity edit and commit utilities */
00276 /* =================================================================== */
00277 
00278 gboolean
00279 qof_util_param_edit (QofInstance * inst, const QofParam *param)
00280 {
00281     QofBackend *be;
00282     QofUndo *undo_data;
00283 
00284     if (!inst)
00285         return FALSE;
00286     (inst->editlevel)++;
00287     if (1 < inst->editlevel)
00288         return FALSE;
00289     if (0 >= inst->editlevel)
00290         inst->editlevel = 1;
00291     be = qof_book_get_backend (inst->book);
00292     if (param != NULL)
00293     {
00294         undo_data = inst->book->undo_data;
00295         inst->param = param;
00296         if (undo_data->undo_operation_open)
00297             qof_undo_modify (inst, param);
00298     }
00299     if (be && qof_backend_begin_exists (be))
00300         qof_backend_run_begin (be, inst);
00301     else
00302         inst->dirty = TRUE;
00303     return TRUE;
00304 }
00305 
00306 gboolean
00307 qof_util_param_commit (QofInstance * inst, const QofParam * param)
00308 {
00309     QofUndo *undo_data;
00310     QofBackend * be;
00311 
00312     if (!inst)
00313         return FALSE;
00314     (inst->editlevel)--;
00315     if (0 < inst->editlevel)
00316         return FALSE;
00317     be = qof_book_get_backend (inst->book);
00318     inst->param = param;
00319     if (be && qof_backend_commit_exists (be))
00320         qof_backend_run_commit (be, inst);
00321     if (param != NULL)
00322     {
00323         undo_data = inst->book->undo_data;
00324         if (undo_data->undo_operation_open)
00325             qof_undo_commit (inst, param);
00326     }
00327     return TRUE;
00328 }
00329 
00330 gchar *
00331 qof_util_make_utf8 (gchar * string)
00332 {
00333     gchar *value;
00334 
00335     if (!string)
00336         return NULL;
00337     if (g_utf8_validate (string, -1, NULL))
00338         return string;
00339     value = g_locale_to_utf8 (string, -1, NULL, NULL, NULL);
00340     if (!value)
00341     {
00342         PWARN (" unable to convert from locale %s", string);
00343         PINFO ("trying to convert from ISO-8859-15.");
00344         value = g_convert (string, -1, "UTF-8", "ISO-8859-15",
00345             NULL, NULL, NULL);
00346         if (!value)
00347         {
00348             PERR (" conversion failed");
00349             return string;
00350         }
00351         return value;
00352     }
00353     return value;
00354 }
00355 
00356 /* =================================================================== */
00357 /* The QOF string cache */
00358 /* =================================================================== */
00359 
00360 static GCache *qof_string_cache = NULL;
00361 
00362 static GCache *
00363 qof_util_get_string_cache (void)
00364 {
00365     if (!qof_string_cache)
00366     {
00367         qof_string_cache = g_cache_new ((GCacheNewFunc) g_strdup,   /* value_new_func     */
00368             g_free,             /* value_destroy_func */
00369             (GCacheDupFunc) g_strdup,   /* key_dup_func       */
00370             g_free,             /* key_destroy_func   */
00371             g_str_hash,         /* hash_key_func      */
00372             g_str_hash,         /* hash_value_func    */
00373             g_str_equal);       /* key_equal_func     */
00374     }
00375     return qof_string_cache;
00376 }
00377 
00378 void
00379 qof_util_string_cache_destroy (void)
00380 {
00381     if (qof_string_cache)
00382         g_cache_destroy (qof_string_cache);
00383     qof_string_cache = NULL;
00384 }
00385 
00386 void
00387 qof_util_string_cache_remove (gconstpointer key)
00388 {
00389     if (key)
00390         g_cache_remove (qof_util_get_string_cache (), key);
00391 }
00392 
00393 gpointer
00394 qof_util_string_cache_insert (gconstpointer key)
00395 {
00396     if (key)
00397         return g_cache_insert(qof_util_get_string_cache(), (gpointer)key);
00398     return NULL;
00399 }
00400 
00401 gchar *
00402 qof_util_param_to_string (QofEntity * ent, const QofParam * param)
00403 {
00404     gchar *param_string;
00405     gchar param_sa[GUID_ENCODING_LENGTH + 1];
00406     gboolean known_type;
00407     QofType paramType;
00408     const GUID *param_guid;
00409     QofNumeric param_numeric, (*numeric_getter) (QofEntity *, const QofParam *);
00410     gdouble param_double, (*double_getter) (QofEntity *, const QofParam *);
00411     gboolean param_boolean, (*boolean_getter) (QofEntity *, const QofParam *);
00412     gint32 param_i32, (*int32_getter) (QofEntity *, const QofParam *);
00413     gint64 param_i64, (*int64_getter) (QofEntity *, const QofParam *);
00414     gchar param_char, (*char_getter) (QofEntity *, const QofParam *);
00415 
00416     param_string = NULL;
00417     known_type = FALSE;
00418     g_return_val_if_fail (ent && param, NULL);
00419     paramType = param->param_type;
00420     if (safe_strcmp (paramType, QOF_TYPE_STRING) == 0)
00421     {
00422         param_string = g_strdup (param->param_getfcn (ent, param));
00423         if (param_string == NULL)
00424             param_string = g_strup("");
00425         known_type = TRUE;
00426         return param_string;
00427     }
00428     if (safe_strcmp (paramType, QOF_TYPE_TIME) == 0)
00429     {
00430         QofTime *param_qt;
00431         QofDate *qd;
00432         param_qt = param->param_getfcn (ent, param);
00433         qd = qof_date_from_qtime (param_qt);
00434         return qof_date_print (qd, QOF_DATE_FORMAT_UTC);
00435     }
00436     if ((safe_strcmp (paramType, QOF_TYPE_NUMERIC) == 0) ||
00437         (safe_strcmp (paramType, QOF_TYPE_DEBCRED) == 0))
00438     {
00439         numeric_getter =
00440             (QofNumeric (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00441         param_numeric = numeric_getter (ent, param);
00442         param_string = g_strdup (qof_numeric_to_string (param_numeric));
00443         known_type = TRUE;
00444         return param_string;
00445     }
00446     if (safe_strcmp (paramType, QOF_TYPE_GUID) == 0)
00447     {
00448         param_guid = param->param_getfcn (ent, param);
00449         guid_to_string_buff (param_guid, param_sa);
00450         param_string = g_strdup (param_sa);
00451         known_type = TRUE;
00452         return param_string;
00453     }
00454     if (safe_strcmp (paramType, QOF_TYPE_INT32) == 0)
00455     {
00456         int32_getter =
00457             (gint32 (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00458         param_i32 = int32_getter (ent, param);
00459         param_string = g_strdup_printf ("%d", param_i32);
00460         known_type = TRUE;
00461         return param_string;
00462     }
00463     if (safe_strcmp (paramType, QOF_TYPE_INT64) == 0)
00464     {
00465         int64_getter =
00466             (gint64 (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00467         param_i64 = int64_getter (ent, param);
00468         param_string = g_strdup_printf ("%" G_GINT64_FORMAT, param_i64);
00469         known_type = TRUE;
00470         return param_string;
00471     }
00472     if (safe_strcmp (paramType, QOF_TYPE_DOUBLE) == 0)
00473     {
00474         double_getter =
00475             (double (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00476         param_double = double_getter (ent, param);
00477         param_string = g_strdup_printf ("%f", param_double);
00478         known_type = TRUE;
00479         return param_string;
00480     }
00481     if (safe_strcmp (paramType, QOF_TYPE_BOOLEAN) == 0)
00482     {
00483         boolean_getter =
00484             (gboolean (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00485         param_boolean = boolean_getter (ent, param);
00486         /* Boolean values need to be lowercase for QSF validation. */
00487         if (param_boolean == TRUE)
00488         {
00489             param_string = g_strdup ("true");
00490         }
00491         else
00492         {
00493             param_string = g_strdup ("false");
00494         }
00495         known_type = TRUE;
00496         return param_string;
00497     }
00498     /* "kvp" contains repeating values, cannot be a single string for the frame. */
00499     if (safe_strcmp (paramType, QOF_TYPE_KVP) == 0)
00500     {
00501         KvpFrame *frame = NULL;
00502         frame = param->param_getfcn (ent, param);
00503         known_type = TRUE;
00504         if (!kvp_frame_is_empty (frame))
00505         {
00506             GHashTable *hash = kvp_frame_get_hash (frame);
00507             param_string = g_strdup_printf ("%s(%d)", QOF_TYPE_KVP,
00508                 g_hash_table_size (hash));
00509         }
00510         /* ensure a newly allocated string is returned, even
00511         if the frame is empty. */
00512         else
00513         {
00514             param_string = g_strdup("");
00515         }
00516         return param_string;
00517     }
00518     if (safe_strcmp (paramType, QOF_TYPE_CHAR) == 0)
00519     {
00520         char_getter =
00521             (gchar (*)(QofEntity *, const QofParam *)) param->param_getfcn;
00522         param_char = char_getter (ent, param);
00523         known_type = TRUE;
00524         return g_strdup_printf ("%c", param_char);
00525     }
00526     /* "collect" contains repeating values, cannot be a single string. */
00527     if (safe_strcmp (paramType, QOF_TYPE_COLLECT) == 0)
00528     {
00529         QofCollection *col = NULL;
00530         col = param->param_getfcn (ent, param);
00531         known_type = TRUE;
00532         return g_strdup_printf ("%s(%d)",
00533             qof_collection_get_type (col), qof_collection_count (col));
00534     }
00535     if (safe_strcmp (paramType, QOF_TYPE_CHOICE) == 0)
00536     {
00537         QofEntity *child = NULL;
00538         child = param->param_getfcn (ent, param);
00539         if (!child)
00540         {
00541             return param_string;
00542         }
00543         known_type = TRUE;
00544         return g_strdup (qof_object_printable (child->e_type, child));
00545     }
00546     if (safe_strcmp (paramType, QOF_PARAM_BOOK) == 0)
00547     {
00548         QofBackend *be;
00549         QofBook *book;
00550         book = param->param_getfcn (ent, param);
00551         PINFO (" book param %p", book);
00552         be = qof_book_get_backend (book);
00553         known_type = TRUE;
00554         PINFO (" backend=%p", be);
00555         if (!be)
00556         {
00557             return QOF_PARAM_BOOK;
00558         }
00559         param_string = g_strdup (be->fullpath);
00560         PINFO (" fullpath=%s", param_string);
00561         if (param_string)
00562         {
00563             return param_string;
00564         }
00565         param_guid = qof_entity_get_guid ((QofEntity*)book);
00566         guid_to_string_buff (param_guid, param_sa);
00567         PINFO (" book GUID=%s", param_sa);
00568         param_string = g_strdup (param_sa);
00569         return param_string;
00570     }
00571     if (!known_type)
00572     {
00573         QofEntity *child = NULL;
00574         child = param->param_getfcn (ent, param);
00575         if (!child)
00576         {
00577             return param_string;
00578         }
00579         return g_strdup (qof_object_printable (child->e_type, child));
00580     }
00581     return g_strdup ("");
00582 }
00583 
00584 gboolean
00585 qof_util_param_set_string (QofEntity * ent, const QofParam * param,
00586     const gchar * value_string)
00587 {
00588     void (*string_setter) (QofEntity *, const gchar *);
00589     void (*time_setter) (QofEntity *, QofTime *);
00590     void (*numeric_setter) (QofEntity *, QofNumeric);
00591     void (*guid_setter) (QofEntity *, const GUID *);
00592     void (*double_setter) (QofEntity *, gdouble);
00593     void (*boolean_setter) (QofEntity *, gboolean);
00594     void (*i32_setter) (QofEntity *, gint32);
00595     void (*i64_setter) (QofEntity *, gint64);
00596     void (*char_setter) (QofEntity *, gchar);
00597 /*  void (*kvp_frame_setter) (QofEntity *, KvpFrame *);
00598     void (*reference_setter) (QofEntity *, QofEntity *);
00599     void (*collection_setter) (QofEntity *, QofCollection *);*/
00600 
00601     g_return_val_if_fail (ent, FALSE);
00602     g_return_val_if_fail (param, FALSE);
00603     g_return_val_if_fail (value_string, FALSE);
00604 
00605     if (safe_strcmp (param->param_type, QOF_TYPE_STRING) == 0)
00606     {
00607         string_setter =
00608             (void (*)(QofEntity *,
00609                 const gchar *)) param->param_setfcn;
00610         if (string_setter != NULL)
00611             string_setter (ent, value_string);
00612 //      registered_type = TRUE;
00613     }
00614     if (safe_strcmp (param->param_type, QOF_TYPE_TIME) == 0)
00615     {
00616         QofTime *qt;
00617         QofDate *qd;
00618 
00619         qd = qof_date_parse (value_string, QOF_DATE_FORMAT_UTC);
00620         if (!qd)
00621             return FALSE;
00622         qt = qof_date_to_qtime (qd);
00623         time_setter = 
00624             (void (*)(QofEntity *, QofTime *))
00625             param->param_setfcn;
00626         if ((time_setter != NULL) && (qof_time_is_valid (qt)))
00627             time_setter (ent, qt);
00628         qof_date_free (qd);
00629 //      registered_type = TRUE;
00630     }
00631     if ((safe_strcmp (param->param_type, QOF_TYPE_NUMERIC) == 0) ||
00632         (safe_strcmp (param->param_type, QOF_TYPE_DEBCRED) == 0))
00633     {
00634         QofNumeric num;
00635         numeric_setter =
00636             (void (*)(QofEntity *,
00637                 QofNumeric)) param->param_setfcn;
00638         if (!qof_numeric_from_string (value_string, &num) ||
00639             (qof_numeric_check (num) != QOF_ERROR_OK))
00640             return FALSE;
00641         if (numeric_setter != NULL)
00642             numeric_setter (ent, num);
00643 //      registered_type = TRUE;
00644     }
00645     if (safe_strcmp (param->param_type, QOF_TYPE_GUID) == 0)
00646     {
00647         GUID * guid;
00648 
00649         guid = guid_malloc();
00650         guid_new (guid);
00651         guid_setter =
00652             (void (*)(QofEntity *,
00653                 const GUID *)) param->param_setfcn;
00654         if (!string_to_guid(value_string, guid))
00655             return FALSE;
00656         if (guid_setter != NULL)
00657             guid_setter (ent, guid);
00658 //      registered_type = TRUE;
00659     }
00660     if (safe_strcmp (param->param_type, QOF_TYPE_INT32) == 0)
00661     {
00662         gint32 i32;
00663         gchar *tail;
00664 
00665         errno = 0;
00666         i32_setter =
00667             (void (*)(QofEntity *, gint32)) param->param_setfcn;
00668         i32 =
00669             (gint32) strtol (value_string, &tail, 0);
00670         if ((i32_setter != NULL) && (errno == 0))
00671 
00672             i32_setter (ent, i32);
00673 //      registered_type = TRUE;
00674     }
00675     if (safe_strcmp (param->param_type, QOF_TYPE_INT64) == 0)
00676     {
00677         gint64 i64;
00678         gchar *tail;
00679 
00680         errno = 0;
00681         i64 = strtoll (value_string, &tail, 0);
00682         i64_setter =
00683             (void (*)(QofEntity *, gint64)) param->param_setfcn;
00684         if ((i64_setter != NULL) && (errno == 0))
00685             i64_setter (ent, i64);
00686 //      registered_type = TRUE;
00687     }
00688     if (safe_strcmp (param->param_type, QOF_TYPE_DOUBLE) == 0)
00689     {
00690         gdouble db;
00691         gchar *tail;
00692 
00693         errno = 0;
00694         db = strtod (value_string, &tail);
00695         double_setter =
00696             (void (*)(QofEntity *, gdouble)) param->param_setfcn;
00697         if ((double_setter != NULL) && (errno == 0))
00698             double_setter (ent, db);
00699 //      registered_type = TRUE;
00700     }
00701     if (safe_strcmp (param->param_type, QOF_TYPE_BOOLEAN) == 0)
00702     {
00703         gint val;
00704         gboolean b;
00705 
00706         boolean_setter =
00707             (void (*)(QofEntity *, gboolean)) param->param_setfcn;
00708         val = qof_util_bool_to_int(value_string);
00709         if ((val > 1) || (val < 0))
00710             return FALSE;
00711         b = (val == 1) ? TRUE : FALSE;
00712         if (boolean_setter != NULL)
00713             boolean_setter (ent, val);
00714 //      registered_type = TRUE;
00715     }
00716     if (safe_strcmp (param->param_type, QOF_TYPE_KVP) == 0)
00717     {
00718         /* unsupported */
00719         return FALSE;
00720 /*      KvpFrame * frame;
00721         KvpValue * value;
00722 
00723         kvp_frame_setter =
00724             (void (*)(QofEntity *, KvpFrame *)) param->param_setfcn;
00725         if (kvp_frame_setter != NULL)
00726             kvp_frame_setter (rule->targetEnt, cm_kvp);
00727 //      registered_type = TRUE;*/
00728     }
00729     if (safe_strcmp (param->param_type, QOF_TYPE_CHAR) == 0)
00730     {
00731         char_setter =
00732             (void (*)(QofEntity *, gchar)) param->param_setfcn;
00733         if (char_setter != NULL)
00734             char_setter (ent, value_string[0]);
00735 //      registered_type = TRUE;
00736     }
00737     if (safe_strcmp (param->param_type, QOF_TYPE_COLLECT) == 0)
00738     {
00739         /* unsupported */
00740         return FALSE;
00741     }
00742     if (safe_strcmp (param->param_type, QOF_TYPE_CHOICE) == 0)
00743     {
00744         /* unsupported*/
00745         return FALSE;
00746     }
00747 /*  if (registered_type == FALSE)
00748     {
00749         referenceEnt =
00750             cm_param->param_getfcn (rule->importEnt, cm_param);
00751         if (referenceEnt)
00752         {
00753             reference_setter =
00754                 (void (*)(QofEntity *, QofEntity *)) cm_param->
00755                 param_setfcn;
00756             if (reference_setter != NULL)
00757             {
00758                 reference_setter (rule->targetEnt, referenceEnt);
00759             }
00760         }
00761     }*/
00762     return TRUE;
00763 }
00764 
00765 
00766 void
00767 qof_init (void)
00768 {
00769     qof_util_get_string_cache ();
00770     guid_init ();
00771     qof_date_init ();
00772     qof_object_initialize ();
00773     qof_query_init ();
00774     qof_book_register ();
00775 }
00776 
00777 void
00778 qof_close (void)
00779 {
00780     qof_query_shutdown ();
00781     qof_object_shutdown ();
00782     guid_shutdown ();
00783     qof_date_close ();
00784     qof_util_string_cache_destroy ();
00785 }
00786 
00787 /* ************************ END OF FILE ***************************** */