static gboolean
billterm_guid_handler (xmlNodePtr node, gpointer billterm_pdata)
{
struct billterm_pdata *pdata = billterm_pdata;
GncGUID *guid;
GncBillTerm *term;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
term = gncBillTermLookup (pdata->book, guid);
if (term)
{
gncBillTermDestroy (pdata->term);
pdata->term = term;
gncBillTermBeginEdit (term);
}
else
{
gncBillTermSetGUID(pdata->term, guid);
}
g_free(guid);
return TRUE;
}
static GncBillTerm*
load_single_billterm (GncSqlBackend* sql_be, GncSqlRow& row,
BillTermParentGuidVec& l_billterms_needing_parents)
{
g_return_val_if_fail (sql_be != NULL, NULL);
auto guid = gnc_sql_load_guid (sql_be, row);
auto pBillTerm = gncBillTermLookup (sql_be->book(), guid);
if (pBillTerm == nullptr)
{
pBillTerm = gncBillTermCreate (sql_be->book());
}
gnc_sql_load_object (sql_be, row, GNC_ID_BILLTERM, pBillTerm, col_table);
/* If the billterm doesn't have a parent, it might be because it hasn't been
loaded yet. If so, add this billterm to the list of billterms with no
parent, along with the parent GncGUID so that after they are all loaded,
the parents can be fixed up. */
if (gncBillTermGetParent (pBillTerm) == NULL)
{
BillTermParentGuid s;
s.billterm = pBillTerm;
s.have_guid = false;
gnc_sql_load_object (sql_be, row, GNC_ID_TAXTABLE, &s,
billterm_parent_col_table);
if (s.have_guid)
l_billterms_needing_parents.push_back(new BillTermParentGuid(s));
}
qof_instance_mark_clean (QOF_INSTANCE (pBillTerm));
return pBillTerm;
}
void
GncSqlBillTermBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
BillTermParentGuidVec l_billterms_needing_parents;
for (auto row : *result)
{
auto pBillTerm =
load_single_billterm (sql_be, row, l_billterms_needing_parents);
if (pBillTerm != nullptr)
instances.push_back(QOF_INSTANCE(pBillTerm));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
/* While there are items on the list of billterms needing parents,
try to see if the parent has now been loaded. Theory says that if
items are removed from the front and added to the back if the
parent is still not available, then eventually, the list will
shrink to size 0. */
if (!l_billterms_needing_parents.empty())
{
bool progress_made = true;
std::reverse(l_billterms_needing_parents.begin(),
l_billterms_needing_parents.end());
auto end = l_billterms_needing_parents.end();
while (progress_made)
{
progress_made = false;
end = std::remove_if(l_billterms_needing_parents.begin(), end,
[&](BillTermParentGuidPtr s)
{
auto pBook = qof_instance_get_book (QOF_INSTANCE (s->billterm));
auto parent = gncBillTermLookup (pBook,
&s->guid);
if (parent != nullptr)
{
gncBillTermSetParent (s->billterm, parent);
gncBillTermSetChild (parent, s->billterm);
progress_made = true;
delete s;
return true;
}
return false;
});
}
}
}
template<> void
GncSqlColumnTableEntryImpl<CT_BILLTERMREF>::load (const GncSqlBackend* sql_be,
GncSqlRow& row,
QofIdTypeConst obj_name,
gpointer pObject) const noexcept
{
load_from_guid_ref(row, obj_name, pObject,
[sql_be](GncGUID* g){
return gncBillTermLookup(sql_be->book(), g);
});
}
static void
compare_single_billterm( QofInstance* inst, gpointer user_data )
{
CompareInfoStruct* info = (CompareInfoStruct*)user_data;
GncBillTerm* bt_1 = GNC_BILLTERM(inst);
GncBillTerm* bt_2 = gncBillTermLookup( info->book_2, qof_instance_get_guid(inst) );
if (!gncBillTermEqual( bt_1, bt_2 ))
{
info->result = FALSE;
}
}
static GncBillTerm*
load_single_billterm (GncSqlBackend* be, GncSqlRow* row,
GList** l_billterms_needing_parents)
{
const GncGUID* guid;
GncBillTerm* pBillTerm;
g_return_val_if_fail (be != NULL, NULL);
g_return_val_if_fail (row != NULL, NULL);
guid = gnc_sql_load_guid (be, row);
pBillTerm = gncBillTermLookup (be->book, guid);
if (pBillTerm == NULL)
{
pBillTerm = gncBillTermCreate (be->book);
}
gnc_sql_load_object (be, row, GNC_ID_BILLTERM, pBillTerm, col_table);
/* If the billterm doesn't have a parent, it might be because it hasn't been loaded yet.
If so, add this billterm to the list of billterms with no parent, along with the parent
GncGUID so that after they are all loaded, the parents can be fixed up. */
if (gncBillTermGetParent (pBillTerm) == NULL)
{
billterm_parent_guid_struct* s = static_cast<decltype (s)> (
g_malloc (sizeof (billterm_parent_guid_struct)));
g_assert (s != NULL);
s->billterm = pBillTerm;
s->have_guid = FALSE;
gnc_sql_load_object (be, row, GNC_ID_TAXTABLE, s, billterm_parent_col_table);
if (s->have_guid)
{
*l_billterms_needing_parents = g_list_prepend (*l_billterms_needing_parents,
s);
}
else
{
g_free (s);
}
}
qof_instance_mark_clean (QOF_INSTANCE (pBillTerm));
return pBillTerm;
}
/* ================================================================= */
static void
load_billterm_guid (const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row)
{
const GValue* val;
GncGUID guid;
GncBillTerm* term = NULL;
g_return_if_fail (be != NULL);
g_return_if_fail (row != NULL);
g_return_if_fail (pObject != NULL);
g_return_if_fail (table_row != NULL);
val = gnc_sql_row_get_value_at_col_name (row, table_row->col_name);
if (val != NULL && G_VALUE_HOLDS_STRING (val) &&
g_value_get_string (val) != NULL)
{
string_to_guid (g_value_get_string (val), &guid);
term = gncBillTermLookup (be->book, &guid);
if (term != NULL)
{
if (table_row->gobj_param_name != NULL)
{
qof_instance_increase_editlevel (pObject);
g_object_set (pObject, table_row->gobj_param_name, term, NULL);
qof_instance_decrease_editlevel (pObject);
}
else
{
(*setter) (pObject, (const gpointer)term);
}
}
else
{
PWARN ("Billterm ref '%s' not found", g_value_get_string (val));
}
}
}
GncBillTerm *
gnc_billterm_xml_find_or_create(QofBook *book, GncGUID *guid)
{
GncBillTerm *term;
g_return_val_if_fail(book, NULL);
g_return_val_if_fail(guid, NULL);
term = gncBillTermLookup(book, guid);
DEBUG("looking for billterm %s, found %p", guid_to_string(guid), term);
if (!term)
{
term = gncBillTermCreate(book);
gncBillTermBeginEdit(term);
gncBillTermSetGUID(term, guid);
gncBillTermCommitEdit(term);
DEBUG("Created term: %p", term);
}
else
gncBillTermDecRef(term);
return term;
}
static void
bt_set_parent (gpointer data, gpointer value)
{
GncBillTerm* billterm;
GncBillTerm* parent;
QofBook* pBook;
GncGUID* guid = (GncGUID*)value;
g_return_if_fail (data != NULL);
g_return_if_fail (GNC_IS_BILLTERM (data));
billterm = GNC_BILLTERM (data);
pBook = qof_instance_get_book (QOF_INSTANCE (billterm));
if (guid != NULL)
{
parent = gncBillTermLookup (pBook, guid);
if (parent != NULL)
{
gncBillTermSetParent (billterm, parent);
gncBillTermSetChild (parent, billterm);
}
}
}
static gboolean
set_parent_child (xmlNodePtr node, struct billterm_pdata *pdata,
void (*func)(GncBillTerm *, GncBillTerm *))
{
GncGUID *guid;
GncBillTerm *term;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
term = gncBillTermLookup (pdata->book, guid);
if (!term)
{
term = gncBillTermCreate (pdata->book);
gncBillTermBeginEdit (term);
gncBillTermSetGUID (term, guid);
gncBillTermCommitEdit (term);
}
g_free (guid);
g_return_val_if_fail (term, FALSE);
func (pdata->term, term);
return TRUE;
}
