static gboolean
set_parent_child (xmlNodePtr node, struct taxtable_pdata *pdata,
void (*func)(GncTaxTable *, GncTaxTable *))
{
GncGUID *guid;
GncTaxTable *table;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
table = gncTaxTableLookup (pdata->book, guid);
/* Ignore pointers to self */
if (table == pdata->table)
{
PINFO ("found a self-referential parent/child; ignoring.\n");
return TRUE;
}
if (!table)
{
table = gncTaxTableCreate (pdata->book);
gncTaxTableBeginEdit (table);
gncTaxTableSetGUID (table, guid);
gncTaxTableCommitEdit (table);
}
g_free (guid);
g_return_val_if_fail (table, FALSE);
func (pdata->table, table);
return TRUE;
}
static gboolean
taxtable_guid_handler (xmlNodePtr node, gpointer taxtable_pdata)
{
struct taxtable_pdata *pdata = taxtable_pdata;
GncGUID *guid;
GncTaxTable *table;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
table = gncTaxTableLookup (pdata->book, guid);
if (table)
{
gncTaxTableDestroy (pdata->table);
pdata->table = table;
gncTaxTableBeginEdit (table);
}
else
{
gncTaxTableSetGUID(pdata->table, guid);
}
g_free(guid);
return TRUE;
}
/* ================================================================= */
template<> void
GncSqlColumnTableEntryImpl<CT_TAXTABLEREF>::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 gncTaxTableLookup(sql_be->book(), g);
});
}
static void
compare_single_taxtable( QofInstance* inst, gpointer user_data )
{
CompareInfoStruct* info = (CompareInfoStruct*)user_data;
GncTaxTable* tt_1 = GNC_TAXTABLE(inst);
GncTaxTable* tt_2 = gncTaxTableLookup( info->book_2, qof_instance_get_guid(inst) );
if (!gncTaxTableEqual( tt_1, tt_2 ))
{
info->result = FALSE;
}
}
void
GncSqlTaxTableBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
/* First time, create the query */
std::stringstream sql;
sql << "SELECT * FROM " << TT_TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
auto result = sql_be->execute_select_statement(stmt);
TaxTblParentGuidVec tt_needing_parents;
for (auto row : *result)
load_single_taxtable (sql_be, row, tt_needing_parents);
/* While there are items on the list of taxtables 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 (!tt_needing_parents.empty())
{
bool progress_made = true;
std::reverse(tt_needing_parents.begin(),
tt_needing_parents.end());
auto end = tt_needing_parents.end();
while (progress_made)
{
progress_made = false;
end = std::remove_if(tt_needing_parents.begin(), end,
[&](TaxTblParentGuidPtr s)
{
auto pBook = qof_instance_get_book (QOF_INSTANCE (s->tt));
auto parent = gncTaxTableLookup (pBook,
&s->guid);
if (parent != nullptr)
{
tt_set_parent (s->tt, &s->guid);
progress_made = true;
delete s;
return true;
}
return false;
});
}
}
}
static void
load_single_taxtable( GncSqlBackend* be, GncSqlRow* row,
GList** l_tt_needing_parents )
{
const GncGUID* guid;
GncTaxTable* tt;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
guid = gnc_sql_load_guid( be, row );
tt = gncTaxTableLookup( be->book, guid );
if ( tt == NULL )
{
tt = gncTaxTableCreate( be->book );
}
gnc_sql_load_object( be, row, GNC_ID_TAXTABLE, tt, tt_col_table );
gnc_sql_slots_load( be, QOF_INSTANCE(tt) );
load_taxtable_entries( be, tt );
/* If the tax table doesn't have a parent, it might be because it hasn't been loaded yet.
If so, add this tax table to the list of tax tables with no parent, along with the parent
GncGUID so that after they are all loaded, the parents can be fixed up. */
if ( gncTaxTableGetParent( tt ) == NULL )
{
taxtable_parent_guid_struct* s = static_cast<decltype(s)>(
g_malloc(sizeof(taxtable_parent_guid_struct)));
g_assert( s != NULL );
s->tt = tt;
s->have_guid = FALSE;
gnc_sql_load_object( be, row, GNC_ID_TAXTABLE, s, tt_parent_col_table );
if ( s->have_guid )
{
*l_tt_needing_parents = g_list_prepend( *l_tt_needing_parents, s );
}
else
{
g_free( s );
}
}
qof_instance_mark_clean( QOF_INSTANCE(tt) );
}
static void
load_single_taxtable (GncSqlBackend* sql_be, GncSqlRow& row,
TaxTblParentGuidVec& l_tt_needing_parents)
{
const GncGUID* guid;
GncTaxTable* tt;
g_return_if_fail (sql_be != NULL);
guid = gnc_sql_load_guid (sql_be, row);
tt = gncTaxTableLookup (sql_be->book(), guid);
if (tt == nullptr)
{
tt = gncTaxTableCreate (sql_be->book());
}
gnc_sql_load_object (sql_be, row, GNC_ID_TAXTABLE, tt, tt_col_table);
gnc_sql_slots_load (sql_be, QOF_INSTANCE (tt));
load_taxtable_entries (sql_be, tt);
/* If the tax table doesn't have a parent, it might be because it hasn't
been loaded yet. if so, add this tax table to the list of tax tables
with no parent, along with the parent GncGUID so that after they are all
loaded, the parents can be fixed up. */
if (gncTaxTableGetParent (tt) == NULL)
{
TaxTblParentGuid s;
s.tt = tt;
s.have_guid = false;
gnc_sql_load_object (sql_be, row, GNC_ID_TAXTABLE, &s,
tt_parent_col_table);
if (s.have_guid)
l_tt_needing_parents.push_back(new TaxTblParentGuid(s));
}
qof_instance_mark_clean (QOF_INSTANCE (tt));
}
/* ================================================================= */
static void
load_taxtable_guid( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
GncTaxTable* taxtable = 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 );
taxtable = gncTaxTableLookup( be->book, &guid );
if ( taxtable != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
qof_instance_increase_editlevel (pObject);
g_object_set( pObject, table_row->gobj_param_name, taxtable, NULL );
qof_instance_decrease_editlevel (pObject);
}
else
{
(*setter)( pObject, (const gpointer)taxtable );
}
}
else
{
PWARN( "Taxtable ref '%s' not found", g_value_get_string( val ) );
}
}
}
static void
tt_set_parent( gpointer data, gpointer value )
{
GncTaxTable* tt;
GncTaxTable* parent;
QofBook* pBook;
GncGUID* guid = (GncGUID*)value;
g_return_if_fail( data != NULL );
g_return_if_fail( GNC_IS_TAXTABLE(data) );
tt = GNC_TAXTABLE(data);
pBook = qof_instance_get_book( QOF_INSTANCE(tt) );
if ( guid != NULL )
{
parent = gncTaxTableLookup( pBook, guid );
if ( parent != NULL )
{
gncTaxTableSetParent( tt, parent );
gncTaxTableSetChild( parent, tt );
}
}
}
static inline gboolean
set_taxtable (xmlNodePtr node, struct entry_pdata *pdata,
void (*func)(GncEntry *entry, GncTaxTable *taxtable))
{
GncGUID *guid;
GncTaxTable *taxtable;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
taxtable = gncTaxTableLookup (pdata->book, guid);
if (!taxtable)
{
taxtable = gncTaxTableCreate (pdata->book);
gncTaxTableBeginEdit (taxtable);
gncTaxTableSetGUID (taxtable, guid);
gncTaxTableCommitEdit (taxtable);
}
else
gncTaxTableDecRef (taxtable);
func (pdata->entry, taxtable);
g_free(guid);
return TRUE;
}
static gboolean
customer_taxtable_handler (xmlNodePtr node, gpointer cust_pdata)
{
struct customer_pdata *pdata = cust_pdata;
GncGUID *guid;
GncTaxTable *taxtable;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
taxtable = gncTaxTableLookup (pdata->book, guid);
if (!taxtable)
{
taxtable = gncTaxTableCreate (pdata->book);
gncTaxTableBeginEdit (taxtable);
gncTaxTableSetGUID (taxtable, guid);
gncTaxTableCommitEdit (taxtable);
}
else
gncTaxTableDecRef (taxtable);
gncCustomerSetTaxTable (pdata->customer, taxtable);
g_free(guid);
return TRUE;
}
static gboolean
vendor_taxtable_handler (xmlNodePtr node, gpointer vendor_pdata)
{
struct vendor_pdata* pdata = static_cast<decltype (pdata)> (vendor_pdata);
GncGUID* guid;
GncTaxTable* taxtable;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
taxtable = gncTaxTableLookup (pdata->book, guid);
if (!taxtable)
{
taxtable = gncTaxTableCreate (pdata->book);
gncTaxTableBeginEdit (taxtable);
gncTaxTableSetGUID (taxtable, guid);
gncTaxTableCommitEdit (taxtable);
}
else
gncTaxTableDecRef (taxtable);
gncVendorSetTaxTable (pdata->vendor, taxtable);
g_free (guid);
return TRUE;
}