[backend/xml] dom_tree_to_guid returns std::optional<GncGUID> instead of GncGUID*

therefore GncGUID is stack-allocated, removing the need for guid_free

libgnucash/backend/xml/gnc-account-xml-v2.cpp

@@ -197,14 +197,11 @@ static gboolean
 account_id_handler (xmlNodePtr node, gpointer act_pdata)
 {
     struct account_pdata* pdata = static_cast<decltype (pdata)> (act_pdata);
-    GncGUID* guid;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
 
-    xaccAccountSetGUID (pdata->account, guid);
-
-    guid_free (guid);
+    xaccAccountSetGUID (pdata->account, &*guid);
 
     return TRUE;
 }
@@ -367,22 +364,18 @@ account_parent_handler (xmlNodePtr node, gpointer act_pdata)
 {
     struct account_pdata* pdata = static_cast<decltype (pdata)> (act_pdata);
     Account* parent;
-    GncGUID* gid;
 
-    gid = dom_tree_to_guid (node);
+    auto gid = dom_tree_to_guid (node);
     g_return_val_if_fail (gid, FALSE);
 
-    parent = xaccAccountLookup (gid, pdata->book);
+    parent = xaccAccountLookup (&*gid, pdata->book);
     if (!parent)
     {
-        guid_free (gid);
         g_return_val_if_fail (parent, FALSE);
     }
 
     gnc_account_append_child (parent, pdata->account);
 
-    guid_free (gid);
-
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-bill-term-xml-v2.cpp

@@ -257,20 +257,18 @@ 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);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    term = gncBillTermLookup (pdata->book, guid);
+    term = gncBillTermLookup (pdata->book, &*guid);
     if (!term)
     {
         term = gncBillTermCreate (pdata->book);
         gncBillTermBeginEdit (term);
-        gncBillTermSetGUID (term, guid);
+        gncBillTermSetGUID (term, &*guid);
         gncBillTermCommitEdit (term);
     }
-    guid_free (guid);
     g_return_val_if_fail (term, FALSE);
     func (pdata->term, term);
 
@@ -292,12 +290,11 @@ static gboolean
 billterm_guid_handler (xmlNodePtr node, gpointer billterm_pdata)
 {
     struct billterm_pdata* pdata = static_cast<decltype (pdata)> (billterm_pdata);
-    GncGUID* guid;
     GncBillTerm* term;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    term = gncBillTermLookup (pdata->book, guid);
+    term = gncBillTermLookup (pdata->book, &*guid);
     if (term)
     {
         gncBillTermDestroy (pdata->term);
@@ -306,11 +303,9 @@ billterm_guid_handler (xmlNodePtr node, gpointer billterm_pdata)
     }
     else
     {
-        gncBillTermSetGUID (pdata->term, guid);
+        gncBillTermSetGUID (pdata->term, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-book-xml-v2.cpp

@@ -114,11 +114,9 @@ static gboolean
 book_id_handler (xmlNodePtr node, gpointer book_pdata)
 {
     QofBook* book = static_cast<decltype (book)> (book_pdata);
-    GncGUID* guid;
 
-    guid = dom_tree_to_guid (node);
-    qof_instance_set_guid (QOF_INSTANCE (book), guid);
-    guid_free (guid);
+    auto guid = dom_tree_to_guid (node);
+    qof_instance_set_guid (QOF_INSTANCE (book), &*guid);
 
     return TRUE;
 }

libgnucash/backend/xml/gnc-budget-xml-v2.cpp

@@ -100,12 +100,9 @@ set_string (xmlNodePtr node, GncBudget* bgt,
 static gboolean
 budget_id_handler (xmlNodePtr node, gpointer bgt)
 {
-    GncGUID* guid;
-
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    qof_instance_set_guid (QOF_INSTANCE (bgt), guid);
-    guid_free (guid);
+    qof_instance_set_guid (QOF_INSTANCE (bgt), &*guid);
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-customer-xml-v2.cpp

@@ -185,12 +185,11 @@ static gboolean
 customer_guid_handler (xmlNodePtr node, gpointer cust_pdata)
 {
     struct customer_pdata* pdata = static_cast<decltype (pdata)> (cust_pdata);
-    GncGUID* guid;
     GncCustomer* cust;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    cust = gncCustomerLookup (pdata->book, guid);
+    cust = gncCustomerLookup (pdata->book, &*guid);
     if (cust)
     {
         gncCustomerDestroy (pdata->customer);
@@ -199,11 +198,9 @@ customer_guid_handler (xmlNodePtr node, gpointer cust_pdata)
     }
     else
     {
-        gncCustomerSetGUID (pdata->customer, guid);
+        gncCustomerSetGUID (pdata->customer, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 
@@ -227,14 +224,12 @@ static gboolean
 customer_terms_handler (xmlNodePtr node, gpointer cust_pdata)
 {
     struct customer_pdata* pdata = static_cast<decltype (pdata)> (cust_pdata);
-    GncGUID* guid;
     GncBillTerm* term;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    term = gnc_billterm_xml_find_or_create (pdata->book, guid);
+    term = gnc_billterm_xml_find_or_create (pdata->book, &*guid);
     g_assert (term);
-    guid_free (guid);
     gncCustomerSetTerms (pdata->customer, term);
 
     return TRUE;
@@ -321,24 +316,22 @@ static gboolean
 customer_taxtable_handler (xmlNodePtr node, gpointer cust_pdata)
 {
     struct customer_pdata* pdata = static_cast<decltype (pdata)> (cust_pdata);
-    GncGUID* guid;
     GncTaxTable* taxtable;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    taxtable = gncTaxTableLookup (pdata->book, guid);
+    taxtable = gncTaxTableLookup (pdata->book, &*guid);
     if (!taxtable)
     {
         taxtable = gncTaxTableCreate (pdata->book);
         gncTaxTableBeginEdit (taxtable);
-        gncTaxTableSetGUID (taxtable, guid);
+        gncTaxTableSetGUID (taxtable, &*guid);
         gncTaxTableCommitEdit (taxtable);
     }
     else
         gncTaxTableDecRef (taxtable);
 
     gncCustomerSetTaxTable (pdata->customer, taxtable);
-    guid_free (guid);
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-employee-xml-v2.cpp

@@ -155,14 +155,13 @@ static gboolean
 employee_guid_handler (xmlNodePtr node, gpointer employee_pdata)
 {
     struct employee_pdata* pdata = static_cast<decltype (pdata)> (employee_pdata);
-    GncGUID* guid;
     GncEmployee* employee;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
 
     /* See if we've already created this one */
-    employee = gncEmployeeLookup (pdata->book, guid);
+    employee = gncEmployeeLookup (pdata->book, &*guid);
     if (employee)
     {
         gncEmployeeDestroy (pdata->employee);
@@ -171,11 +170,9 @@ employee_guid_handler (xmlNodePtr node, gpointer employee_pdata)
     }
     else
     {
-        gncEmployeeSetGUID (pdata->employee, guid);
+        gncEmployeeSetGUID (pdata->employee, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 
@@ -261,14 +258,12 @@ static gboolean
 employee_ccard_handler (xmlNodePtr node, gpointer employee_pdata)
 {
     struct employee_pdata* pdata = static_cast<decltype (pdata)> (employee_pdata);
-    GncGUID* guid;
     Account* ccard_acc;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
 
-    ccard_acc = xaccAccountLookup (guid, pdata->book);
-    guid_free (guid);
+    ccard_acc = xaccAccountLookup (&*guid, pdata->book);
 
     g_return_val_if_fail (ccard_acc, FALSE);
     gncEmployeeSetCCard (pdata->employee, ccard_acc);

libgnucash/backend/xml/gnc-entry-xml-v2.cpp

@@ -270,13 +270,11 @@ static inline gboolean
 set_account (xmlNodePtr node, struct entry_pdata* pdata,
              void (*func) (GncEntry* entry, Account* acc))
 {
-    GncGUID* guid;
     Account* acc;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    acc = xaccAccountLookup (guid, pdata->book);
-    guid_free (guid);
+    acc = xaccAccountLookup (&*guid, pdata->book);
     g_return_val_if_fail (acc, FALSE);
 
     if (func)
@@ -290,24 +288,22 @@ 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);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    taxtable = gncTaxTableLookup (pdata->book, guid);
+    taxtable = gncTaxTableLookup (pdata->book, &*guid);
     if (!taxtable)
     {
         taxtable = gncTaxTableCreate (pdata->book);
         gncTaxTableBeginEdit (taxtable);
-        gncTaxTableSetGUID (taxtable, guid);
+        gncTaxTableSetGUID (taxtable, &*guid);
         gncTaxTableCommitEdit (taxtable);
     }
     else
         gncTaxTableDecRef (taxtable);
 
     func (pdata->entry, taxtable);
-    guid_free (guid);
     return TRUE;
 }
 
@@ -315,12 +311,11 @@ static gboolean
 entry_guid_handler (xmlNodePtr node, gpointer entry_pdata)
 {
     struct entry_pdata* pdata = static_cast<decltype (pdata)> (entry_pdata);
-    GncGUID* guid;
     GncEntry* entry;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    entry = gncEntryLookup (pdata->book, guid);
+    entry = gncEntryLookup (pdata->book, &*guid);
     if (entry)
     {
         gncEntryDestroy (pdata->entry);
@@ -329,11 +324,9 @@ entry_guid_handler (xmlNodePtr node, gpointer entry_pdata)
     }
     else
     {
-        gncEntrySetGUID (pdata->entry, guid);
+        gncEntrySetGUID (pdata->entry, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 
@@ -555,24 +548,22 @@ static gboolean
 entry_order_handler (xmlNodePtr node, gpointer entry_pdata)
 {
     struct entry_pdata* pdata = static_cast<decltype (pdata)> (entry_pdata);
-    GncGUID* guid;
     GncOrder* order;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    order = gncOrderLookup (pdata->book, guid);
+    order = gncOrderLookup (pdata->book, &*guid);
     if (!order)
     {
         order = gncOrderCreate (pdata->book);
         gncOrderBeginEdit (order);
-        gncOrderSetGUID (order, guid);
+        gncOrderSetGUID (order, &*guid);
         gncOrderCommitEdit (order);
     }
     gncOrderBeginEdit (order);
     gncOrderAddEntry (order, pdata->entry);
     gncOrderCommitEdit (order);
 
-    guid_free (guid);
     return TRUE;
 }
 
@@ -580,24 +571,22 @@ static gboolean
 entry_invoice_handler (xmlNodePtr node, gpointer entry_pdata)
 {
     struct entry_pdata* pdata = static_cast<decltype (pdata)> (entry_pdata);
-    GncGUID* guid;
     GncInvoice* invoice;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    invoice = gncInvoiceLookup (pdata->book, guid);
+    invoice = gncInvoiceLookup (pdata->book, &*guid);
     if (!invoice)
     {
         invoice = gncInvoiceCreate (pdata->book);
         gncInvoiceBeginEdit (invoice);
-        gncInvoiceSetGUID (invoice, guid);
+        gncInvoiceSetGUID (invoice, &*guid);
         gncInvoiceCommitEdit (invoice);
     }
     gncInvoiceBeginEdit (invoice);
     gncInvoiceAddEntry (invoice, pdata->entry);
     gncInvoiceCommitEdit (invoice);
 
-    guid_free (guid);
     return TRUE;
 }
 
@@ -605,24 +594,22 @@ static gboolean
 entry_bill_handler (xmlNodePtr node, gpointer entry_pdata)
 {
     struct entry_pdata* pdata = static_cast<decltype (pdata)> (entry_pdata);
-    GncGUID* guid;
     GncInvoice* invoice;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    invoice = gncInvoiceLookup (pdata->book, guid);
+    invoice = gncInvoiceLookup (pdata->book, &*guid);
     if (!invoice)
     {
         invoice = gncInvoiceCreate (pdata->book);
         gncInvoiceBeginEdit (invoice);
-        gncInvoiceSetGUID (invoice, guid);
+        gncInvoiceSetGUID (invoice, &*guid);
         gncInvoiceCommitEdit (invoice);
     }
     gncInvoiceBeginEdit (invoice);
     gncBillAddEntry (invoice, pdata->entry);
     gncInvoiceCommitEdit (invoice);
 
-    guid_free (guid);
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-invoice-xml-v2.cpp

@@ -194,12 +194,11 @@ static gboolean
 invoice_guid_handler (xmlNodePtr node, gpointer invoice_pdata)
 {
     struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
-    GncGUID* guid;
     GncInvoice* invoice;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    invoice = gncInvoiceLookup (pdata->book, guid);
+    invoice = gncInvoiceLookup (pdata->book, &*guid);
     if (invoice)
     {
         gncInvoiceDestroy (pdata->invoice);
@@ -208,11 +207,9 @@ invoice_guid_handler (xmlNodePtr node, gpointer invoice_pdata)
     }
     else
     {
-        gncInvoiceSetGUID (pdata->invoice, guid);
+        gncInvoiceSetGUID (pdata->invoice, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 
@@ -286,14 +283,12 @@ static gboolean
 invoice_terms_handler (xmlNodePtr node, gpointer invoice_pdata)
 {
     struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
-    GncGUID* guid;
     GncBillTerm* term;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    term = gnc_billterm_xml_find_or_create (pdata->book, guid);
+    term = gnc_billterm_xml_find_or_create (pdata->book, &*guid);
     g_assert (term);
-    guid_free (guid);
     gncInvoiceSetTerms (pdata->invoice, term);
 
     return TRUE;
@@ -303,13 +298,11 @@ static gboolean
 invoice_posttxn_handler (xmlNodePtr node, gpointer invoice_pdata)
 {
     struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
-    GncGUID* guid;
     Transaction* txn;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    txn = xaccTransLookup (guid, pdata->book);
-    guid_free (guid);
+    txn = xaccTransLookup (&*guid, pdata->book);
     g_return_val_if_fail (txn, FALSE);
 
     gncInvoiceSetPostedTxn (pdata->invoice, txn);
@@ -320,13 +313,11 @@ static gboolean
 invoice_postlot_handler (xmlNodePtr node, gpointer invoice_pdata)
 {
     struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
-    GncGUID* guid;
     GNCLot* lot;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    lot = gnc_lot_lookup (guid, pdata->book);
-    guid_free (guid);
+    lot = gnc_lot_lookup (&*guid, pdata->book);
     g_return_val_if_fail (lot, FALSE);
 
     gncInvoiceSetPostedLot (pdata->invoice, lot);
@@ -337,13 +328,11 @@ static gboolean
 invoice_postacc_handler (xmlNodePtr node, gpointer invoice_pdata)
 {
     struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
-    GncGUID* guid;
     Account* acc;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    acc = xaccAccountLookup (guid, pdata->book);
-    guid_free (guid);
+    acc = xaccAccountLookup (&*guid, pdata->book);
     g_return_val_if_fail (acc, FALSE);
 
     gncInvoiceSetPostedAcc (pdata->invoice, acc);

libgnucash/backend/xml/gnc-job-xml-v2.cpp

@@ -126,12 +126,11 @@ static gboolean
 job_guid_handler (xmlNodePtr node, gpointer job_pdata)
 {
     struct job_pdata* pdata = static_cast<decltype (pdata)> (job_pdata);
-    GncGUID* guid;
     GncJob* job;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    job = gncJobLookup (pdata->book, guid);
+    job = gncJobLookup (pdata->book, &*guid);
     if (job)
     {
         gncJobDestroy (pdata->job);
@@ -140,11 +139,9 @@ job_guid_handler (xmlNodePtr node, gpointer job_pdata)
     }
     else
     {
-        gncJobSetGUID (pdata->job, guid);
+        gncJobSetGUID (pdata->job, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-lot-xml-v2.cpp

@@ -82,14 +82,11 @@ static gboolean
 lot_id_handler (xmlNodePtr node, gpointer p)
 {
     struct lot_pdata* pdata = static_cast<decltype (pdata)> (p);
-    GncGUID* guid;
 
     ENTER ("(lot=%p)", pdata->lot);
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     gnc_lot_set_guid (pdata->lot, *guid);
 
-    guid_free (guid);
-
     LEAVE ("");
     return TRUE;
 }

libgnucash/backend/xml/gnc-order-xml-v2.cpp

@@ -141,12 +141,11 @@ static gboolean
 order_guid_handler (xmlNodePtr node, gpointer order_pdata)
 {
     struct order_pdata* pdata = static_cast<decltype (pdata)> (order_pdata);
-    GncGUID* guid;
     GncOrder* order;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    order = gncOrderLookup (pdata->book, guid);
+    order = gncOrderLookup (pdata->book, &*guid);
     if (order)
     {
         gncOrderDestroy (pdata->order);
@@ -155,11 +154,9 @@ order_guid_handler (xmlNodePtr node, gpointer order_pdata)
     }
     else
     {
-        gncOrderSetGUID (pdata->order, guid);
+        gncOrderSetGUID (pdata->order, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-owner-xml-v2.cpp

@@ -126,64 +126,61 @@ static gboolean
 owner_id_handler (xmlNodePtr node, gpointer owner_pdata)
 {
     struct owner_pdata* pdata = static_cast<decltype (pdata)> (owner_pdata);
-    GncGUID* guid;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
 
     switch (gncOwnerGetType (pdata->owner))
     {
     case GNC_OWNER_CUSTOMER:
     {
-        GncCustomer* cust = gncCustomerLookup (pdata->book, guid);
+        GncCustomer* cust = gncCustomerLookup (pdata->book, &*guid);
         if (!cust)
         {
             cust = gncCustomerCreate (pdata->book);
-            gncCustomerSetGUID (cust, guid);
+            gncCustomerSetGUID (cust, &*guid);
         }
         gncOwnerInitCustomer (pdata->owner, cust);
         break;
     }
     case GNC_OWNER_JOB:
     {
-        GncJob* job = gncJobLookup (pdata->book, guid);
+        GncJob* job = gncJobLookup (pdata->book, &*guid);
         if (!job)
         {
             job = gncJobCreate (pdata->book);
-            gncJobSetGUID (job, guid);
+            gncJobSetGUID (job, &*guid);
         }
         gncOwnerInitJob (pdata->owner, job);
         break;
     }
     case GNC_OWNER_VENDOR:
     {
-        GncVendor* vendor = gncVendorLookup (pdata->book, guid);
+        GncVendor* vendor = gncVendorLookup (pdata->book, &*guid);
         if (!vendor)
         {
             vendor = gncVendorCreate (pdata->book);
-            gncVendorSetGUID (vendor, guid);
+            gncVendorSetGUID (vendor, &*guid);
         }
         gncOwnerInitVendor (pdata->owner, vendor);
         break;
     }
     case GNC_OWNER_EMPLOYEE:
     {
-        GncEmployee* employee = gncEmployeeLookup (pdata->book, guid);
+        GncEmployee* employee = gncEmployeeLookup (pdata->book, &*guid);
         if (!employee)
         {
             employee = gncEmployeeCreate (pdata->book);
-            gncEmployeeSetGUID (employee, guid);
+            gncEmployeeSetGUID (employee, &*guid);
         }
         gncOwnerInitEmployee (pdata->owner, employee);
         break;
     }
     default:
         PWARN ("Invalid owner type: %d\n", gncOwnerGetType (pdata->owner));
-        guid_free (guid);
         return FALSE;
     }
 
-    guid_free (guid);
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-pricedb-xml-v2.cpp

@@ -91,10 +91,9 @@ price_parse_xml_sub_node (GNCPrice* p, xmlNodePtr sub_node, QofBook* book)
     gnc_price_begin_edit (p);
     if (g_strcmp0 ("price:id", (char*)sub_node->name) == 0)
     {
-        GncGUID* c = dom_tree_to_guid (sub_node);
+        auto c = dom_tree_to_guid (sub_node);
         if (!c) return FALSE;
-        gnc_price_set_guid (p, c);
-        guid_free (c);
+        gnc_price_set_guid (p, &*c);
     }
     else if (g_strcmp0 ("price:commodity", (char*)sub_node->name) == 0)
     {

libgnucash/backend/xml/gnc-schedxaction-xml-v2.cpp

@@ -210,11 +210,10 @@ sx_id_handler (xmlNodePtr node, gpointer sx_pdata)
 {
     struct sx_pdata* pdata = static_cast<decltype (pdata)> (sx_pdata);
     SchedXaction* sx = pdata->sx;
-    GncGUID*        tmp = dom_tree_to_guid (node);
+    auto tmp = dom_tree_to_guid (node);
 
     g_return_val_if_fail (tmp, FALSE);
-    xaccSchedXactionSetGUID (sx, tmp);
-    guid_free (tmp);
+    xaccSchedXactionSetGUID (sx, &*tmp);
 
     return TRUE;
 }
@@ -584,7 +583,7 @@ sx_templ_acct_handler (xmlNodePtr node, gpointer sx_pdata)
 {
     struct sx_pdata* pdata = static_cast<decltype (pdata)> (sx_pdata);
     SchedXaction* sx = pdata->sx;
-    GncGUID* templ_acct_guid = dom_tree_to_guid (node);
+    auto templ_acct_guid = dom_tree_to_guid (node);
     Account* account;
 
     if (!templ_acct_guid)
@@ -592,9 +591,8 @@ sx_templ_acct_handler (xmlNodePtr node, gpointer sx_pdata)
         return FALSE;
     }
 
-    account = xaccAccountLookup (templ_acct_guid, pdata->book);
+    account = xaccAccountLookup (&*templ_acct_guid, pdata->book);
     sx_set_template_account (sx, account);
-    guid_free (templ_acct_guid);
 
     return TRUE;
 }

libgnucash/backend/xml/gnc-tax-table-xml-v2.cpp

@@ -146,13 +146,11 @@ static gboolean
 ttentry_acct_handler (xmlNodePtr node, gpointer ttentry_pdata)
 {
     struct ttentry_pdata* pdata = static_cast<decltype (pdata)> (ttentry_pdata);
-    GncGUID* guid;
     Account* acc;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    acc = xaccAccountLookup (guid, pdata->book);
-    guid_free (guid);
+    acc = xaccAccountLookup (&*guid, pdata->book);
     g_return_val_if_fail (acc, FALSE);
 
     gncTaxTableEntrySetAccount (pdata->ttentry, acc);
@@ -230,12 +228,11 @@ 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);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    table = gncTaxTableLookup (pdata->book, guid);
+    table = gncTaxTableLookup (pdata->book, &*guid);
 
     /* Ignore pointers to self */
     if (table == pdata->table)
@@ -248,10 +245,9 @@ set_parent_child (xmlNodePtr node, struct taxtable_pdata* pdata,
     {
         table = gncTaxTableCreate (pdata->book);
         gncTaxTableBeginEdit (table);
-        gncTaxTableSetGUID (table, guid);
+        gncTaxTableSetGUID (table, &*guid);
         gncTaxTableCommitEdit (table);
     }
-    guid_free (guid);
     g_return_val_if_fail (table, FALSE);
     func (pdata->table, table);
 
@@ -262,12 +258,11 @@ static gboolean
 taxtable_guid_handler (xmlNodePtr node, gpointer taxtable_pdata)
 {
     struct taxtable_pdata* pdata = static_cast<decltype (pdata)> (taxtable_pdata);
-    GncGUID* guid;
     GncTaxTable* table;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    table = gncTaxTableLookup (pdata->book, guid);
+    table = gncTaxTableLookup (pdata->book, &*guid);
     if (table)
     {
         gncTaxTableDestroy (pdata->table);
@@ -276,11 +271,9 @@ taxtable_guid_handler (xmlNodePtr node, gpointer taxtable_pdata)
     }
     else
     {
-        gncTaxTableSetGUID (pdata->table, guid);
+        gncTaxTableSetGUID (pdata->table, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 

libgnucash/backend/xml/gnc-transaction-xml-v2.cpp

@@ -225,12 +225,11 @@ static gboolean
 spl_id_handler (xmlNodePtr node, gpointer data)
 {
     struct split_pdata* pdata = static_cast<decltype (pdata)> (data);
-    GncGUID* tmp = dom_tree_to_guid (node);
+    auto tmp = dom_tree_to_guid (node);
     g_return_val_if_fail (tmp, FALSE);
 
-    xaccSplitSetGUID (pdata->split, tmp);
+    xaccSplitSetGUID (pdata->split, &*tmp);
 
-    guid_free (tmp);
     return TRUE;
 }
 
@@ -292,25 +291,23 @@ static gboolean
 spl_account_handler (xmlNodePtr node, gpointer data)
 {
     struct split_pdata* pdata = static_cast<decltype (pdata)> (data);
-    GncGUID* id = dom_tree_to_guid (node);
+    auto id = dom_tree_to_guid (node);
     Account* account;
 
     g_return_val_if_fail (id, FALSE);
 
-    account = xaccAccountLookup (id, pdata->book);
+    account = xaccAccountLookup (&*id, pdata->book);
     if (!account && gnc_transaction_xml_v2_testing &&
-        !guid_equal (id, guid_null ()))
+        !guid_equal (&*id, guid_null ()))
     {
         account = xaccMallocAccount (pdata->book);
-        xaccAccountSetGUID (account, id);
+        xaccAccountSetGUID (account, &*id);
         xaccAccountSetCommoditySCU (account,
                                     xaccSplitGetAmount (pdata->split).denom);
     }
 
     xaccAccountInsertSplit (account, pdata->split);
 
-    guid_free (id);
-
     return TRUE;
 }
 
@@ -318,14 +315,14 @@ static gboolean
 spl_lot_handler (xmlNodePtr node, gpointer data)
 {
     struct split_pdata* pdata = static_cast<decltype (pdata)> (data);
-    GncGUID* id = dom_tree_to_guid (node);
+    auto id = dom_tree_to_guid (node);
     GNCLot* lot;
 
     g_return_val_if_fail (id, FALSE);
 
-    lot = gnc_lot_lookup (id, pdata->book);
+    lot = gnc_lot_lookup (&*id, pdata->book);
     if (!lot && gnc_transaction_xml_v2_testing &&
-        !guid_equal (id, guid_null ()))
+        !guid_equal (&*id, guid_null ()))
     {
         lot = gnc_lot_new (pdata->book);
         gnc_lot_set_guid (lot, *id);
@@ -333,8 +330,6 @@ spl_lot_handler (xmlNodePtr node, gpointer data)
 
     gnc_lot_add_split (lot, pdata->split);
 
-    guid_free (id);
-
     return TRUE;
 }
 
@@ -432,13 +427,11 @@ trn_id_handler (xmlNodePtr node, gpointer trans_pdata)
 {
     struct trans_pdata* pdata = static_cast<decltype (pdata)> (trans_pdata);
     Transaction* trn = pdata->trans;
-    GncGUID* tmp = dom_tree_to_guid (node);
+    auto tmp = dom_tree_to_guid (node);
 
     g_return_val_if_fail (tmp, FALSE);
 
-    xaccTransSetGUID ((Transaction*)trn, tmp);
-
-    guid_free (tmp);
+    xaccTransSetGUID ((Transaction*)trn, &*tmp);
 
     return TRUE;
 }

libgnucash/backend/xml/gnc-vendor-xml-v2.cpp

@@ -170,12 +170,11 @@ static gboolean
 vendor_guid_handler (xmlNodePtr node, gpointer vendor_pdata)
 {
     struct vendor_pdata* pdata = static_cast<decltype (pdata)> (vendor_pdata);
-    GncGUID* guid;
     GncVendor* vendor;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    vendor = gncVendorLookup (pdata->book, guid);
+    vendor = gncVendorLookup (pdata->book, &*guid);
     if (vendor)
     {
         gncVendorDestroy (pdata->vendor);
@@ -184,11 +183,9 @@ vendor_guid_handler (xmlNodePtr node, gpointer vendor_pdata)
     }
     else
     {
-        gncVendorSetGUID (pdata->vendor, guid);
+        gncVendorSetGUID (pdata->vendor, &*guid);
     }
 
-    guid_free (guid);
-
     return TRUE;
 }
 
@@ -212,14 +209,12 @@ static gboolean
 vendor_terms_handler (xmlNodePtr node, gpointer vendor_pdata)
 {
     struct vendor_pdata* pdata = static_cast<decltype (pdata)> (vendor_pdata);
-    GncGUID* guid;
     GncBillTerm* term;
 
-    guid = dom_tree_to_guid (node);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    term = gnc_billterm_xml_find_or_create (pdata->book, guid);
+    term = gnc_billterm_xml_find_or_create (pdata->book, &*guid);
     g_assert (term);
-    guid_free (guid);
     gncVendorSetTerms (pdata->vendor, term);
 
     return TRUE;
@@ -278,24 +273,22 @@ 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);
+    auto guid = dom_tree_to_guid (node);
     g_return_val_if_fail (guid, FALSE);
-    taxtable = gncTaxTableLookup (pdata->book, guid);
+    taxtable = gncTaxTableLookup (pdata->book, &*guid);
     if (!taxtable)
     {
         taxtable = gncTaxTableCreate (pdata->book);
         gncTaxTableBeginEdit (taxtable);
-        gncTaxTableSetGUID (taxtable, guid);
+        gncTaxTableSetGUID (taxtable, &*guid);
         gncTaxTableCommitEdit (taxtable);
     }
     else
         gncTaxTableDecRef (taxtable);
 
     gncVendorSetTaxTable (pdata->vendor, taxtable);
-    guid_free (guid);
     return TRUE;
 }
 

libgnucash/backend/xml/io-gncxml-v1.cpp

@@ -2935,10 +2935,9 @@ price_parse_xml_sub_node (GNCPrice* p, xmlNodePtr sub_node, QofBook* book)
 
     if (g_strcmp0 ("price:id", (char*)sub_node->name) == 0)
     {
-        GncGUID* c = dom_tree_to_guid (sub_node);
+        auto c = dom_tree_to_guid (sub_node);
         if (!c) return FALSE;
-        gnc_price_set_guid (p, c);
-        guid_free (c);
+        gnc_price_set_guid (p, &*c);
     }
     else if (g_strcmp0 ("price:commodity", (char*)sub_node->name) == 0)
     {

libgnucash/backend/xml/sixtp-dom-parsers.cpp

@@ -35,12 +35,12 @@
 
 static QofLogModule log_module = GNC_MOD_IO;
 
-GncGUID*
+std::optional<GncGUID>
 dom_tree_to_guid (xmlNodePtr node)
 {
     if (!node->properties)
     {
-        return NULL;
+        return {};
     }
 
     if (strcmp ((char*) node->properties->name, "type") != 0)
@@ -48,7 +48,7 @@ dom_tree_to_guid (xmlNodePtr node)
         PERR ("Unknown attribute for id tag: %s",
               node->properties->name ?
               (char*) node->properties->name : "(null)");
-        return NULL;
+        return {};
     }
 
     {
@@ -59,11 +59,11 @@ dom_tree_to_guid (xmlNodePtr node)
         /* handle new and guid the same for the moment */
         if ((g_strcmp0 ("guid", type) == 0) || (g_strcmp0 ("new", type) == 0))
         {
-            auto gid = guid_new ();
+            GncGUID gid;
             char* guid_str;
 
             guid_str = (char*)xmlNodeGetContent (node->xmlChildrenNode);
-            string_to_guid (guid_str, gid);
+            string_to_guid (guid_str, &gid);
             xmlFree (guid_str);
             xmlFree (type);
             return gid;
@@ -75,7 +75,7 @@ dom_tree_to_guid (xmlNodePtr node)
                   node->properties->name ?
                   (char*) node->properties->name : "(null)");
             xmlFree (type);
-            return NULL;
+            return {};
         }
     }
 }
@@ -195,13 +195,12 @@ dom_tree_to_string_kvp_value (xmlNodePtr node)
 static KvpValue*
 dom_tree_to_guid_kvp_value (xmlNodePtr node)
 {
-    GncGUID* daguid;
     KvpValue* ret = NULL;
 
-    daguid = dom_tree_to_guid (node);
+    auto daguid = dom_tree_to_guid (node);
     if (daguid)
     {
-        ret = new KvpValue {daguid};
+        ret = new KvpValue {guid_copy (&*daguid)};
     }
 
     return ret;

libgnucash/backend/xml/sixtp-dom-parsers.h

@@ -28,10 +28,11 @@
 #include "gnc-commodity.h"
 #include "qof.h"
 #include "gnc-budget.h"
+#include <optional>
 
 #include "gnc-xml-helper.h"
 
-GncGUID* dom_tree_to_guid (xmlNodePtr node);
+std::optional<GncGUID> dom_tree_to_guid (xmlNodePtr node);
 
 gnc_commodity* dom_tree_to_commodity_ref (xmlNodePtr node, QofBook* book);
 gnc_commodity* dom_tree_to_commodity_ref_no_engine (xmlNodePtr node, QofBook*);

libgnucash/backend/xml/test/test-dom-converters1.cpp

@@ -219,7 +219,6 @@ test_dom_tree_to_guid (void)
     for (i = 0; i < 20; i++)
     {
         GncGUID* test_guid1;
-        GncGUID* test_guid2;
         xmlNodePtr test_node;
 
         test_guid1 = get_random_guid ();
@@ -230,14 +229,13 @@ test_dom_tree_to_guid (void)
                           "conversion to dom tree failed");
         }
 
-        test_guid2 = dom_tree_to_guid (test_node);
+        auto test_guid2 = dom_tree_to_guid (test_node);
 
-        do_test (guid_equal (test_guid1, test_guid2),
+        do_test (guid_equal (test_guid1, &*test_guid2),
                  "dom_tree_to_guid");
 
         xmlFreeNode (test_node);
         guid_free (test_guid1);
-        guid_free (test_guid2);
     }
 }
 

libgnucash/backend/xml/test/test-file-stuff.cpp

@@ -196,23 +196,19 @@ equals_node_val_vs_boolean (xmlNodePtr node, gboolean val)
 gboolean
 equals_node_val_vs_guid (xmlNodePtr node, const GncGUID* id)
 {
-    GncGUID* cmpid;
-
     g_return_val_if_fail (node, FALSE);
     g_return_val_if_fail (id, FALSE);
 
-    cmpid = dom_tree_to_guid (node);
+    auto cmpid = dom_tree_to_guid (node);
 
     g_return_val_if_fail (cmpid, FALSE);
 
-    if (guid_compare (cmpid, id) == 0)
+    if (guid_compare (&*cmpid, id) == 0)
     {
-        guid_free (cmpid);
         return TRUE;
     }
     else
     {
-        guid_free (cmpid);
         return FALSE;
     }
 }

libgnucash/backend/xml/test/test-xml-transaction.cpp

@@ -79,14 +79,13 @@ find_appropriate_node (xmlNodePtr node, Split* spl)
             }
             else if (g_strcmp0 ((char*)mark2->name, "split:account") == 0)
             {
-                GncGUID* accid = dom_tree_to_guid (mark2);
+                auto accid = dom_tree_to_guid (mark2);
                 Account* account = xaccSplitGetAccount (spl);
 
-                if (guid_equal (accid, xaccAccountGetGUID (account)))
+                if (guid_equal (&*accid, xaccAccountGetGUID (account)))
                 {
                     account_guid_good = TRUE;
                 }
-                guid_free (accid);
             }
 
             if (account_guid_good && amount_good)
@@ -108,14 +107,12 @@ equals_node_val_vs_split_internal (xmlNodePtr node, Split* spl)
     {
         if (g_strcmp0 ((char*)mark->name, "split:id") == 0)
         {
-            GncGUID* id = dom_tree_to_guid (mark);
+            auto id = dom_tree_to_guid (mark);
 
-            if (!guid_equal (id, xaccSplitGetGUID (spl)))
+            if (!guid_equal (&*id, xaccSplitGetGUID (spl)))
             {
-                guid_free (id);
                 return "ids differ";
             }
-            guid_free (id);
         }
         else if (g_strcmp0 ((char*)mark->name, "split:memo") == 0)
         {
@@ -178,15 +175,13 @@ equals_node_val_vs_split_internal (xmlNodePtr node, Split* spl)
         }
         else if (g_strcmp0 ((char*)mark->name, "split:account") == 0)
         {
-            GncGUID* id = dom_tree_to_guid (mark);
+            auto id = dom_tree_to_guid (mark);
             Account* account = xaccSplitGetAccount (spl);
 
-            if (!guid_equal (id, xaccAccountGetGUID (account)))
+            if (!guid_equal (&*id, xaccAccountGetGUID (account)))
             {
-                guid_free (id);
                 return "accounts differ";
             }
-            guid_free (id);
         }
     }
     return NULL;