Define an object to track tax properties for invoices. More...

Files
file	gncTaxTable.h
	Tax Table programming interface.

Data Structures
struct	GncAccountValue

struct	GncTaxTable
	modtime is the internal date of the last modtime See libgnucash/engine/TaxTableBillTermImmutability.txt for an explanation of the following Code that handles refcount, parent, child, invisible and children is identical to that in ::GncBillTerm More...

struct	GncTaxTableEntry

Macros
#define	GNC_ID_TAXTABLE "gncTaxTable"

#define	GNC_TYPE_TAXTABLE (gnc_taxtable_get_type ())

#define	GNC_TAXTABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_TAXTABLE, GncTaxTable))

#define	GNC_TAXTABLE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_TAXTABLE, GncTaxTableClass))

#define	GNC_IS_TAXTABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_TAXTABLE))

#define	GNC_IS_TAXTABLE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_TAXTABLE))

#define	GNC_TAXTABLE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_TAXTABLE, GncTaxTableClass))

#define	GNC_TT_NAME "tax table name"
	QOF parameter definitions.

#define	GNC_TT_REFCOUNT "reference count"

#define	gncTaxTableGetGUID(x) qof_instance_get_guid(QOF_INSTANCE(x))

#define	gncTaxTableRetGUID(x) (x ? (qof_instance_get_guid(QOF_INSTANCE(x))) : (guid_null()))

#define	gncTaxTableLookupDirect(G, B) gncTaxTableLookup((B), &(G))

Enumerations
enum	GncAmountType { GNC_AMT_TYPE_VALUE = 1 , GNC_AMT_TYPE_PERCENT }
	How to interpret the amount. More...

enum	GncTaxIncluded { GNC_TAXINCLUDED_YES = 1 , GNC_TAXINCLUDED_NO , GNC_TAXINCLUDED_USEGLOBAL }
	How to interpret the TaxIncluded. More...

Functions
GType	gnc_taxtable_get_type (void)

const char *	gncAmountTypeToString (GncAmountType type)

gboolean	gncAmountStringToType (const char str, GncAmountType type)

const char *	gncTaxIncludedTypeToString (GncTaxIncluded type)

gboolean	gncTaxIncludedStringToType (const char str, GncTaxIncluded type)

void	gncTaxTableAddEntry (GncTaxTable table, GncTaxTableEntry entry)

void	gncTaxTableRemoveEntry (GncTaxTable table, GncTaxTableEntry entry)

void	gncTaxTableChanged (GncTaxTable *table)

void	gncTaxTableBeginEdit (GncTaxTable *table)

void	gncTaxTableCommitEdit (GncTaxTable *table)

gboolean	gncTaxTableEqual (const GncTaxTable a, const GncTaxTable b)

int	gncTaxTableCompare (const GncTaxTable a, const GncTaxTable b)

int	gncTaxTableEntryCompare (const GncTaxTableEntry a, const GncTaxTableEntry b)

gboolean	gncTaxTableEntryEqual (const GncTaxTableEntry a, const GncTaxTableEntry b)

GList *	gncAccountValueAdd (GList list, Account acc, gnc_numeric value)
	This will add value to the account-value for acc, creating a new list object if necessary.

GList *	gncAccountValueAddList (GList l1, GList l2)
	Merge l2 into l1.

gnc_numeric	gncAccountValueTotal (GList *list)
	return the total for this list

void	gncAccountValueDestroy (GList *list)
	Destroy a list of accountvalues.

Get Functions
typedef GList	GncTaxTableList

typedef GList	GncTaxTableEntryList

GncTaxTable *	gncTaxTableLookupByName (QofBook book, const char name)

GncTaxTable *	gncTaxTableGetDefault (QofBook *book, GncOwnerType type)

GncTaxTableList *	gncTaxTableGetTables (QofBook *book)

const char *	gncTaxTableGetName (const GncTaxTable *table)

GncTaxTable *	gncTaxTableGetParent (const GncTaxTable *table)

GncTaxTable *	gncTaxTableReturnChild (GncTaxTable *table, gboolean make_new)

GncTaxTableEntryList *	gncTaxTableGetEntries (const GncTaxTable *table)

gint64	gncTaxTableGetRefcount (const GncTaxTable *table)

time64	gncTaxTableLastModifiedSecs (const GncTaxTable *table)

Account *	gncTaxTableEntryGetAccount (const GncTaxTableEntry *entry)

GncAmountType	gncTaxTableEntryGetType (const GncTaxTableEntry *entry)

gnc_numeric	gncTaxTableEntryGetAmount (const GncTaxTableEntry *entry)

#define	gncTaxTableGetChild(t) gncTaxTableReturnChild((t),FALSE)

Create/Destroy Functions
GncTaxTable *	gncTaxTableCreate (QofBook *book)

void	gncTaxTableDestroy (GncTaxTable *table)

GncTaxTableEntry *	gncTaxTableEntryCreate (void)

void	gncTaxTableEntryDestroy (GncTaxTableEntry *entry)

Set Functions
void	gncTaxTableSetName (GncTaxTable table, const char name)

void	gncTaxTableIncRef (GncTaxTable *table)

void	gncTaxTableDecRef (GncTaxTable *table)

void	gncTaxTableEntrySetAccount (GncTaxTableEntry entry, Account account)

void	gncTaxTableEntrySetType (GncTaxTableEntry *entry, GncAmountType type)

void	gncTaxTableEntrySetAmount (GncTaxTableEntry *entry, gnc_numeric amount)

Detailed Description

Define an object to track tax properties for invoices.

Note: A tax table added to an invoice is immutable, that is it can't change any more. To achieve that a tax table is copied when added to an invoice. This uses some internal fields to track this which are explained in Some notes on tracking fields in gncBillTerm and gncTaxTable objects.

Macro Definition Documentation

◆ GNC_ID_TAXTABLE

#define GNC_ID_TAXTABLE "gncTaxTable"

Definition at line 101 of file gncTaxTable.h.

◆ GNC_IS_TAXTABLE

#define GNC_IS_TAXTABLE ( o ) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_TAXTABLE))

Definition at line 109 of file gncTaxTable.h.

{
    QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_TAXTABLE, GncTaxTable);
}
 
GncTaxTable *gncTaxTableLookupByName (QofBook *book, const char *name);
GncTaxTable *gncTaxTableGetDefault (QofBook *book, GncOwnerType type);
 
typedef GList GncTaxTableList;
GncTaxTableList  * gncTaxTableGetTables (QofBook *book);
 
const char *gncTaxTableGetName (const GncTaxTable *table);
GncTaxTable *gncTaxTableGetParent (const GncTaxTable *table);
GncTaxTable *gncTaxTableReturnChild (GncTaxTable *table, gboolean make_new);
#define gncTaxTableGetChild(t) gncTaxTableReturnChild((t),FALSE)
typedef GList GncTaxTableEntryList;
GncTaxTableEntryList* gncTaxTableGetEntries (const GncTaxTable *table);
gint64 gncTaxTableGetRefcount (const GncTaxTable *table);
time64 gncTaxTableLastModifiedSecs (const GncTaxTable *table);
 
Account * gncTaxTableEntryGetAccount (const GncTaxTableEntry *entry);
GncAmountType gncTaxTableEntryGetType (const GncTaxTableEntry *entry);
gnc_numeric gncTaxTableEntryGetAmount (const GncTaxTableEntry *entry);
int gncTaxTableCompare (const GncTaxTable *a, const GncTaxTable *b);
int gncTaxTableEntryCompare (const GncTaxTableEntry *a, const GncTaxTableEntry *b);
gboolean gncTaxTableEntryEqual(const GncTaxTableEntry *a, const GncTaxTableEntry *b);
 
/************************************************/
 
struct _gncAccountValue
{
    Account *   account;
    gnc_numeric value;
};
 
GList *gncAccountValueAdd (GList *list, Account *acc, gnc_numeric value);
 
GList *gncAccountValueAddList (GList *l1, GList *l2);
 
gnc_numeric gncAccountValueTotal (GList *list);
 
void gncAccountValueDestroy (GList *list);
 
#define GNC_TT_NAME "tax table name"
#define GNC_TT_REFCOUNT "reference count"
 
#define gncTaxTableGetGUID(x) qof_instance_get_guid(QOF_INSTANCE(x))
#define gncTaxTableRetGUID(x) (x ? *(qof_instance_get_guid(QOF_INSTANCE(x))) : *(guid_null()))
#define gncTaxTableLookupDirect(G,B) gncTaxTableLookup((B), &(G))
 
#ifdef __cplusplus
}
#endif
 
#endif /* GNC_TAXTABLE_H_ */

◆ GNC_IS_TAXTABLE_CLASS

#define GNC_IS_TAXTABLE_CLASS ( k ) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_TAXTABLE))

Definition at line 111 of file gncTaxTable.h.

◆ GNC_TAXTABLE

#define GNC_TAXTABLE ( o ) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_TAXTABLE, GncTaxTable))

Definition at line 105 of file gncTaxTable.h.

◆ GNC_TAXTABLE_CLASS

#define GNC_TAXTABLE_CLASS ( k ) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_TAXTABLE, GncTaxTableClass))

Definition at line 107 of file gncTaxTable.h.

◆ GNC_TAXTABLE_GET_CLASS

#define GNC_TAXTABLE_GET_CLASS ( o ) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_TAXTABLE, GncTaxTableClass))

Definition at line 113 of file gncTaxTable.h.

◆ GNC_TT_NAME

#define GNC_TT_NAME "tax table name"

QOF parameter definitions.

Definition at line 210 of file gncTaxTable.h.

◆ GNC_TT_REFCOUNT

#define GNC_TT_REFCOUNT "reference count"

Definition at line 211 of file gncTaxTable.h.

◆ GNC_TYPE_TAXTABLE

#define GNC_TYPE_TAXTABLE (gnc_taxtable_get_type ())

Definition at line 104 of file gncTaxTable.h.

◆ gncTaxTableGetChild

#define gncTaxTableGetChild ( t ) gncTaxTableReturnChild((t),FALSE)

Definition at line 171 of file gncTaxTable.h.

◆ gncTaxTableGetGUID

#define gncTaxTableGetGUID ( x ) qof_instance_get_guid(QOF_INSTANCE(x))

Deprecated:: routine

Definition at line 214 of file gncTaxTable.h.

◆ gncTaxTableLookupDirect

#define gncTaxTableLookupDirect	(	G,
		B
	)	gncTaxTableLookup((B), &(G))

Definition at line 216 of file gncTaxTable.h.

◆ gncTaxTableRetGUID

#define gncTaxTableRetGUID ( x ) (x ? *(qof_instance_get_guid(QOF_INSTANCE(x))) : *(guid_null()))

Definition at line 215 of file gncTaxTable.h.

Typedef Documentation

◆ GncTaxTableEntryList

typedef GList GncTaxTableEntryList

Definition at line 172 of file gncTaxTable.h.

◆ GncTaxTableList

typedef GList GncTaxTableList

Definition at line 165 of file gncTaxTable.h.

Enumeration Type Documentation

◆ GncAmountType

enum GncAmountType

How to interpret the amount.

You can interpret it as a VALUE or a PERCENT.

Enumerator
GNC_AMT_TYPE_VALUE	tax is a number
GNC_AMT_TYPE_PERCENT	tax is a percentage

Definition at line 78 of file gncTaxTable.h.

{
    GNC_AMT_TYPE_VALUE = 1,     
    GNC_AMT_TYPE_PERCENT        
} GncAmountType;

◆ GncTaxIncluded

enum GncTaxIncluded

How to interpret the TaxIncluded.

Enumerator
GNC_TAXINCLUDED_YES	tax is included
GNC_TAXINCLUDED_NO	tax is not included
GNC_TAXINCLUDED_USEGLOBAL	use the global setting

Definition at line 85 of file gncTaxTable.h.

{
    GNC_TAXINCLUDED_YES = 1,  
    GNC_TAXINCLUDED_NO,     
    GNC_TAXINCLUDED_USEGLOBAL, 
} GncTaxIncluded;

Function Documentation

◆ gncAccountValueAdd()

GList * gncAccountValueAdd	(	GList *	list,
		Account *	acc,
		gnc_numeric	value
	)

This will add value to the account-value for acc, creating a new list object if necessary.

Definition at line 942 of file gncTaxTable.c.

{
    GList *li;
    GncAccountValue *res = NULL;
 
    g_return_val_if_fail (acc, list);
    g_return_val_if_fail (gnc_numeric_check (value) == GNC_ERROR_OK, list);
 
    /* Try to find the account in the list */
    for (li = list; li; li = li->next)
    {
        res = li->data;
        if (res->account == acc)
        {
            res->value = gnc_numeric_add (res->value, value, GNC_DENOM_AUTO,
                                          GNC_HOW_DENOM_REDUCE | GNC_HOW_RND_ROUND_HALF_UP);
            return list;
        }
    }
    /* Nope, didn't find it. */
 
    res = g_new0 (GncAccountValue, 1);
    res->account = acc;
    res->value = value;
    return g_list_prepend (list, res);
}

◆ gncAccountValueAddList()

GList * gncAccountValueAddList	(	GList *	l1,
		GList *	l2
	)

Merge l2 into l1.

l2 is not touched.

Definition at line 970 of file gncTaxTable.c.

{
    GList *li;
 
    for (li = l2; li; li = li->next )
    {
        GncAccountValue *val = li->data;
        l1 = gncAccountValueAdd (l1, val->account, val->value);
    }
 
    return l1;
}

◆ gncAccountValueDestroy()

void gncAccountValueDestroy ( GList * list )

Destroy a list of accountvalues.

Definition at line 997 of file gncTaxTable.c.

{
    GList *node;
    for ( node = list; node ; node = node->next)
        g_free (node->data);
 
    g_list_free (list);
}

◆ gncAccountValueTotal()

gnc_numeric gncAccountValueTotal ( GList * list )

return the total for this list

Definition at line 984 of file gncTaxTable.c.

{
    gnc_numeric total = gnc_numeric_zero ();
 
    for ( ; list ; list = list->next)
    {
        GncAccountValue *val = list->data;
        total = gnc_numeric_add (total, val->value, GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE | GNC_HOW_RND_ROUND_HALF_UP);
    }
    return total;
}

◆ gncAmountStringToType()

gboolean gncAmountStringToType	(	const char *	str,
		GncAmountType *	type
	)

Definition at line 110 of file gncTaxTable.c.

{
    GNC_RETURN_ON_MATCH ("VALUE", GNC_AMT_TYPE_VALUE);
    GNC_RETURN_ON_MATCH ("PERCENT", GNC_AMT_TYPE_PERCENT);
    g_warning ("asked to translate unknown amount type string %s.\n",
               str ? str : "(null)");
 
    return(FALSE);
}

◆ gncAmountTypeToString()

const char * gncAmountTypeToString ( GncAmountType type )

Definition at line 79 of file gncTaxTable.c.

{
    switch (type)
    {
        GNC_RETURN_ENUM_AS_STRING(GNC_AMT_TYPE_VALUE, "VALUE");
        GNC_RETURN_ENUM_AS_STRING(GNC_AMT_TYPE_PERCENT, "PERCENT");
    default:
        g_warning ("asked to translate unknown amount type %d.\n", type);
        break;
    }
    return(NULL);
}

◆ gncTaxIncludedStringToType()

gboolean gncTaxIncludedStringToType	(	const char *	str,
		GncTaxIncluded *	type
	)

Definition at line 121 of file gncTaxTable.c.

{
    GNC_RETURN_ON_MATCH ("YES", GNC_TAXINCLUDED_YES);
    GNC_RETURN_ON_MATCH ("NO", GNC_TAXINCLUDED_NO);
    GNC_RETURN_ON_MATCH ("USEGLOBAL", GNC_TAXINCLUDED_USEGLOBAL);
    g_warning ("asked to translate unknown taxincluded type string %s.\n",
               str ? str : "(null)");
 
    return(FALSE);
}

◆ gncTaxIncludedTypeToString()

const char * gncTaxIncludedTypeToString ( GncTaxIncluded type )

Definition at line 93 of file gncTaxTable.c.

{
    switch (type)
    {
        GNC_RETURN_ENUM_AS_STRING(GNC_TAXINCLUDED_YES, "YES");
        GNC_RETURN_ENUM_AS_STRING(GNC_TAXINCLUDED_NO, "NO");
        GNC_RETURN_ENUM_AS_STRING(GNC_TAXINCLUDED_USEGLOBAL, "USEGLOBAL");
    default:
        g_warning ("asked to translate unknown taxincluded type %d.\n", type);
        break;
    }
    return(NULL);
}

◆ gncTaxTableAddEntry()

void gncTaxTableAddEntry	(	GncTaxTable *	table,
		GncTaxTableEntry *	entry
	)

Definition at line 594 of file gncTaxTable.c.

{
    if (!table || !entry) return;
    if (entry->table == table) return; /* already mine */
 
    gncTaxTableBeginEdit (table);
    if (entry->table)
        gncTaxTableRemoveEntry (entry->table, entry);
 
    entry->table = table;
    table->entries = g_list_insert_sorted (table->entries, entry,
                                           (GCompareFunc)gncTaxTableEntryCompare);
    mark_table (table);
    mod_table (table);
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableBeginEdit()

void gncTaxTableBeginEdit ( GncTaxTable * table )

Definition at line 632 of file gncTaxTable.c.

{
    qof_begin_edit(&table->inst);
}

◆ gncTaxTableChanged()

void gncTaxTableChanged ( GncTaxTable * table )

Definition at line 622 of file gncTaxTable.c.

{
    if (!table) return;
    gncTaxTableBeginEdit (table);
    table->child = NULL;
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableCommitEdit()

void gncTaxTableCommitEdit ( GncTaxTable * table )

Definition at line 651 of file gncTaxTable.c.

{
    /* GnuCash 2.6.3 and earlier didn't handle taxtable kvp's... */
     if (qof_instance_has_kvp (QOF_INSTANCE (table)))
          gnc_features_set_used (qof_instance_get_book (QOF_INSTANCE (table)),
                                 GNC_FEATURE_KVP_EXTRA_DATA);
 
    if (!qof_commit_edit (QOF_INSTANCE(table))) return;
    qof_commit_edit_part2 (&table->inst, gncTaxTableOnError,
                           gncTaxTableOnDone, table_free);
}

◆ gncTaxTableCompare()

int gncTaxTableCompare	(	const GncTaxTable *	a,
		const GncTaxTable *	b
	)

Definition at line 842 of file gncTaxTable.c.

{
    if (!a && !b) return 0;
    if (!a) return -1;
    if (!b) return 1;
    return g_strcmp0 (a->name, b->name);
}

◆ gncTaxTableCreate()

GncTaxTable * gncTaxTableCreate ( QofBook * book )

Definition at line 406 of file gncTaxTable.c.

{
    GncTaxTable *table;
    if (!book) return NULL;
 
    table = g_object_new (GNC_TYPE_TAXTABLE, NULL);
    qof_instance_init_data (&table->inst, _GNC_MOD_NAME, book);
    table->name = CACHE_INSERT ("");
    addObj (table);
    qof_event_gen (&table->inst, QOF_EVENT_CREATE, NULL);
    return table;
}

◆ gncTaxTableDecRef()

void gncTaxTableDecRef ( GncTaxTable * table )

Definition at line 526 of file gncTaxTable.c.

{
    if (!table) return;
    if (table->parent || table->invisible) return;        /* children dont need refcounts */
    g_return_if_fail (table->refcount > 0);
    gncTaxTableBeginEdit (table);
    table->refcount--;
    mark_table (table);
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableDestroy()

void gncTaxTableDestroy ( GncTaxTable * table )

Definition at line 420 of file gncTaxTable.c.

{
    if (!table) return;
    qof_instance_set_destroying(table, TRUE);
    qof_instance_set_dirty (&table->inst);
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableEntryCompare()

int gncTaxTableEntryCompare	(	const GncTaxTableEntry *	a,
		const GncTaxTableEntry *	b
	)

Definition at line 821 of file gncTaxTable.c.

{
    char *name_a, *name_b;
    int retval;
 
    if (!a && !b) return 0;
    if (!a) return -1;
    if (!b) return 1;
 
    name_a = gnc_account_get_full_name (a->account);
    name_b = gnc_account_get_full_name (b->account);
    retval = g_strcmp0(name_a, name_b);
    g_free(name_a);
    g_free(name_b);
 
    if (retval)
        return retval;
 
    return gnc_numeric_compare (a->amount, b->amount);
}

◆ gncTaxTableEntryCreate()

GncTaxTableEntry * gncTaxTableEntryCreate ( void )

Definition at line 466 of file gncTaxTable.c.

{
    GncTaxTableEntry *entry;
    entry = g_new0 (GncTaxTableEntry, 1);
    entry->amount = gnc_numeric_zero ();
    return entry;
}

◆ gncTaxTableEntryDestroy()

void gncTaxTableEntryDestroy ( GncTaxTableEntry * entry )

Definition at line 474 of file gncTaxTable.c.

{
    if (!entry) return;
    g_free (entry);
}

◆ gncTaxTableEntryEqual()

gboolean gncTaxTableEntryEqual	(	const GncTaxTableEntry *	a,
		const GncTaxTableEntry *	b
	)

Definition at line 850 of file gncTaxTable.c.

{
    if (a == NULL && b == NULL) return TRUE;
    if (a == NULL || b == NULL) return FALSE;
 
    if (!xaccAccountEqual(a->account, b->account, TRUE))
    {
        PWARN("accounts differ");
        return FALSE;
    }
 
    if (a->type != b->type)
    {
        PWARN("types differ");
        return FALSE;
    }
 
    if (!gnc_numeric_equal(a->amount, b->amount))
    {
        PWARN("amounts differ");
        return FALSE;
    }
 
    return TRUE;
}

◆ gncTaxTableEntryGetAccount()

Account * gncTaxTableEntryGetAccount ( const GncTaxTableEntry * entry )

Definition at line 795 of file gncTaxTable.c.

{
    if (!entry) return NULL;
    return entry->account;
}

◆ gncTaxTableEntryGetAmount()

gnc_numeric gncTaxTableEntryGetAmount ( const GncTaxTableEntry * entry )

Definition at line 807 of file gncTaxTable.c.

{
    if (!entry) return gnc_numeric_zero();
    return entry->amount;
}

◆ gncTaxTableEntryGetType()

GncAmountType gncTaxTableEntryGetType ( const GncTaxTableEntry * entry )

Definition at line 801 of file gncTaxTable.c.

{
    if (!entry) return 0;
    return entry->type;
}

◆ gncTaxTableEntrySetAccount()

void gncTaxTableEntrySetAccount	(	GncTaxTableEntry *	entry,
		Account *	account
	)

Definition at line 558 of file gncTaxTable.c.

{
    if (!entry || !account) return;
    if (entry->account == account) return;
    entry->account = account;
    if (entry->table)
    {
        mark_table (entry->table);
        mod_table (entry->table);
    }
}

◆ gncTaxTableEntrySetAmount()

void gncTaxTableEntrySetAmount	(	GncTaxTableEntry *	entry,
		gnc_numeric	amount
	)

Definition at line 582 of file gncTaxTable.c.

{
    if (!entry) return;
    if (gnc_numeric_eq (entry->amount, amount)) return;
    entry->amount = amount;
    if (entry->table)
    {
        mark_table (entry->table);
        mod_table (entry->table);
    }
}

◆ gncTaxTableEntrySetType()

void gncTaxTableEntrySetType	(	GncTaxTableEntry *	entry,
		GncAmountType	type
	)

Definition at line 570 of file gncTaxTable.c.

{
    if (!entry) return;
    if (entry->type == type) return;
    entry->type = type;
    if (entry->table)
    {
        mark_table (entry->table);
        mod_table (entry->table);
    }
}

◆ gncTaxTableEqual()

gboolean gncTaxTableEqual	(	const GncTaxTable *	a,
		const GncTaxTable *	b
	)

Definition at line 876 of file gncTaxTable.c.

{
    if (a == NULL && b == NULL) return TRUE;
    if (a == NULL || b == NULL) return FALSE;
 
    g_return_val_if_fail(GNC_IS_TAXTABLE(a), FALSE);
    g_return_val_if_fail(GNC_IS_TAXTABLE(b), FALSE);
 
    if (g_strcmp0(a->name, b->name) != 0)
    {
        PWARN("Names differ: %s vs %s", a->name, b->name);
        return FALSE;
    }
 
    if (a->invisible != b->invisible)
    {
        PWARN("invisible flags differ");
        return FALSE;
    }
 
    if ((a->entries != NULL) != (b->entries != NULL))
    {
        PWARN("only one has entries");
        return FALSE;
    }
 
    if (a->entries != NULL && b->entries != NULL)
    {
        GncTaxTableEntryList* a_node;
        GncTaxTableEntryList* b_node;
 
        for (a_node = a->entries, b_node = b->entries;
                a_node != NULL && b_node != NULL;
                a_node = a_node->next, b_node = b_node->next)
        {
            if (!gncTaxTableEntryEqual((GncTaxTableEntry*)a_node->data,
                                       (GncTaxTableEntry*)b_node->data))
            {
                PWARN("entries differ");
                return FALSE;
            }
        }
 
        if (a_node != NULL || b_node != NULL)
        {
            PWARN("Unequal number of entries");
            return FALSE;
        }
    }
 
#if 0
    /* See libgnucash/engine/TaxTableBillTermImmutability.txt for an explanation of the following */
    /* Code that handles this is *identical* to that in gncBillTerm */
    gint64          refcount;
    GncTaxTable *   parent;       /* if non-null, we are an immutable child */
    GncTaxTable *   child;        /* if non-null, we have not changed */
    GList *         children;     /* list of children for disconnection */
#endif
 
    return TRUE;
}

◆ gncTaxTableGetDefault()

GncTaxTable * gncTaxTableGetDefault	(	QofBook *	book,
		GncOwnerType	type
	)

Definition at line 681 of file gncTaxTable.c.

{
    GSList *path = NULL;
    const GncGUID *guid = NULL;
    const char *vendor = "Default Vendor TaxTable";
    const char *customer = "Default Customer TaxTable";
    const char *section = "Business";
 
    g_return_val_if_fail (book != NULL, NULL);
    g_return_val_if_fail (type == GNC_OWNER_CUSTOMER || \
                          type == GNC_OWNER_VENDOR, NULL);
    path = g_slist_prepend (path, type == GNC_OWNER_CUSTOMER ? (void*)customer : (void*)vendor);
    path = g_slist_prepend (path, (void*)section);
 
    guid = qof_book_get_guid_option (book, path);
    g_slist_free (path);
 
    return gncTaxTableLookup (book, guid);
}

◆ gncTaxTableGetEntries()

GncTaxTableEntryList * gncTaxTableGetEntries ( const GncTaxTable * table )

Definition at line 771 of file gncTaxTable.c.

{
    if (!table) return NULL;
    return table->entries;
}

◆ gncTaxTableGetName()

const char * gncTaxTableGetName ( const GncTaxTable * table )

Definition at line 710 of file gncTaxTable.c.

{
    if (!table) return NULL;
    return table->name;
}

◆ gncTaxTableGetParent()

GncTaxTable * gncTaxTableGetParent ( const GncTaxTable * table )

Definition at line 765 of file gncTaxTable.c.

{
    if (!table) return NULL;
    return table->parent;
}

◆ gncTaxTableGetRefcount()

gint64 gncTaxTableGetRefcount ( const GncTaxTable * table )

Definition at line 777 of file gncTaxTable.c.

{
    if (!table) return 0;
    return table->refcount;
}

◆ gncTaxTableGetTables()

GncTaxTableList * gncTaxTableGetTables ( QofBook * book )

Definition at line 701 of file gncTaxTable.c.

{
    struct _book_info *bi;
    if (!book) return NULL;
 
    bi = qof_book_get_data (book, _GNC_MOD_NAME);
    return bi ? bi->tables : NULL;
}

◆ gncTaxTableIncRef()

void gncTaxTableIncRef ( GncTaxTable * table )

Definition at line 516 of file gncTaxTable.c.

{
    if (!table) return;
    if (table->parent || table->invisible) return;        /* children dont need refcounts */
    gncTaxTableBeginEdit (table);
    table->refcount++;
    mark_table (table);
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableLastModifiedSecs()

time64 gncTaxTableLastModifiedSecs ( const GncTaxTable * table )

Definition at line 783 of file gncTaxTable.c.

{
    if (!table) return 0;
    return table->modtime;
}

◆ gncTaxTableLookupByName()

GncTaxTable * gncTaxTableLookupByName	(	QofBook *	book,
		const char *	name
	)

Definition at line 667 of file gncTaxTable.c.

{
    GList *list = gncTaxTableGetTables (book);
 
    for ( ; list; list = list->next)
    {
        GncTaxTable *table = list->data;
        if (!g_strcmp0 (table->name, name))
            return list->data;
    }
    return NULL;
}

◆ gncTaxTableRemoveEntry()

void gncTaxTableRemoveEntry	(	GncTaxTable *	table,
		GncTaxTableEntry *	entry
	)

Definition at line 611 of file gncTaxTable.c.

{
    if (!table || !entry) return;
    gncTaxTableBeginEdit (table);
    entry->table = NULL;
    table->entries = g_list_remove (table->entries, entry);
    mark_table (table);
    mod_table (table);
    gncTaxTableCommitEdit (table);
}

◆ gncTaxTableReturnChild()

GncTaxTable * gncTaxTableReturnChild	(	GncTaxTable *	table,
		gboolean	make_new
	)

Definition at line 749 of file gncTaxTable.c.

{
    GncTaxTable *child = NULL;
 
    if (!table) return NULL;
    if (table->child) return table->child;
    if (table->parent || table->invisible) return table;
    if (make_new)
    {
        child = gncTaxTableCopy (table);
        gncTaxTableSetChild (table, child);
        gncTaxTableSetParent (child, table);
    }
    return child;
}

◆ gncTaxTableSetName()

void gncTaxTableSetName	(	GncTaxTable *	table,
		const char *	name
	)

Definition at line 483 of file gncTaxTable.c.

{
    if (!table || !name) return;
    SET_STR (table, table->name, name);
    mark_table (table);
    maybe_resort_list (table);
    gncTaxTableCommitEdit (table);
}

Files

Data Structures

Macros

Enumerations

Functions

Get Functions

Create/Destroy Functions

Set Functions