gboolean
qof_instance_copy_coll(QofSession *new_session, QofCollection *entity_coll)
{
QofInstanceCopyData qecd;
g_return_val_if_fail(new_session, FALSE);
if (!entity_coll)
{
return FALSE;
}
qof_event_suspend();
qecd.param_list = NULL;
qecd.new_session = new_session;
qof_book_set_partial(qof_session_get_book(qecd.new_session));
qof_collection_foreach(entity_coll, qof_instance_coll_foreach, &qecd);
qof_class_param_foreach(qof_collection_get_type(entity_coll),
qof_instance_param_cb, &qecd);
qof_collection_foreach(entity_coll, qof_instance_coll_copy, &qecd);
if (qecd.param_list != NULL)
{
g_slist_free(qecd.param_list);
}
qof_event_resume();
return TRUE;
}
gboolean qof_instance_copy_one_r(QofSession *new_session, QofInstance *ent)
{
struct recurse_s store;
QofCollection *coll;
gboolean success;
if ((!new_session) || (!ent))
{
return FALSE;
}
store.session = new_session;
success = TRUE;
store.success = success;
store.ref_list = qof_class_get_referenceList(ent->e_type);
success = qof_instance_copy_to_session(new_session, ent);
if (success == TRUE)
{
coll = qof_book_get_collection(qof_session_get_book(new_session), ent->e_type);
if (coll)
{
qof_collection_foreach(coll, recurse_ent_cb, &store);
}
}
return success;
}
/** Handles book end - frees all entries from the book
*
* @param book Book being closed
*/
static void
gnc_entry_book_end(QofBook* book)
{
QofCollection *col;
col = qof_book_get_collection(book, GNC_ID_ENTRY);
qof_collection_foreach(col, destroy_entry_on_book_close, NULL);
}
/** Handles book end - frees all employees from the book
*
* @param book Book being closed
*/
static void
gnc_employee_book_end(QofBook* book)
{
QofCollection *col;
col = qof_book_get_collection(book, GNC_ID_EMPLOYEE);
qof_collection_foreach(col, destroy_employee_on_book_close, NULL);
}
/**
* Destroys all SXes in the book because the book is being destroyed.
*
* @param book Book being destroyed
*/
static void
gnc_sx_book_end(QofBook* book)
{
QofCollection *col;
col = qof_book_get_collection(book, GNC_ID_SCHEDXACTION);
qof_collection_foreach(col, destroy_sx_on_book_close, NULL);
}
static void
grand_setDescend(mygrand *g, QofCollection *coll)
{
g_return_if_fail(g || coll);
if (0 != safe_strcmp(qof_collection_get_type(coll), CHILD_MODULE_NAME))
{
return;
}
qof_collection_foreach(coll, descend_cb, g);
}
bool
GncSqlLotsBackend::write (GncSqlBackend* be)
{
g_return_val_if_fail (be != NULL, FALSE);
write_objects_t data{be, true, this};
qof_collection_foreach (qof_book_get_collection (be->book(), GNC_ID_LOT),
(QofInstanceForeachCB)do_save_lot, &data);
return data.is_ok;
}
static gboolean
write_lots( GncSqlBackend* be )
{
write_objects_t data;
g_return_val_if_fail( be != NULL, FALSE );
data.be = be;
data.is_ok = TRUE;
qof_collection_foreach( qof_book_get_collection( be->book, GNC_ID_LOT ),
(QofInstanceForeachCB)do_save_lot, &data );
return data.is_ok;
}
void
do_compare( QofBook* book_1, QofBook* book_2, const gchar* id, QofInstanceForeachCB cb, const gchar* msg )
{
QofCollection* coll;
CompareInfoStruct info;
coll = qof_book_get_collection( book_1, id );
info.book_1 = book_1;
info.book_2 = book_2;
info.result = TRUE;
qof_collection_foreach(coll, cb, &info);
do_test( info.result, msg );
}
GList*
qof_instance_get_referring_object_list_from_collection(const QofCollection* coll, const QofInstance* ref)
{
GetReferringObjectHelperData data;
g_return_val_if_fail( coll != NULL, NULL );
g_return_val_if_fail( ref != NULL, NULL );
data.inst = ref;
data.list = NULL;
qof_collection_foreach(coll, get_typed_referring_object_instance_helper, &data);
return data.list;
}
static void
get_referring_object_helper(QofCollection* coll, gpointer user_data)
{
QofInstance* first_instance = NULL;
GetReferringObjectHelperData* data = (GetReferringObjectHelperData*)user_data;
qof_collection_foreach(coll, get_referring_object_instance_helper, &first_instance);
if (first_instance != NULL)
{
GList* new_list = qof_instance_get_typed_referring_object_list(first_instance, data->inst);
data->list = g_list_concat(data->list, new_list);
}
}
/* CAS: Even though it works, something feels not-quite-right with
* this design. The idea here is to _not_ provide yet another
* implementation of GtkTreeModel, this time for budgets. Instead,
* right now, we're using the already implemented GtkListStore. This
* has a couple consequences: 1) We allocate a new store upon every
* call, so the memory is owned by caller. 2) The model won't reflect
* later updates to the book, so the model shouldn't be expected to
* track asynchronous changes.
*
* If, for some reason, I decide I can't live with or remove those
* consequences, I still think there must be some better way than
* re-implementing GtkTreeModel. One idea I'm toying with is to
* implement a GtkTreeModel for QofCollections, which would offer only
* the GncGUID as a field. Then, TreeViews could add their own columns
* with custom CellDataFuncs to display the object-specific fields.
* Or, something like that. :)
*
*/
GtkTreeModel *
gnc_tree_model_budget_new(QofBook *book)
{
GtkListStore* store;
store = gtk_list_store_new (BUDGET_LIST_NUM_COLS,
G_TYPE_POINTER,
G_TYPE_STRING,
G_TYPE_STRING);
qof_collection_foreach(qof_book_get_collection(book, GNC_ID_BUDGET),
add_budget_to_model, GTK_TREE_MODEL(store));
return GTK_TREE_MODEL(store);
}
bool
GncSqlBudgetBackend::write (GncSqlBackend* sql_be)
{
write_objects_t data;
g_return_val_if_fail (sql_be != NULL, FALSE);
data.be = sql_be;
data.is_ok = TRUE;
data.obe = this;
qof_collection_foreach (qof_book_get_collection (sql_be->book(), GNC_ID_BUDGET),
(QofInstanceForeachCB)do_save, &data);
return data.is_ok;
}
gboolean
qof_instance_copy_coll_r(QofSession *new_session, QofCollection *coll)
{
struct recurse_s store;
gboolean success;
if ((!new_session) || (!coll))
{
return FALSE;
}
store.session = new_session;
success = TRUE;
store.success = success;
store.ent_list = NULL;
store.ref_list = qof_class_get_referenceList(qof_collection_get_type(coll));
success = qof_instance_copy_coll(new_session, coll);
if (success)
{
qof_collection_foreach(coll, recurse_ent_cb, &store);
}
return success;
}
static void
recurse_ent_cb(QofInstance *ent, gpointer user_data)
{
GList *ref_list, *i, *j, *ent_list, *child_list;
QofParam *ref_param;
QofInstance *ref_ent, *child_ent;
QofSession *session;
struct recurse_s *store;
gboolean success;
if (user_data == NULL)
{
return;
}
store = (struct recurse_s*)user_data;
session = store->session;
success = store->success;
ref_list = NULL;
child_ent = NULL;
ref_list = g_list_copy(store->ref_list);
if ((!session) || (!ent))
{
return;
}
ent_list = NULL;
child_list = NULL;
i = NULL;
j = NULL;
for (i = ref_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
ref_param = (QofParam*)i->data;
if (ref_param->param_name == NULL)
{
continue;
}
if (0 == safe_strcmp(ref_param->param_type, QOF_TYPE_COLLECT))
{
QofCollection *col;
col = ref_param->param_getfcn(ent, ref_param);
if (col)
{
qof_collection_foreach(col, recurse_collection_cb, store);
}
continue;
}
ref_ent = QOF_INSTANCE(ref_param->param_getfcn(ent, ref_param));
if ((ref_ent) && (ref_ent->e_type))
{
store->success = qof_instance_copy_to_session(session, ref_ent);
if (store->success)
{
ent_list = g_list_append(ent_list, ref_ent);
}
}
}
for (i = ent_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
child_ent = QOF_INSTANCE(i->data);
if (child_ent == NULL)
{
continue;
}
ref_list = qof_class_get_referenceList(child_ent->e_type);
for (j = ref_list; j != NULL; j = j->next)
{
if (j->data == NULL)
{
continue;
}
ref_param = (QofParam*)j->data;
ref_ent = ref_param->param_getfcn(child_ent, ref_param);
if (ref_ent != NULL)
{
success = qof_instance_copy_to_session(session, ref_ent);
if (success)
{
child_list = g_list_append(child_list, ref_ent);
}
}
}
}
for (i = child_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
ref_ent = QOF_INSTANCE(i->data);
if (ref_ent == NULL)
{
continue;
}
ref_list = qof_class_get_referenceList(ref_ent->e_type);
for (j = ref_list; j != NULL; j = j->next)
{
if (j->data == NULL)
{
continue;
}
ref_param = (QofParam*)j->data;
child_ent = ref_param->param_getfcn(ref_ent, ref_param);
if (child_ent != NULL)
{
qof_instance_copy_to_session(session, child_ent);
}
}
}
}
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);
}
}
}
