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