gboolean
equals_node_val_vs_kvp_frame(xmlNodePtr node, const kvp_frame *frm)
{
kvp_frame *cmpfrm;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(frm, FALSE);
cmpfrm = dom_tree_to_kvp_frame(node);
g_return_val_if_fail(cmpfrm, FALSE);
if (kvp_frame_compare(frm, cmpfrm) == 0)
{
kvp_frame_delete(cmpfrm);
return TRUE;
}
else
{
gchar *frm1str;
gchar *frm2str;
frm1str = kvp_frame_to_string(frm);
frm2str = kvp_frame_to_string(cmpfrm);
printf("%s vs %s\n", frm1str, frm2str);
g_free(frm1str);
g_free(frm2str);
kvp_frame_delete(cmpfrm);
return FALSE;
}
}
static void
remove_guids (Split *sa, Split *sb)
{
KvpFrame *ksub;
/* Find and remove the matching guid's */
ksub = (KvpFrame*)gnc_kvp_bag_find_by_guid (sa->inst.kvp_data, "lot-split",
"peer_guid", qof_instance_get_guid(sb));
if (ksub)
{
gnc_kvp_bag_remove_frame (sa->inst.kvp_data, "lot-split", ksub);
kvp_frame_delete (ksub);
}
/* Now do it in the other direction */
ksub = (KvpFrame*)gnc_kvp_bag_find_by_guid (sb->inst.kvp_data, "lot-split",
"peer_guid", qof_instance_get_guid(sa));
if (ksub)
{
gnc_kvp_bag_remove_frame (sb->inst.kvp_data, "lot-split", ksub);
kvp_frame_delete (ksub);
}
/* Finally, merge b's lot-splits, if any, into a's */
/* This is an important step, if it got busted into many pieces. */
gnc_kvp_bag_merge (sa->inst.kvp_data, "lot-split",
sb->inst.kvp_data, "lot-split");
}
void
kvp_value_delete(KvpValue * value)
{
if (!value) return;
switch (value->type)
{
case KVP_TYPE_STRING:
g_free(value->value.str);
break;
case KVP_TYPE_GUID:
g_free(value->value.guid);
break;
case KVP_TYPE_BINARY:
g_free(value->value.binary.data);
break;
case KVP_TYPE_GLIST:
kvp_glist_delete(value->value.list);
break;
case KVP_TYPE_FRAME:
kvp_frame_delete(value->value.frame);
break;
default:
break;
}
g_free(value);
}
void
qof_backend_destroy(QofBackend *be)
{
g_free(be->error_msg);
be->error_msg = NULL;
kvp_frame_delete(be->backend_configuration);
be->backend_configuration = NULL;
}
void qof_backend_prepare_frame(QofBackend *be)
{
g_return_if_fail(be);
if (!kvp_frame_is_empty(be->backend_configuration))
{
kvp_frame_delete(be->backend_configuration);
be->backend_configuration = kvp_frame_new();
}
be->config_count = 0;
}
static void
qof_instance_finalize_real (GObject *instp)
{
QofInstancePrivate *priv;
QofInstance* inst = QOF_INSTANCE(instp);
kvp_frame_delete (inst->kvp_data);
inst->kvp_data = NULL;
priv = GET_PRIVATE(inst);
priv->editlevel = 0;
priv->do_free = FALSE;
priv->dirty = FALSE;
}
void
qof_instance_set_slots (QofInstance *inst, KvpFrame *frm)
{
QofInstancePrivate *priv;
if (!inst) return;
priv = GET_PRIVATE(inst);
if (inst->kvp_data && (inst->kvp_data != frm))
{
kvp_frame_delete(inst->kvp_data);
}
priv->dirty = TRUE;
inst->kvp_data = frm;
}
static void
qof_instance_foreach_copy(gpointer data, gpointer user_data)
{
QofInstance *importEnt, *targetEnt/*, *referenceEnt*/;
QofInstanceCopyData *context;
QofInstanceReference *reference;
gboolean registered_type;
/* cm_ prefix used for variables that hold the data to commit */
QofParam *cm_param;
gchar *cm_string, *cm_char;
const GncGUID *cm_guid;
KvpFrame *cm_kvp;
QofCollection *cm_col;
/* function pointers and variables for parameter getters that don't use pointers normally */
gnc_numeric cm_numeric, (*numeric_getter) (QofInstance*, QofParam*);
double cm_double, (*double_getter) (QofInstance*, QofParam*);
gboolean cm_boolean, (*boolean_getter) (QofInstance*, QofParam*);
gint32 cm_i32, (*int32_getter) (QofInstance*, QofParam*);
gint64 cm_i64, (*int64_getter) (QofInstance*, QofParam*);
Timespec cm_date, (*date_getter) (QofInstance*, QofParam*);
/* function pointers to the parameter setters */
void (*string_setter) (QofInstance*, const char*);
void (*date_setter) (QofInstance*, Timespec);
void (*numeric_setter) (QofInstance*, gnc_numeric);
void (*guid_setter) (QofInstance*, const GncGUID*);
void (*double_setter) (QofInstance*, double);
void (*boolean_setter) (QofInstance*, gboolean);
void (*i32_setter) (QofInstance*, gint32);
void (*i64_setter) (QofInstance*, gint64);
void (*char_setter) (QofInstance*, char*);
void (*kvp_frame_setter) (QofInstance*, KvpFrame*);
g_return_if_fail(user_data != NULL);
context = (QofInstanceCopyData*) user_data;
cm_date.tv_nsec = 0;
cm_date.tv_sec = 0;
importEnt = context->from;
targetEnt = context->to;
registered_type = FALSE;
cm_param = (QofParam*) data;
g_return_if_fail(cm_param != NULL);
context->param = cm_param;
if (safe_strcmp(cm_param->param_type, QOF_TYPE_STRING) == 0)
{
cm_string = (gchar*)cm_param->param_getfcn(importEnt, cm_param);
if (cm_string)
{
string_setter = (void(*)(QofInstance*, const char*))cm_param->param_setfcn;
if (string_setter != NULL)
{
string_setter(targetEnt, cm_string);
}
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_DATE) == 0)
{
date_getter = (Timespec (*)(QofInstance*, QofParam*))cm_param->param_getfcn;
cm_date = date_getter(importEnt, cm_param);
date_setter = (void(*)(QofInstance*, Timespec))cm_param->param_setfcn;
if (date_setter != NULL)
{
date_setter(targetEnt, cm_date);
}
registered_type = TRUE;
}
if ((safe_strcmp(cm_param->param_type, QOF_TYPE_NUMERIC) == 0) ||
(safe_strcmp(cm_param->param_type, QOF_TYPE_DEBCRED) == 0))
{
numeric_getter = (gnc_numeric (*)(QofInstance*, QofParam*))cm_param->param_getfcn;
cm_numeric = numeric_getter(importEnt, cm_param);
numeric_setter = (void(*)(QofInstance*, gnc_numeric))cm_param->param_setfcn;
if (numeric_setter != NULL)
{
numeric_setter(targetEnt, cm_numeric);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_GUID) == 0)
{
cm_guid = (const GncGUID*)cm_param->param_getfcn(importEnt, cm_param);
guid_setter = (void(*)(QofInstance*, const GncGUID*))cm_param->param_setfcn;
if (guid_setter != NULL)
{
guid_setter(targetEnt, cm_guid);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_INT32) == 0)
{
int32_getter = (gint32 (*)(QofInstance*, QofParam*)) cm_param->param_getfcn;
cm_i32 = int32_getter(importEnt, cm_param);
i32_setter = (void(*)(QofInstance*, gint32))cm_param->param_setfcn;
if (i32_setter != NULL)
{
i32_setter(targetEnt, cm_i32);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_INT64) == 0)
{
int64_getter = (gint64 (*)(QofInstance*, QofParam*)) cm_param->param_getfcn;
cm_i64 = int64_getter(importEnt, cm_param);
i64_setter = (void(*)(QofInstance*, gint64))cm_param->param_setfcn;
if (i64_setter != NULL)
{
i64_setter(targetEnt, cm_i64);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_DOUBLE) == 0)
{
double_getter = (double (*)(QofInstance*, QofParam*)) cm_param->param_getfcn;
cm_double = double_getter(importEnt, cm_param);
double_setter = (void(*)(QofInstance*, double))cm_param->param_setfcn;
if (double_setter != NULL)
{
double_setter(targetEnt, cm_double);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_BOOLEAN) == 0)
{
boolean_getter = (gboolean (*)(QofInstance*, QofParam*)) cm_param->param_getfcn;
cm_boolean = boolean_getter(importEnt, cm_param);
boolean_setter = (void(*)(QofInstance*, gboolean))cm_param->param_setfcn;
if (boolean_setter != NULL)
{
boolean_setter(targetEnt, cm_boolean);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_KVP) == 0)
{
cm_kvp = (KvpFrame*)cm_param->param_getfcn(importEnt, cm_param);
kvp_frame_setter = (void(*)(QofInstance*, KvpFrame*))cm_param->param_setfcn;
if (kvp_frame_setter != NULL)
{
kvp_frame_setter(targetEnt, cm_kvp);
}
else
{
QofInstance *target_inst;
target_inst = (QofInstance*)targetEnt;
kvp_frame_delete(target_inst->kvp_data);
target_inst->kvp_data = kvp_frame_copy(cm_kvp);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_CHAR) == 0)
{
cm_char = (gchar*)cm_param->param_getfcn(importEnt, cm_param);
char_setter = (void(*)(QofInstance*, char*))cm_param->param_setfcn;
if (char_setter != NULL)
{
char_setter(targetEnt, cm_char);
}
registered_type = TRUE;
}
if (safe_strcmp(cm_param->param_type, QOF_TYPE_COLLECT) == 0)
{
cm_col = (QofCollection*)cm_param->param_getfcn(importEnt, cm_param);
if (cm_col)
{
/* create one reference for each member of the collection. */
qof_collection_foreach(cm_col, col_ref_cb, context);
}
registered_type = TRUE;
}
if (registered_type == FALSE)
{
/* referenceEnt = QOF_INSTANCE(cm_param->param_getfcn(importEnt, cm_param));
if(!referenceEnt) { return; }
if(!referenceEnt->e_type) { return; }*/
reference = qof_instance_get_reference_from(importEnt, cm_param);
if (reference)
{
qof_session_update_reference_list(context->new_session, reference);
}
}
}
