GnuCash  2.6.99
Files | Data Structures | Macros | Typedefs | Enumerations | Functions

Splits are grouped into Accounts which are also known as "Ledgers" in accounting practice. More...

Files

file  Account.h
 Account handling public routines.
 

Data Structures

struct  AccountClass
 
struct  GncImportMatchMap
 

Macros

#define GNC_TYPE_ACCOUNT   (gnc_account_get_type ())
 
#define GNC_ACCOUNT(o)   (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_ACCOUNT, Account))
 
#define GNC_ACCOUNT_CLASS(k)   (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_ACCOUNT, AccountClass))
 
#define GNC_IS_ACCOUNT(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_ACCOUNT))
 
#define GNC_IS_ACCOUNT_CLASS(k)   (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_ACCOUNT))
 
#define GNC_ACCOUNT_GET_CLASS(o)   (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_ACCOUNT, AccountClass))
 

Typedefs

typedef gnc_numeric(* xaccGetBalanceFn) (const Account *account)
 
typedef gnc_numeric(* xaccGetBalanceInCurrencyFn) (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
typedef gnc_numeric(* xaccGetBalanceAsOfDateFn) (Account *account, time64 date)
 
typedef void(* AccountCb) (Account *a, gpointer data)
 
typedef gpointer(* AccountCb2) (Account *a, gpointer data)
 

Enumerations

enum  GNCAccountType {
  ACCT_TYPE_INVALID = -1, ACCT_TYPE_NONE = -1, ACCT_TYPE_BANK = 0, ACCT_TYPE_CASH = 1,
  ACCT_TYPE_CREDIT = 3, ACCT_TYPE_ASSET = 2, ACCT_TYPE_LIABILITY = 4, ACCT_TYPE_STOCK = 5,
  ACCT_TYPE_MUTUAL = 6, ACCT_TYPE_CURRENCY = 7, ACCT_TYPE_INCOME = 8, ACCT_TYPE_EXPENSE = 9,
  ACCT_TYPE_EQUITY = 10, ACCT_TYPE_RECEIVABLE = 11, ACCT_TYPE_PAYABLE = 12, ACCT_TYPE_ROOT = 13,
  ACCT_TYPE_TRADING = 14, NUM_ACCOUNT_TYPES = 15, ACCT_TYPE_CHECKING = 15, ACCT_TYPE_SAVINGS = 16,
  ACCT_TYPE_MONEYMRKT = 17, ACCT_TYPE_CREDITLINE = 18, ACCT_TYPE_LAST
}
 The account types are used to determine how the transaction data in the account is displayed. More...
 

Functions

GType gnc_account_get_type (void)
 Returns the GType type system description of the Account class. More...
 
gchar * gnc_account_name_violations_errmsg (const gchar *separator, GList *invalid_account_names)
 Composes a translatable error message showing which account names clash with the current account separator. More...
 
GList * gnc_account_list_name_violations (QofBook *book, const gchar *separator)
 Runs through all the accounts and returns a list of account names that contain the provided separator character. More...
 
void xaccAccountSetReconcileChildrenStatus (Account *account, gboolean status)
 DOCUMENT ME!
 
gboolean xaccAccountGetReconcileChildrenStatus (const Account *account)
 DOCUMENT ME!
 
gboolean xaccAccountHasAncestor (const Account *acc, const Account *ancestor)
 Returns true if the account is 'ancestor' or has 'ancestor' as an ancestor. More...
 

Account Constructors, Edit/Commit, Comparison

AccountxaccMallocAccount (QofBook *book)
 Constructor.
 
Accountgnc_account_create_root (QofBook *book)
 Create a new root level account. More...
 
AccountxaccCloneAccount (const Account *source, QofBook *book)
 The xaccCloneAccount() routine makes a simple copy of the indicated account, placing it in the indicated book. More...
 
void xaccAccountBeginEdit (Account *account)
 The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account updates. More...
 
void xaccAccountCommitEdit (Account *account)
 ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account updates. More...
 
void xaccAccountDestroy (Account *account)
 The xaccAccountDestroy() routine can be used to get rid of an account. More...
 
gboolean xaccAccountEqual (const Account *a, const Account *b, gboolean check_guids)
 Compare two accounts for equality - this is a deep compare. More...
 
int xaccAccountOrder (const Account *account_1, const Account *account_2)
 The xaccAccountOrder() subroutine defines a sorting order on accounts. More...
 

Account lookup and GncGUID routines

const gchar * gnc_get_account_separator_string (void)
 Returns the account separation character chosen by the user. More...
 
gunichar gnc_get_account_separator (void)
 
void gnc_set_account_separator (const gchar *separator)
 
Accountgnc_book_get_root_account (QofBook *book)
 
void gnc_book_set_root_account (QofBook *book, Account *root)
 
AccountxaccAccountLookup (const GncGUID *guid, QofBook *book)
 The xaccAccountLookup() subroutine will return the account associated with the given id, or NULL if there is no such account. More...
 
#define xaccAccountGetGUID(X)   qof_entity_get_guid(QOF_INSTANCE(X))
 
#define xaccAccountReturnGUID(X)   (X ? *(qof_entity_get_guid(QOF_INSTANCE(X))) : *(guid_null()))
 
#define xaccAccountLookupDirect(g, b)   xaccAccountLookup(&(g),b)
 

Account general setters/getters

QofBook * gnc_account_get_book (const Account *account)
 
void xaccAccountSetType (Account *account, GNCAccountType)
 Set the account's type.
 
void xaccAccountSetName (Account *account, const char *name)
 Set the account's name.
 
void xaccAccountSetCode (Account *account, const char *code)
 Set the account's accounting code.
 
void xaccAccountSetDescription (Account *account, const char *desc)
 Set the account's description.
 
void xaccAccountSetColor (Account *account, const char *color)
 Set the account's Color.
 
void xaccAccountSetFilter (Account *account, const char *filter)
 Set the account's Filter.
 
void xaccAccountSetSortOrder (Account *account, const char *sortorder)
 Set the account's Sort Order.
 
void xaccAccountSetSortReversed (Account *account, gboolean sortreversed)
 Set the account's Sort Order direction.
 
void xaccAccountSetNotes (Account *account, const char *notes)
 Set the account's notes.
 
void xaccAccountSetLastNum (Account *account, const char *num)
 Set the last num field of an Account.
 
void gnc_account_set_policy (Account *account, GNCPolicy *policy)
 Set the account's lot order policy.
 
GNCAccountType xaccAccountGetType (const Account *account)
 Returns the account's account type. More...
 
gboolean xaccAccountIsPriced (const Account *acc)
 Returns true if the account is a stock, mutual fund or currency, otherwise false. More...
 
void gnc_account_set_start_balance (Account *acc, const gnc_numeric start_baln)
 This function will set the starting commodity balance for this account. More...
 
void gnc_account_set_start_cleared_balance (Account *acc, const gnc_numeric start_baln)
 This function will set the starting cleared commodity balance for this account. More...
 
void gnc_account_set_start_reconciled_balance (Account *acc, const gnc_numeric start_baln)
 This function will set the starting reconciled commodity balance for this account. More...
 
void gnc_account_set_balance_dirty (Account *acc)
 Tell the account that the running balances may be incorrect and need to be recomputed. More...
 
void gnc_account_set_sort_dirty (Account *acc)
 Tell the account believes that the splits may be incorrectly sorted and need to be resorted. More...
 
gboolean gnc_account_insert_split (Account *acc, Split *s)
 Insert the given split from an account. More...
 
gboolean gnc_account_remove_split (Account *acc, Split *s)
 Remove the given split from an account. More...
 
const char * xaccAccountGetName (const Account *account)
 Get the account's name.
 
const char * xaccAccountGetCode (const Account *account)
 Get the account's accounting code.
 
const char * xaccAccountGetDescription (const Account *account)
 Get the account's description.
 
const char * xaccAccountGetColor (const Account *account)
 Get the account's color.
 
const char * xaccAccountGetFilter (const Account *account)
 Get the account's filter.
 
const char * xaccAccountGetSortOrder (const Account *account)
 Get the account's Sort Order.
 
gboolean xaccAccountGetSortReversed (const Account *account)
 Get the account's Sort Order direction.
 
const char * xaccAccountGetNotes (const Account *account)
 Get the account's notes.
 
const char * xaccAccountGetLastNum (const Account *account)
 Get the last num field of an Account.
 
GNCPolicy * gnc_account_get_policy (Account *account)
 Get the account's lot order policy.
 
void xaccAccountRecomputeBalance (Account *)
 The following recompute the partial balances (stored with the transaction) and the total balance, for this account.
 
void xaccAccountSortSplits (Account *acc, gboolean force)
 The xaccAccountSortSplits() routine will resort the account's splits if the sort is dirty. More...
 
gchar * gnc_account_get_full_name (const Account *account)
 The gnc_account_get_full_name routine returns the fully qualified name of the account using the given separator char. More...
 
AccountxaccAccountGainsAccount (Account *acc, gnc_commodity *curr)
 Retrieve the gains account used by this account for the indicated currency, creating and recording a new one if necessary. More...
 
void dxaccAccountSetPriceSrc (Account *account, const char *src)
 Set a string that identifies the Finance::Quote backend that should be used to retrieve online prices. More...
 
const char * dxaccAccountGetPriceSrc (const Account *account)
 Get a string that identifies the Finance::Quote backend that should be used to retrieve online prices. More...
 
gboolean xaccAccountGetAutoInterestXfer (const Account *account, gboolean default_value)
 Returns a per-account flag: Prior to reconciling an account which charges or pays interest, this flag tells whether to prompt the user to enter a transaction for the interest charge or payment. More...
 
void xaccAccountSetAutoInterestXfer (Account *account, gboolean value)
 Sets a per-account flag: Prior to reconciling an account which charges or pays interest, this flag tells whether to prompt the user to enter a transaction for the interest charge or payment. More...
 

Account Commodity setters/getters

Accounts are used to store an amount of 'something', that 'something'
is called the 'commodity'.

An account can only hold one kind of commodity. The following are used to get and set the commodity, and also to set the SCU, the 'Smallest Commodity Unit'.

Note that when we say that a 'split' holds an 'amount', that amount is denominated in the account commodity. Do not confuse 'amount' and 'value'. The 'value' of a split is the value of the amount expressed in the currency of the transaction. Thus, for example, the 'amount' may be 12 apples, where the account commodity is 'apples'. The value of these 12 apples may be 12 dollars, where the transaction currency is 'dollars'.

The SCU is the 'Smallest Commodity Unit', signifying the smallest non-zero amount that can be stored in the account. It is represented as the integer denominator of a fraction. Thus, for example, a SCU of 12 means that 1/12 of something is the smallest amount that can be stored in the account. SCU's can be any value; they do not need to be decimal. This allows the use of accounts with unusual, non-decimal commodities and currencies.

Normally, the SCU is determined by the commodity of the account. However, this default SCU can be over-ridden and set to an account-specific value. This is account-specific value is called the 'non-standard' value in the documentation below.

void xaccAccountSetCommodity (Account *account, gnc_commodity *comm)
 Set the account's commodity.
 
gnc_commodity * xaccAccountGetCommodity (const Account *account)
 Get the account's commodity.
 
gnc_commodity * gnc_account_get_currency_or_parent (const Account *account)
 Returns a gnc_commodity that is a currency, suitable for being a Transaction's currency. More...
 
int xaccAccountGetCommoditySCU (const Account *account)
 Return the SCU for the account. More...
 
int xaccAccountGetCommoditySCUi (const Account *account)
 Return the 'internal' SCU setting. More...
 
void xaccAccountSetCommoditySCU (Account *account, int frac)
 Set the SCU for the account. More...
 
void xaccAccountSetNonStdSCU (Account *account, gboolean flag)
 Set the flag indicating that this account uses a non-standard SCU. More...
 
gboolean xaccAccountGetNonStdSCU (const Account *account)
 Return boolean, indicating whether this account uses a non-standard SCU. More...
 

Account Balance

gnc_numeric xaccAccountGetBalance (const Account *account)
 Get the current balance of the account, which may include future splits.
 
gnc_numeric xaccAccountGetClearedBalance (const Account *account)
 Get the current balance of the account, only including cleared transactions.
 
gnc_numeric xaccAccountGetReconciledBalance (const Account *account)
 Get the current balance of the account, only including reconciled transactions.
 
gnc_numeric xaccAccountGetPresentBalance (const Account *account)
 
gnc_numeric xaccAccountGetProjectedMinimumBalance (const Account *account)
 
gnc_numeric xaccAccountGetBalanceAsOfDate (Account *account, time64 date)
 Get the balance of the account as of the date specified.
 
gnc_numeric xaccAccountConvertBalanceToCurrency (const Account *account, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency)
 
gnc_numeric xaccAccountConvertBalanceToCurrencyAsOfDate (const Account *account, gnc_numeric balance, gnc_commodity *balance_currency, gnc_commodity *new_currency, time64 date)
 
gnc_numeric xaccAccountGetBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetClearedBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetReconciledBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetPresentBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetProjectedMinimumBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetBalanceAsOfDateInCurrency (Account *account, time64 date, gnc_commodity *report_commodity, gboolean include_children)
 
gnc_numeric xaccAccountGetBalanceChangeForPeriod (Account *acc, time64 date1, time64 date2, gboolean recurse)
 

Account Children and Parents.

The set of accounts is represented as a doubly-linked tree, so that given any account, both its parent and its children can be easily found.

At the top of the tree hierarchy lies a single root node, the root account.

The account tree hierarchy is unique, in that a given account can have only one parent account.

void gnc_account_append_child (Account *new_parent, Account *child)
 This function will remove from the child account any pre-existing parent relationship, and will then add the account as a child of the new parent. More...
 
void gnc_account_remove_child (Account *parent, Account *child)
 This function will remove the specified child account from the specified parent account. More...
 
Accountgnc_account_get_parent (const Account *account)
 This routine returns a pointer to the parent of the specified account. More...
 
Accountgnc_account_get_root (Account *account)
 This routine returns the root account of the account tree that the specified account belongs to. More...
 
gboolean gnc_account_is_root (const Account *account)
 This routine indicates whether the specified account is the root node of an account tree. More...
 
GList * gnc_account_get_children (const Account *account)
 This routine returns a GList of all children accounts of the specified account. More...
 
GList * gnc_account_get_children_sorted (const Account *account)
 This routine returns a GList of all children accounts of the specified account, ordered by xaccAccountOrder(). More...
 
gint gnc_account_n_children (const Account *account)
 Return the number of children of the specified account. More...
 
gint gnc_account_child_index (const Account *parent, const Account *child)
 Return the index of the specified child within the list of the parent's children. More...
 
Accountgnc_account_nth_child (const Account *parent, gint num)
 Return the n'th child account of the specified parent account. More...
 
GList * gnc_account_get_descendants (const Account *account)
 This routine returns a flat list of all of the accounts that are descendants of the specified account. More...
 
GList * gnc_account_get_descendants_sorted (const Account *account)
 This function returns a GList containing all the descendants of the specified account, sorted at each level. More...
 
gint gnc_account_n_descendants (const Account *account)
 Return the number of descendants of the specified account. More...
 
gint gnc_account_get_current_depth (const Account *account)
 Return the number of levels of this account below the root account. More...
 
gint gnc_account_get_tree_depth (const Account *account)
 Return the number of levels of descendants accounts below the specified account. More...
 

ForEach

void gnc_account_foreach_child (const Account *account, AccountCb func, gpointer user_data)
 This method will traverse the immediate children of this accounts, calling 'func' on each account. More...
 
void gnc_account_foreach_descendant (const Account *account, AccountCb func, gpointer user_data)
 This method will traverse all children of this accounts and their descendants, calling 'func' on each account. More...
 
gpointer gnc_account_foreach_descendant_until (const Account *account, AccountCb2 func, gpointer user_data)
 This method will traverse all children of this accounts and their descendants, calling 'func' on each account. More...
 

Concatenation, Merging

void gnc_account_join_children (Account *to_parent, Account *from_parent)
 The gnc_account_join_children() subroutine will move (reparent) all child accounts from the from_parent account to the to_parent account, preserving the account hierarchy. More...
 
void gnc_account_merge_children (Account *parent)
 The gnc_account_merge_children() subroutine will go through an account, merging all child accounts that have the same name and description. More...
 

Detailed Description

Splits are grouped into Accounts which are also known as "Ledgers" in accounting practice.

Each Account consists of a list of Splits that debit that Account. To ensure consistency, if a Split points to an Account, then the Account must point to the Split, and vice-versa. A Split can belong to at most one Account. Besides merely containing a list of Splits, the Account structure also gives the Account a name, a code number, description and notes fields, a key-value frame, a pointer to the commodity that is used for all splits in this account. The commodity can be the name of anything traded and tradeable: a stock (e.g. "IBM", "McDonald's"), a currency (e.g. "USD", "GBP"), or anything added to the commodity table.

Accounts can be arranged in a hierarchical tree. By accounting convention, the value of an Account is equal to the value of all of its Splits plus the value of all of its sub-Accounts.

Macro Definition Documentation

◆ xaccAccountGetGUID

#define xaccAccountGetGUID (   X)    qof_entity_get_guid(QOF_INSTANCE(X))
Deprecated:

Definition at line 245 of file Account.h.

Enumeration Type Documentation

◆ GNCAccountType

The account types are used to determine how the transaction data in the account is displayed.

These values can be safely changed from one release to the next. Note that if values are added, the file IO translation routines need to be updated. Note also that GUI code depends on these numbers.

Note
IMPORTANT: If you do change the enumeration names (not the numbers), you need to update xaccAccountTypeEnumAsString — used for text file exports
Enumerator
ACCT_TYPE_INVALID 

Not a type.

ACCT_TYPE_NONE 

Not a type.

ACCT_TYPE_BANK 

The bank account type denotes a savings or checking account held at a bank.

Often interest bearing.

ACCT_TYPE_CASH 

The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.

ACCT_TYPE_CREDIT 

The Credit card account is used to denote credit (e.g.

amex) and debit (e.g. visa, mastercard) card accounts

ACCT_TYPE_ASSET 

asset (and liability) accounts indicate generic, generalized accounts that are none of the above.

ACCT_TYPE_LIABILITY 

liability (and asset) accounts indicate generic, generalized accounts that are none of the above.

ACCT_TYPE_STOCK 

Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.

ACCT_TYPE_MUTUAL 

Mutual Fund accounts will typically be shown in registers which show three columns: price, number of shares, and value.

ACCT_TYPE_CURRENCY 

The currency account type indicates that the account is a currency trading account.

In many ways, a currency trading account is like a stock * trading account. It is shown in the register with three columns: price, number of shares, and value. Note: Since version 1.7.0, this account is * no longer needed to exchange currencies between accounts, so this type is DEPRECATED.

ACCT_TYPE_INCOME 

Income accounts are used to denote income.

ACCT_TYPE_EXPENSE 

Expense accounts are used to denote expenses.

ACCT_TYPE_EQUITY 

Equity account is used to balance the balance sheet.

ACCT_TYPE_RECEIVABLE 

A/R account type.

ACCT_TYPE_PAYABLE 

A/P account type.

ACCT_TYPE_ROOT 

The hidden root account of an account tree.

ACCT_TYPE_TRADING 

Account used to record multiple commodity transactions.

This is not the same as ACCT_TYPE_CURRENCY above. Multiple commodity transactions have splits in these accounts to make the transaction balance in each commodity as well as in total value.

NUM_ACCOUNT_TYPES 

stop here; the following types just aren't ready for prime time

ACCT_TYPE_CHECKING 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_SAVINGS 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_MONEYMRKT 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_CREDITLINE 

line of credit – don't use this for now, see NUM_ACCOUNT_TYPES

Definition at line 102 of file Account.h.

103 {
104  ACCT_TYPE_INVALID = -1,
105  ACCT_TYPE_NONE = -1,
107  ACCT_TYPE_BANK = 0,
110  ACCT_TYPE_CASH = 1,
113  ACCT_TYPE_CREDIT = 3,
116  ACCT_TYPE_ASSET = 2,
122  ACCT_TYPE_STOCK = 5,
125  ACCT_TYPE_MUTUAL = 6,
129  ACCT_TYPE_CURRENCY = 7,
140  ACCT_TYPE_INCOME = 8,
143  ACCT_TYPE_EXPENSE = 9,
146  ACCT_TYPE_EQUITY = 10,
151  ACCT_TYPE_PAYABLE = 12,
153  ACCT_TYPE_ROOT = 13,
155  ACCT_TYPE_TRADING = 14,
161  NUM_ACCOUNT_TYPES = 15,
164  /* bank account types */
165  ACCT_TYPE_CHECKING = 15,
167  ACCT_TYPE_SAVINGS = 16,
169  ACCT_TYPE_MONEYMRKT = 17,
171  ACCT_TYPE_CREDITLINE = 18,
173  ACCT_TYPE_LAST
Expense accounts are used to denote expenses.
Definition: Account.h:143
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:125
stop here; the following types just aren't ready for prime time
Definition: Account.h:161
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:110
Account used to record multiple commodity transactions.
Definition: Account.h:155
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:122
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:165
Income accounts are used to denote income.
Definition: Account.h:140
line of credit – don't use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:171
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:107
A/P account type.
Definition: Account.h:151
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:167
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:116
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:129
GNCAccountType
The account types are used to determine how the transaction data in the account is displayed...
Definition: Account.h:102
Not a type.
Definition: Account.h:104
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
A/R account type.
Definition: Account.h:149
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:169
Equity account is used to balance the balance sheet.
Definition: Account.h:146
Not a type.
Definition: Account.h:105
The hidden root account of an account tree.
Definition: Account.h:153
The Credit card account is used to denote credit (e.g.
Definition: Account.h:113

Function Documentation

◆ dxaccAccountGetPriceSrc()

const char* dxaccAccountGetPriceSrc ( const Account account)

Get a string that identifies the Finance::Quote backend that should be used to retrieve online prices.

See price-quotes.scm for more information.

Deprecated:
Price quote information is now stored on the commodity, not the account.

Definition at line 4616 of file Account.c.

4617 {
4618  GValue v = G_VALUE_INIT;
4619  if (!acc) return NULL;
4620 
4621  if (!xaccAccountIsPriced(acc)) return NULL;
4622 
4623  qof_instance_get_kvp (QOF_INSTANCE(acc), "old-price-source", &v);
4624  return G_VALUE_HOLDS_STRING (&v) ? g_value_get_string (&v) : NULL;
4625 }
void qof_instance_get_kvp(const QofInstance *inst, const gchar *key, GValue *value)
Retrieves the contents of a KVP slot into a provided GValue.
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.c:4252

◆ dxaccAccountSetPriceSrc()

void dxaccAccountSetPriceSrc ( Account account,
const char *  src 
)

Set a string that identifies the Finance::Quote backend that should be used to retrieve online prices.

See price-quotes.scm for more information

Deprecated:
Price quote information is now stored on the commodity, not the account.

Definition at line 4589 of file Account.c.

4590 {
4591  if (!acc) return;
4592 
4593  if (xaccAccountIsPriced(acc))
4594  {
4595  xaccAccountBeginEdit(acc);
4596  if (src)
4597  {
4598  GValue v = G_VALUE_INIT;
4599  g_value_init (&v, G_TYPE_STRING);
4600  g_value_set_string (&v, src);
4601  qof_instance_set_kvp (QOF_INSTANCE(acc),
4602  "old-price-source", &v);
4603  }
4604  else
4605  qof_instance_set_kvp (QOF_INSTANCE(acc), "old-price-source", NULL);
4606 
4607  mark_account (acc);
4608  xaccAccountCommitEdit(acc);
4609  }
4610 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.c:4252
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
void qof_instance_set_kvp(QofInstance *inst, const gchar *key, const GValue *value)
Sets a KVP slot to a value from a GValue.
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336

◆ gnc_account_append_child()

void gnc_account_append_child ( Account new_parent,
Account child 
)

This function will remove from the child account any pre-existing parent relationship, and will then add the account as a child of the new parent.

The exception to this is when the old and new parent accounts are the same, in which case this function does nothing.

If the child account belongs to a different book than the specified new parent account, the child will be removed from the other book (and thus, the other book's entity tables, generating a destroy event), and will be added to the new book (generating a create event).

Parameters
new_parentThe new parent account to which the child should be attached.
childThe account to attach.

Definition at line 2526 of file Account.c.

2527 {
2528  AccountPrivate *ppriv, *cpriv;
2529  Account *old_parent;
2530  QofCollection *col;
2531 
2532  /* errors */
2533  g_assert(GNC_IS_ACCOUNT(new_parent));
2534  g_assert(GNC_IS_ACCOUNT(child));
2535 
2536  /* optimizations */
2537  ppriv = GET_PRIVATE(new_parent);
2538  cpriv = GET_PRIVATE(child);
2539  old_parent = cpriv->parent;
2540  if (old_parent == new_parent)
2541  return;
2542 
2543  // xaccAccountBeginEdit(new_parent);
2544  xaccAccountBeginEdit(child);
2545  if (old_parent)
2546  {
2547  gnc_account_remove_child(old_parent, child);
2548 
2549  if (!qof_instance_books_equal(old_parent, new_parent))
2550  {
2551  /* hack alert -- this implementation is not exactly correct.
2552  * If the entity tables are not identical, then the 'from' book
2553  * may have a different backend than the 'to' book. This means
2554  * that we should get the 'from' backend to destroy this account,
2555  * and the 'to' backend to save it. Right now, this is broken.
2556  *
2557  * A 'correct' implementation similar to this is in Period.c
2558  * except its for transactions ...
2559  *
2560  * Note also, we need to reparent the children to the new book as well.
2561  */
2562  PWARN ("reparenting accounts across books is not correctly supported\n");
2563 
2564  qof_event_gen (&child->inst, QOF_EVENT_DESTROY, NULL);
2566  GNC_ID_ACCOUNT);
2567  qof_collection_insert_entity (col, &child->inst);
2568  qof_event_gen (&child->inst, QOF_EVENT_CREATE, NULL);
2569  }
2570  }
2571  cpriv->parent = new_parent;
2572  ppriv->children = g_list_append(ppriv->children, child);
2573  qof_instance_set_dirty(&new_parent->inst);
2574  qof_instance_set_dirty(&child->inst);
2575 
2576  /* Send events data. Warning: The call to commit_edit is also going
2577  * to send a MODIFY event. If the gtktreemodelfilter code gets the
2578  * MODIFY before it gets the ADD, it gets very confused and thinks
2579  * that two nodes have been added. */
2580  qof_event_gen (&child->inst, QOF_EVENT_ADD, NULL);
2581  // qof_event_gen (&new_parent->inst, QOF_EVENT_MODIFY, NULL);
2582 
2583  xaccAccountCommitEdit (child);
2584  // xaccAccountCommitEdit(new_parent);
2585 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
STRUCTS.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:243
void gnc_account_remove_child(Account *parent, Account *child)
This function will remove the specified child account from the specified parent account.
Definition: Account.c:2588
void qof_collection_insert_entity(QofCollection *, QofInstance *)
Take entity, remove it from whatever collection its currently in, and place it in a new collection...
Definition: qofid.cpp:97
gboolean qof_instance_books_equal(gconstpointer ptr1, gconstpointer ptr2)
See if two QofInstances share the same book.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:599
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336

◆ gnc_account_child_index()

gint gnc_account_child_index ( const Account parent,
const Account child 
)

Return the index of the specified child within the list of the parent's children.

The first child index is 0. This function returns -1 if the parent account is NULL of if the specified child does not belong to the parent account.

Parameters
parentThe parent account to check.
childThe child account to find.
Returns
The index of the child account within the specified parent, or -1.

Definition at line 2684 of file Account.c.

2685 {
2686  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
2687  g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
2688  return g_list_index(GET_PRIVATE(parent)->children, child);
2689 }

◆ gnc_account_create_root()

Account* gnc_account_create_root ( QofBook *  book)

Create a new root level account.

Definition at line 1113 of file Account.c.

1114 {
1115  Account *root;
1116  AccountPrivate *rpriv;
1117 
1118  root = xaccMallocAccount(book);
1119  rpriv = GET_PRIVATE(root);
1120  xaccAccountBeginEdit(root);
1121  rpriv->type = ACCT_TYPE_ROOT;
1122  CACHE_REPLACE(rpriv->accountName, "Root Account");
1123  mark_account (root);
1124  xaccAccountCommitEdit(root);
1125  gnc_book_set_root_account(book, root);
1126  return root;
1127 }
STRUCTS.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
Account * xaccMallocAccount(QofBook *book)
Constructor.
Definition: Account.c:1099
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336
The hidden root account of an account tree.
Definition: Account.h:153

◆ gnc_account_foreach_child()

void gnc_account_foreach_child ( const Account account,
AccountCb  func,
gpointer  user_data 
)

This method will traverse the immediate children of this accounts, calling 'func' on each account.

This function traverses all children nodes. To traverse only a subset of the child nodes use the gnc_account_foreach_child_until() function.

Parameters
accountA pointer to the account on whose children the function should be called.
funcA function taking two arguments, an Account and a gpointer.
user_dataThis data will be passed to each call of func.

Definition at line 2941 of file Account.c.

2944 {
2945  const AccountPrivate *priv;
2946  GList *node;
2947 
2948  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2949  g_return_if_fail(thunk);
2950 
2951  priv = GET_PRIVATE(acc);
2952  for (node = priv->children; node; node = node->next)
2953  {
2954  thunk (node->data, user_data);
2955  }
2956 }

◆ gnc_account_foreach_descendant()

void gnc_account_foreach_descendant ( const Account account,
AccountCb  func,
gpointer  user_data 
)

This method will traverse all children of this accounts and their descendants, calling 'func' on each account.

This function traverses all descendant nodes. To traverse only a subset of the descendant nodes use the gnc_account_foreach_descendant_until() function.

Parameters
accountA pointer to the account on whose descendants the function should be called.
funcA function taking two arguments, an Account and a gpointer.
user_dataThis data will be passed to each call of func.

Definition at line 2959 of file Account.c.

2962 {
2963  const AccountPrivate *priv;
2964  GList *node;
2965  Account *child;
2966 
2967  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2968  g_return_if_fail(thunk);
2969 
2970  priv = GET_PRIVATE(acc);
2971  for (node = priv->children; node; node = node->next)
2972  {
2973  child = node->data;
2974  thunk(child, user_data);
2975  gnc_account_foreach_descendant(child, thunk, user_data);
2976  }
2977 }
void gnc_account_foreach_descendant(const Account *acc, AccountCb thunk, gpointer user_data)
This method will traverse all children of this accounts and their descendants, calling 'func' on each...
Definition: Account.c:2959
STRUCTS.

◆ gnc_account_foreach_descendant_until()

gpointer gnc_account_foreach_descendant_until ( const Account account,
AccountCb2  func,
gpointer  user_data 
)

This method will traverse all children of this accounts and their descendants, calling 'func' on each account.

Traversal will stop when func returns a non-null value, and the routine will return with that value. Therefore, this function will return null if func returns null for every account. For a simpler function that always traverses all children nodes, use the gnc_account_foreach_descendant() function.

Parameters
accountA pointer to the account on whose descendants the function should be called.
funcA function taking two arguments, an Account and a gpointer.
user_dataThis data will be passed to each call of func.

Definition at line 2980 of file Account.c.

2983 {
2984  const AccountPrivate *priv;
2985  GList *node;
2986  Account *child;
2987  gpointer result;
2988 
2989  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2990  g_return_val_if_fail(thunk, NULL);
2991 
2992  priv = GET_PRIVATE(acc);
2993  for (node = priv->children; node; node = node->next)
2994  {
2995  child = node->data;
2996  result = thunk(child, user_data);
2997  if (result)
2998  return(result);
2999 
3000  result = gnc_account_foreach_descendant_until(child, thunk, user_data);
3001  if (result)
3002  return(result);
3003  }
3004 
3005  return NULL;
3006 }
STRUCTS.
gpointer gnc_account_foreach_descendant_until(const Account *acc, AccountCb2 thunk, gpointer user_data)
This method will traverse all children of this accounts and their descendants, calling 'func' on each...
Definition: Account.c:2980

◆ gnc_account_get_children()

GList* gnc_account_get_children ( const Account account)

This routine returns a GList of all children accounts of the specified account.

This function only returns the immediate children of the specified account. For a list of all descendant accounts, use the gnc_account_get_descendants() function.

If you are looking for the splits of this account, use xaccAccountGetSplitList() instead. This function here deals with children accounts inside the account tree.

Parameters
accountThe account whose children should be returned.
Returns
A GList of account pointers, or NULL if there are no children accounts. It is the callers responsibility to free any returned list with the g_list_free() function.

Definition at line 2655 of file Account.c.

2656 {
2657  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2658  return g_list_copy(GET_PRIVATE(account)->children);
2659 }

◆ gnc_account_get_children_sorted()

GList* gnc_account_get_children_sorted ( const Account account)

This routine returns a GList of all children accounts of the specified account, ordered by xaccAccountOrder().

See also
gnc_account_get_children()

Definition at line 2662 of file Account.c.

2663 {
2664  AccountPrivate *priv;
2665 
2666  /* errors */
2667  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2668 
2669  /* optimizations */
2670  priv = GET_PRIVATE(account);
2671  if (!priv->children)
2672  return NULL;
2673  return g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2674 }
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.c:2147

◆ gnc_account_get_currency_or_parent()

gnc_commodity* gnc_account_get_currency_or_parent ( const Account account)

Returns a gnc_commodity that is a currency, suitable for being a Transaction's currency.

The gnc_commodity is taken either from the current account, or from the next parent account that has a gnc_commodity that is a currency. If neither this account nor any of its parent has such a commodity that is a currency, NULL is returned. In that case, you can use gnc_default_currency() but you might want to show a warning dialog first.

Definition at line 3162 of file Account.c.

3163 {
3164  gnc_commodity * commodity;
3165  g_assert(account);
3166 
3167  commodity = xaccAccountGetCommodity (account);
3168  if (gnc_commodity_is_currency(commodity))
3169  return commodity;
3170  else
3171  {
3172  const Account *parent_account = account;
3173  /* Account commodity is not a currency, walk up the tree until
3174  * we find a parent account that is a currency account and use
3175  * it's currency.
3176  */
3177  do
3178  {
3179  parent_account = gnc_account_get_parent (parent_account);
3180  if (parent_account)
3181  {
3182  commodity = xaccAccountGetCommodity (parent_account);
3183  if (gnc_commodity_is_currency(commodity))
3184  {
3185  return commodity;
3186  //break;
3187  }
3188  }
3189  }
3190  while (parent_account);
3191  }
3192  return NULL; // no suitable commodity found.
3193 }
Account * gnc_account_get_parent(const Account *acc)
This routine returns a pointer to the parent of the specified account.
Definition: Account.c:2624
gboolean gnc_commodity_is_currency(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency or a legacy currency...
STRUCTS.
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account's commodity.
Definition: Account.c:3155

◆ gnc_account_get_current_depth()

gint gnc_account_get_current_depth ( const Account account)

Return the number of levels of this account below the root account.

Parameters
accountThe account to query.
Returns
The number of levels below the root.

Definition at line 2716 of file Account.c.

2717 {
2718  AccountPrivate *priv;
2719  int depth = 0;
2720 
2721  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2722 
2723  priv = GET_PRIVATE(account);
2724  while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
2725  {
2726  account = priv->parent;
2727  priv = GET_PRIVATE(account);
2728  depth++;
2729  }
2730 
2731  return depth;
2732 }
The hidden root account of an account tree.
Definition: Account.h:153

◆ gnc_account_get_descendants()

GList* gnc_account_get_descendants ( const Account account)

This routine returns a flat list of all of the accounts that are descendants of the specified account.

This includes not only the the children, but the children of the children, etc. For a list of only the immediate child accounts, use the gnc_account_get_children() function. Within each set of child accounts, the accounts returned by this function are unordered. For a list of descendants where each set of children is sorted via the standard account sort function, use the gnc_account_get_descendants_sorted() function.

Parameters
accountThe account whose descendants should be returned.
Returns
A GList of account pointers, or NULL if there are no descendants. It is the callers responsibility to free any returned list with the g_list_free() function.

Definition at line 2756 of file Account.c.

2757 {
2758  AccountPrivate *priv;
2759  GList *child, *descendants;
2760 
2761  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2762 
2763  priv = GET_PRIVATE(account);
2764  if (!priv->children)
2765  return NULL;
2766 
2767  descendants = NULL;
2768  for (child = priv->children; child; child = g_list_next(child))
2769  {
2770  descendants = g_list_append(descendants, child->data);
2771  descendants = g_list_concat(descendants,
2772  gnc_account_get_descendants(child->data));
2773  }
2774  return descendants;
2775 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.c:2756

◆ gnc_account_get_descendants_sorted()

GList* gnc_account_get_descendants_sorted ( const Account account)

This function returns a GList containing all the descendants of the specified account, sorted at each level.

This includes not only the the children, but the children of the children, etc. Within each set of child accounts, the accounts returned by this function are ordered via the standard account sort function. For a list of descendants where each set of children is unordered, use the gnc_account_get_descendants() function.

Note: Use this function where the results are intended for display to the user. If the results are internal to GnuCash or will be resorted at som later point in time you should use the gnc_account_get_descendants() function.

Parameters
accountThe account whose descendants should be returned.
Returns
A GList of account pointers, or NULL if there are no descendants. It is the callers responsibility to free any returned list with the g_list_free() function.

Definition at line 2778 of file Account.c.

2779 {
2780  AccountPrivate *priv;
2781  GList *child, *children, *descendants;
2782 
2783  /* errors */
2784  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2785 
2786  /* optimizations */
2787  priv = GET_PRIVATE(account);
2788  if (!priv->children)
2789  return NULL;
2790 
2791  descendants = NULL;
2792  children = g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2793  for (child = children; child; child = g_list_next(child))
2794  {
2795  descendants = g_list_append(descendants, child->data);
2796  descendants = g_list_concat(descendants,
2797  gnc_account_get_descendants_sorted(child->data));
2798  }
2799  g_list_free(children);
2800  return descendants;
2801 }
GList * gnc_account_get_descendants_sorted(const Account *account)
This function returns a GList containing all the descendants of the specified account, sorted at each level.
Definition: Account.c:2778
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.c:2147

◆ gnc_account_get_full_name()

gchar* gnc_account_get_full_name ( const Account account)

The gnc_account_get_full_name routine returns the fully qualified name of the account using the given separator char.

The name must be g_free'd after use. The fully qualified name of an account is the concatenation of the names of the account and all its ancestor accounts starting with the topmost account and ending with the given account. Each name is separated by the given character.

Note
: WAKE UP! Unlike all other gets, the string returned by gnc_account_get_full_name() must be freed by you the user !!! hack alert – since it breaks the rule of string allocation, maybe this routine should not be in this library, but some utility library?

Definition at line 3039 of file Account.c.

3040 {
3041  AccountPrivate *priv;
3042  const Account *a;
3043  char *fullname;
3044  gchar **names;
3045  int level;
3046 
3047  /* So much for hardening the API. Too many callers to this function don't
3048  * bother to check if they have a non-NULL pointer before calling. */
3049  if (NULL == account)
3050  return g_strdup("");
3051 
3052  /* errors */
3053  g_return_val_if_fail(GNC_IS_ACCOUNT(account), g_strdup(""));
3054 
3055  /* optimizations */
3056  priv = GET_PRIVATE(account);
3057  if (!priv->parent)
3058  return g_strdup("");
3059 
3060  /* Figure out how much space is needed by counting the nodes up to
3061  * the root. */
3062  level = 0;
3063  for (a = account; a; a = priv->parent)
3064  {
3065  priv = GET_PRIVATE(a);
3066  level++;
3067  }
3068 
3069  /* Get all the pointers in the right order. The root node "entry"
3070  * becomes the terminating NULL pointer for the array of strings. */
3071  names = g_malloc(level * sizeof(gchar *));
3072  names[--level] = NULL;
3073  for (a = account; level > 0; a = priv->parent)
3074  {
3075  priv = GET_PRIVATE(a);
3076  names[--level] = priv->accountName;
3077  }
3078 
3079  /* Build the full name */
3080  fullname = g_strjoinv(account_separator, names);
3081  g_free(names);
3082 
3083  return fullname;
3084 }
STRUCTS.

◆ gnc_account_get_parent()

Account* gnc_account_get_parent ( const Account account)

This routine returns a pointer to the parent of the specified account.

If the account has no parent, i.e it is either the root node or is a disconnected account, then its parent will be NULL.

Parameters
accountA pointer to any exiting account.
Returns
A pointer to the parent account node, or NULL if there is no parent account.

Definition at line 2624 of file Account.c.

2625 {
2626  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2627  return GET_PRIVATE(acc)->parent;
2628 }

◆ gnc_account_get_root()

Account* gnc_account_get_root ( Account account)

This routine returns the root account of the account tree that the specified account belongs to.

It is the equivalent of repeatedly calling the gnc_account_get_parent() routine until that routine returns NULL.

Parameters
accountA pointer to any existing account.
Returns
The root node of the account tree to which this account belongs. NULL if the account is not part of any account tree.

Definition at line 2631 of file Account.c.

2632 {
2633  AccountPrivate *priv;
2634 
2635  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2636 
2637  priv = GET_PRIVATE(acc);
2638  while (priv->parent)
2639  {
2640  acc = priv->parent;
2641  priv = GET_PRIVATE(acc);
2642  }
2643 
2644  return acc;
2645 }

◆ gnc_account_get_tree_depth()

gint gnc_account_get_tree_depth ( const Account account)

Return the number of levels of descendants accounts below the specified account.

The returned number does not include the specified account itself.

Parameters
accountThe account to query.
Returns
The number of levels of descendants.

Definition at line 2735 of file Account.c.

2736 {
2737  AccountPrivate *priv;
2738  GList *node;
2739  gint depth = 0, child_depth;
2740 
2741  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2742 
2743  priv = GET_PRIVATE(account);
2744  if (!priv->children)
2745  return 1;
2746 
2747  for (node = priv->children; node; node = g_list_next(node))
2748  {
2749  child_depth = gnc_account_get_tree_depth(node->data);
2750  depth = MAX(depth, child_depth);
2751  }
2752  return depth + 1;
2753 }
gint gnc_account_get_tree_depth(const Account *account)
Return the number of levels of descendants accounts below the specified account.
Definition: Account.c:2735

◆ gnc_account_get_type()

GType gnc_account_get_type ( void  )

Returns the GType type system description of the Account class.

This must not be confused with the GNCAccountType as returned by xaccAccountGetType().

◆ gnc_account_insert_split()

gboolean gnc_account_insert_split ( Account acc,
Split *  s 
)

Insert the given split from an account.

Parameters
accThe account to which the split should be added.
sThe split to be added.
Returns
TRUE is the split is successfully added to the set of splits in the account. FALSE if the addition fails for any reason (including that the split is already in the account).

Definition at line 1735 of file Account.c.

1736 {
1737  AccountPrivate *priv;
1738  GList *node;
1739 
1740  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1741  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1742 
1743  priv = GET_PRIVATE(acc);
1744  node = g_list_find(priv->splits, s);
1745  if (node)
1746  return FALSE;
1747 
1748  if (qof_instance_get_editlevel(acc) == 0)
1749  {
1750  priv->splits = g_list_insert_sorted(priv->splits, s,
1751  (GCompareFunc)xaccSplitOrder);
1752  }
1753  else
1754  {
1755  priv->splits = g_list_prepend(priv->splits, s);
1756  priv->sort_dirty = TRUE;
1757  }
1758 
1759  //FIXME: find better event
1760  qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, NULL);
1761  /* Also send an event based on the account */
1762  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_ADDED, s);
1763 
1764  priv->balance_dirty = TRUE;
1765 // DRH: Should the below be added? It is present in the delete path.
1766 // xaccAccountRecomputeBalance(acc);
1767  return TRUE;
1768 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1485
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234
#define GNC_EVENT_ITEM_ADDED
These events are used when a split is added to an account.
Definition: gnc-event.h:45

◆ gnc_account_is_root()

gboolean gnc_account_is_root ( const Account account)

This routine indicates whether the specified account is the root node of an account tree.

Parameters
accountA pointer to any account.
Returns
TRUE if this account is of type ROOT. FALSE otherwise.

Definition at line 2648 of file Account.c.

2649 {
2650  g_return_val_if_fail(GNC_IS_ACCOUNT(account), FALSE);
2651  return (GET_PRIVATE(account)->parent == NULL);
2652 }

◆ gnc_account_join_children()

void gnc_account_join_children ( Account to_parent,
Account from_parent 
)

The gnc_account_join_children() subroutine will move (reparent) all child accounts from the from_parent account to the to_parent account, preserving the account hierarchy.

It will also take care that the moved accounts will have the to_parent's book parent as well.

Definition at line 4765 of file Account.c.

4766 {
4767  AccountPrivate *from_priv;
4768  GList *children, *node;
4769 
4770  /* errors */
4771  g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
4772  g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
4773 
4774  /* optimizations */
4775  from_priv = GET_PRIVATE(from_parent);
4776  if (!from_priv->children)
4777  return;
4778 
4779  ENTER (" ");
4780  children = g_list_copy(from_priv->children);
4781  for (node = children; node; node = g_list_next(node))
4782  gnc_account_append_child(to_parent, node->data);
4783  g_list_free(children);
4784  LEAVE (" ");
4785 }
void gnc_account_append_child(Account *new_parent, Account *child)
This function will remove from the child account any pre-existing parent relationship, and will then add the account as a child of the new parent.
Definition: Account.c:2526
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:261
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:271

◆ gnc_account_list_name_violations()

GList* gnc_account_list_name_violations ( QofBook *  book,
const gchar *  separator 
)

Runs through all the accounts and returns a list of account names that contain the provided separator character.

This can be used to check if certain account names are invalid.

Parameters
bookPointer to the book with accounts to verify
separatorThe separator character to verify against
Returns
A GList of invalid account names. Should be freed with g_list_free if no longer needed.

Definition at line 199 of file Account.c.

200 {
201  Account *root_account = gnc_book_get_root_account(book);
202  GList *accounts, *node;
203  GList *invalid_list = NULL;
204 
205  g_return_val_if_fail (separator != NULL, NULL);
206 
207  if (root_account == NULL)
208  return NULL;
209 
210  accounts = gnc_account_get_descendants (root_account);
211  for (node = accounts; node; node = g_list_next(node))
212  {
213  Account *acct = (Account*)node->data;
214  gchar *acct_name = g_strdup ( xaccAccountGetName ( acct ) );
215 
216  if ( g_strstr_len ( acct_name, -1, separator ) )
217  invalid_list = g_list_prepend ( invalid_list, (gpointer) acct_name );
218  else
219  g_free ( acct_name );
220  }
221  if (accounts != NULL)
222  {
223  g_list_free(accounts);
224  }
225 
226  return invalid_list;
227 }
STRUCTS.
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.c:2756
const char * xaccAccountGetName(const Account *acc)
Get the account's name.
Definition: Account.c:3032

◆ gnc_account_merge_children()

void gnc_account_merge_children ( Account parent)

The gnc_account_merge_children() subroutine will go through an account, merging all child accounts that have the same name and description.

This function is useful when importing Quicken(TM) files.

Definition at line 4790 of file Account.c.

4791 {
4792  AccountPrivate *ppriv, *priv_a, *priv_b;
4793  GList *node_a, *node_b, *work, *worker;
4794 
4795  g_return_if_fail(GNC_IS_ACCOUNT(parent));
4796 
4797  ppriv = GET_PRIVATE(parent);
4798  for (node_a = ppriv->children; node_a; node_a = node_a->next)
4799  {
4800  Account *acc_a = node_a->data;
4801 
4802  priv_a = GET_PRIVATE(acc_a);
4803  for (node_b = node_a->next; node_b; node_b = g_list_next(node_b))
4804  {
4805  Account *acc_b = node_b->data;
4806 
4807  priv_b = GET_PRIVATE(acc_b);
4808  if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
4809  continue;
4810  if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
4811  continue;
4812  if (0 != null_strcmp(priv_a->description, priv_b->description))
4813  continue;
4814  if (0 != null_strcmp(xaccAccountGetColor(acc_a),
4815  xaccAccountGetColor(acc_b)))
4816  continue;
4817  if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
4818  continue;
4819  if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
4820  xaccAccountGetNotes(acc_b)))
4821  continue;
4822  if (priv_a->type != priv_b->type)
4823  continue;
4824 
4825  /* consolidate children */
4826  if (priv_b->children)
4827  {
4828  work = g_list_copy(priv_b->children);
4829  for (worker = work; worker; worker = g_list_next(worker))
4830  gnc_account_append_child (acc_a, (Account *)worker->data);
4831  g_list_free(work);
4832 
4833  qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, NULL);
4834  qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, NULL);
4835  }
4836 
4837  /* recurse to do the children's children */
4839 
4840  /* consolidate transactions */
4841  while (priv_b->splits)
4842  xaccSplitSetAccount (priv_b->splits->data, acc_a);
4843 
4844  /* move back one before removal. next iteration around the loop
4845  * will get the node after node_b */
4846  node_b = g_list_previous(node_b);
4847 
4848  /* The destroy function will remove from list -- node_a is ok,
4849  * it's before node_b */
4850  xaccAccountBeginEdit (acc_b);
4851  xaccAccountDestroy (acc_b);
4852  }
4853  }
4854 }
void gnc_account_append_child(Account *new_parent, Account *child)
This function will remove from the child account any pre-existing parent relationship, and will then add the account as a child of the new parent.
Definition: Account.c:2526
STRUCTS.
void xaccAccountDestroy(Account *acc)
The xaccAccountDestroy() routine can be used to get rid of an account.
Definition: Account.c:1415
const char * xaccAccountGetColor(const Account *acc)
Get the account's color.
Definition: Account.c:3101
gint null_strcmp(const gchar *da, const gchar *db)
The null_strcmp compares strings a and b the same way that strcmp() does, except that either may be n...
Definition: qofutil.cpp:123
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234
gboolean gnc_commodity_equiv(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equivalent.
void gnc_account_merge_children(Account *parent)
The gnc_account_merge_children() subroutine will go through an account, merging all child accounts th...
Definition: Account.c:4790
const char * xaccAccountGetNotes(const Account *acc)
Get the account's notes.
Definition: Account.c:3130

◆ gnc_account_n_children()

gint gnc_account_n_children ( const Account account)

Return the number of children of the specified account.

The returned number does not include the account itself.

Parameters
accountThe account to query.
Returns
The number of children of the specified account.

Definition at line 2677 of file Account.c.

2678 {
2679  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2680  return g_list_length(GET_PRIVATE(account)->children);
2681 }

◆ gnc_account_n_descendants()

gint gnc_account_n_descendants ( const Account account)

Return the number of descendants of the specified account.

The returned number does not include the account itself.

Parameters
accountThe account to query.
Returns
The number of descendants of the specified account.

Definition at line 2699 of file Account.c.

2700 {
2701  AccountPrivate *priv;
2702  GList *node;
2703  gint count = 0;
2704 
2705  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2706 
2707  priv = GET_PRIVATE(account);
2708  for (node = priv->children; node; node = g_list_next(node))
2709  {
2710  count += gnc_account_n_descendants(node->data) + 1;
2711  }
2712  return count;
2713 }
gint gnc_account_n_descendants(const Account *account)
Return the number of descendants of the specified account.
Definition: Account.c:2699

◆ gnc_account_name_violations_errmsg()

gchar* gnc_account_name_violations_errmsg ( const gchar *  separator,
GList *  invalid_account_names 
)

Composes a translatable error message showing which account names clash with the current account separator.

Can be called after gnc_account_list_name_violations to have a consistent error message in different parts of GnuCash

Parameters
separatorThe separator character that was verified against
invalid_account_namesA GList of invalid account names.
Returns
An error message that can be displayed to the user or logged. This message string should be freed with g_free when no longer needed.

Definition at line 162 of file Account.c.

163 {
164  GList *node;
165  gchar *message = NULL;
166  gchar *account_list = NULL;
167 
168  if ( !invalid_account_names )
169  return NULL;
170 
171  for ( node = invalid_account_names; node; node = g_list_next(node))
172  {
173  if ( !account_list )
174  account_list = node->data;
175  else
176  {
177  gchar *tmp_list = NULL;
178 
179  tmp_list = g_strconcat (account_list, "\n", node->data, NULL );
180  g_free ( account_list );
181  account_list = tmp_list;
182  }
183  }
184 
185  /* Translators: The first %s will be the account separator character,
186  the second %s is a list of account names.
187  The resulting string will be displayed to the user if there are
188  account names containing the separator character. */
189  message = g_strdup_printf(
190  _("The separator character \"%s\" is used in one or more account names.\n\n"
191  "This will result in unexpected behaviour. "
192  "Either change the account names or choose another separator character.\n\n"
193  "Below you will find the list of invalid account names:\n"
194  "%s"), separator, account_list );
195  g_free ( account_list );
196  return message;
197 }

◆ gnc_account_nth_child()

Account* gnc_account_nth_child ( const Account parent,
gint  num 
)

Return the n'th child account of the specified parent account.

If the parent account is not specified or the child index number is invalid, this function returns NULL.

Parameters
parentThe parent account to check.
numThe index number of the child account that should be returned.
Returns
A pointer to the specified child account, or NULL

Definition at line 2692 of file Account.c.

2693 {
2694  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), NULL);
2695  return g_list_nth_data(GET_PRIVATE(parent)->children, num);
2696 }

◆ gnc_account_remove_child()

void gnc_account_remove_child ( Account parent,
Account child 
)

This function will remove the specified child account from the specified parent account.

It will NOT free the associated memory or otherwise alter the account: the account can now be reparented to a new location. Note, however, that it will mark the old parents as having been modified.

Parameters
parentThe parent account from which the child should be removed.
childThe child account to remove.

Definition at line 2588 of file Account.c.

2589 {
2590  AccountPrivate *ppriv, *cpriv;
2591  GncEventData ed;
2592 
2593  if (!child) return;
2594 
2595  /* Note this routine might be called on accounts which
2596  * are not yet parented. */
2597  if (!parent) return;
2598 
2599  ppriv = GET_PRIVATE(parent);
2600  cpriv = GET_PRIVATE(child);
2601 
2602  if (cpriv->parent != parent)
2603  {
2604  PERR ("account not a child of parent");
2605  return;
2606  }
2607 
2608  /* Gather event data */
2609  ed.node = parent;
2610  ed.idx = g_list_index(ppriv->children, child);
2611 
2612  ppriv->children = g_list_remove(ppriv->children, child);
2613 
2614  /* Now send the event. */
2615  qof_event_gen(&child->inst, QOF_EVENT_REMOVE, &ed);
2616 
2617  /* clear the account's parent pointer after REMOVE event generation. */
2618  cpriv->parent = NULL;
2619 
2620  qof_event_gen (&parent->inst, QOF_EVENT_MODIFY, NULL);
2621 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:237
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234

◆ gnc_account_remove_split()

gboolean gnc_account_remove_split ( Account acc,
Split *  s 
)

Remove the given split from an account.

Parameters
accThe account from which the split should be removed.
sThe split to be removed.
Returns
TRUE is the split is successfully removed from the set of splits in the account. FALSE if the removal fails for any reason.

Definition at line 1771 of file Account.c.

1772 {
1773  AccountPrivate *priv;
1774  GList *node;
1775 
1776  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1777  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1778 
1779  priv = GET_PRIVATE(acc);
1780  node = g_list_find(priv->splits, s);
1781  if (NULL == node)
1782  return FALSE;
1783 
1784  priv->splits = g_list_delete_link(priv->splits, node);
1785  //FIXME: find better event type
1786  qof_event_gen(&acc->inst, QOF_EVENT_MODIFY, NULL);
1787  // And send the account-based event, too
1788  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_REMOVED, s);
1789 
1790  priv->balance_dirty = TRUE;
1792  return TRUE;
1793 }
void xaccAccountRecomputeBalance(Account *acc)
The following recompute the partial balances (stored with the transaction) and the total balance...
Definition: Account.c:2073
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234

◆ gnc_account_set_balance_dirty()

void gnc_account_set_balance_dirty ( Account acc)

Tell the account that the running balances may be incorrect and need to be recomputed.

Parameters
accSet the flag on this account.

Definition at line 1718 of file Account.c.

1719 {
1720  AccountPrivate *priv;
1721 
1722  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1723 
1724  if (qof_instance_get_destroying(acc))
1725  return;
1726 
1727  priv = GET_PRIVATE(acc);
1728  priv->balance_dirty = TRUE;
1729 }
gboolean qof_instance_get_destroying(gconstpointer ptr)
Retrieve the flag that indicates whether or not this object is about to be destroyed.

◆ gnc_account_set_sort_dirty()

void gnc_account_set_sort_dirty ( Account acc)

Tell the account believes that the splits may be incorrectly sorted and need to be resorted.

Parameters
accSet the flag on this account.

Definition at line 1704 of file Account.c.

1705 {
1706  AccountPrivate *priv;
1707 
1708  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1709 
1710  if (qof_instance_get_destroying(acc))
1711  return;
1712 
1713  priv = GET_PRIVATE(acc);
1714  priv->sort_dirty = TRUE;
1715 }
gboolean qof_instance_get_destroying(gconstpointer ptr)
Retrieve the flag that indicates whether or not this object is about to be destroyed.

◆ gnc_account_set_start_balance()

void gnc_account_set_start_balance ( Account acc,
const gnc_numeric  start_baln 
)

This function will set the starting commodity balance for this account.

This routine is intended for use with backends that do not return the complete list of splits for an account, but rather return a partial list. In such a case, the backend will typically return all of the splits after some certain date, and the 'starting balance' will represent the summation of the splits up to that date.

Definition at line 3198 of file Account.c.

3199 {
3200  AccountPrivate *priv;
3201 
3202  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3203 
3204  priv = GET_PRIVATE(acc);
3205  priv->starting_balance = start_baln;
3206  priv->balance_dirty = TRUE;
3207 }

◆ gnc_account_set_start_cleared_balance()

void gnc_account_set_start_cleared_balance ( Account acc,
const gnc_numeric  start_baln 
)

This function will set the starting cleared commodity balance for this account.

This routine is intended for use with backends that do not return the complete list of splits for an account, but rather return a partial list. In such a case, the backend will typically return all of the splits after some certain date, and the 'starting balance' will represent the summation of the splits up to that date.

Definition at line 3210 of file Account.c.

3212 {
3213  AccountPrivate *priv;
3214 
3215  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3216 
3217  priv = GET_PRIVATE(acc);
3218  priv->starting_cleared_balance = start_baln;
3219  priv->balance_dirty = TRUE;
3220 }

◆ gnc_account_set_start_reconciled_balance()

void gnc_account_set_start_reconciled_balance ( Account acc,
const gnc_numeric  start_baln 
)

This function will set the starting reconciled commodity balance for this account.

This routine is intended for use with backends that do not return the complete list of splits for an account, but rather return a partial list. In such a case, the backend will typically return all of the splits after some certain date, and the 'starting balance' will represent the summation of the splits up to that date.

Definition at line 3223 of file Account.c.

3225 {
3226  AccountPrivate *priv;
3227 
3228  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3229 
3230  priv = GET_PRIVATE(acc);
3231  priv->starting_reconciled_balance = start_baln;
3232  priv->balance_dirty = TRUE;
3233 }

◆ gnc_get_account_separator_string()

const gchar* gnc_get_account_separator_string ( void  )

Returns the account separation character chosen by the user.

Returns
The character to use.

Definition at line 132 of file Account.c.

133 {
134  return account_separator;
135 }

◆ xaccAccountBeginEdit()

void xaccAccountBeginEdit ( Account account)

The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account updates.

Definition at line 1295 of file Account.c.

1296 {
1297  g_return_if_fail(acc);
1298  qof_begin_edit(&acc->inst);
1299 }
gboolean qof_begin_edit(QofInstance *inst)
begin_edit

◆ xaccAccountCommitEdit()

void xaccAccountCommitEdit ( Account account)

ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account updates.

Definition at line 1336 of file Account.c.

1337 {
1338  AccountPrivate *priv;
1339  QofBook *book;
1340 
1341  g_return_if_fail(acc);
1342  if (!qof_commit_edit(&acc->inst)) return;
1343 
1344  /* If marked for deletion, get rid of subaccounts first,
1345  * and then the splits ... */
1346  priv = GET_PRIVATE(acc);
1347  if (qof_instance_get_destroying(acc))
1348  {
1349  GList *lp, *slist;
1350  QofCollection *col;
1351 
1352  qof_instance_increase_editlevel(acc);
1353 
1354  /* First, recursively free children */
1355  xaccFreeAccountChildren(acc);
1356 
1357  PINFO ("freeing splits for account %p (%s)",
1358  acc, priv->accountName ? priv->accountName : "(null)");
1359 
1360  book = qof_instance_get_book(acc);
1361 
1362  /* If book is shutting down, just clear the split list. The splits
1363  themselves will be destroyed by the transaction code */
1364  if (!qof_book_shutting_down(book))
1365  {
1366  slist = g_list_copy(priv->splits);
1367  for (lp = slist; lp; lp = lp->next)
1368  {
1369  Split *s = lp->data;
1370  xaccSplitDestroy (s);
1371  }
1372  g_list_free(slist);
1373  }
1374  else
1375  {
1376  g_list_free(priv->splits);
1377  priv->splits = NULL;
1378  }
1379 
1380  /* It turns out there's a case where this assertion does not hold:
1381  When the user tries to delete an Imbalance account, while also
1382  deleting all the splits in it. The splits will just get
1383  recreated and put right back into the same account!
1384 
1385  g_assert(priv->splits == NULL || qof_book_shutting_down(acc->inst.book));
1386  */
1387 
1388  if (!qof_book_shutting_down(book))
1389  {
1390  col = qof_book_get_collection(book, GNC_ID_TRANS);
1391  qof_collection_foreach(col, destroy_pending_splits_for_account, acc);
1392 
1393  /* the lots should be empty by now */
1394  for (lp = priv->lots; lp; lp = lp->next)
1395  {
1396  GNCLot *lot = lp->data;
1397  gnc_lot_destroy (lot);
1398  }
1399  }
1400  g_list_free(priv->lots);
1401  priv->lots = NULL;
1402 
1403  qof_instance_set_dirty(&acc->inst);
1404  qof_instance_decrease_editlevel(acc);
1405  }
1406  else
1407  {
1408  xaccAccountBringUpToDate(acc);
1409  }
1410 
1411  qof_commit_edit_part2(&acc->inst, on_err, on_done, acc_free);
1412 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:249
gboolean xaccSplitDestroy(Split *split)
Destructor.
Definition: Split.c:1456
gboolean qof_instance_get_destroying(gconstpointer ptr)
Retrieve the flag that indicates whether or not this object is about to be destroyed.
gboolean qof_commit_edit(QofInstance *inst)
commit_edit helpers
void qof_collection_foreach(const QofCollection *col, QofInstanceForeachCB cb_func, gpointer user_data)
Call the callback for each entity in the collection.
Definition: qofid.cpp:321
gboolean qof_commit_edit_part2(QofInstance *inst, void(*on_error)(QofInstance *, QofBackendError), void(*on_done)(QofInstance *), void(*on_free)(QofInstance *))
part2 – deal with the backend
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:599
gboolean qof_book_shutting_down(const QofBook *book)
Is the book shutting down?
Definition: qofbook.cpp:535

◆ xaccAccountDestroy()

void xaccAccountDestroy ( Account account)

The xaccAccountDestroy() routine can be used to get rid of an account.

The account should have been opened for editing (by calling xaccAccountBeginEdit()) before calling this routine.

Definition at line 1415 of file Account.c.

1416 {
1417  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1418 
1419  qof_instance_set_destroying(acc, TRUE);
1420 
1421  xaccAccountCommitEdit (acc);
1422 }
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336

◆ xaccAccountEqual()

gboolean xaccAccountEqual ( const Account a,
const Account b,
gboolean  check_guids 
)

Compare two accounts for equality - this is a deep compare.

Definition at line 1490 of file Account.c.

1491 {
1492  AccountPrivate *priv_aa, *priv_ab;
1493 
1494  if (!aa && !ab) return TRUE;
1495 
1496  g_return_val_if_fail(GNC_IS_ACCOUNT(aa), FALSE);
1497  g_return_val_if_fail(GNC_IS_ACCOUNT(ab), FALSE);
1498 
1499  priv_aa = GET_PRIVATE(aa);
1500  priv_ab = GET_PRIVATE(ab);
1501  if (priv_aa->type != priv_ab->type)
1502  {
1503  PWARN ("types differ: %d vs %d", priv_aa->type, priv_ab->type);
1504  return FALSE;
1505  }
1506 
1507  if (g_strcmp0(priv_aa->accountName, priv_ab->accountName) != 0)
1508  {
1509  PWARN ("names differ: %s vs %s", priv_aa->accountName, priv_ab->accountName);
1510  return FALSE;
1511  }
1512 
1513  if (g_strcmp0(priv_aa->accountCode, priv_ab->accountCode) != 0)
1514  {
1515  PWARN ("codes differ: %s vs %s", priv_aa->accountCode, priv_ab->accountCode);
1516  return FALSE;
1517  }
1518 
1519  if (g_strcmp0(priv_aa->description, priv_ab->description) != 0)
1520  {
1521  PWARN ("descriptions differ: %s vs %s", priv_aa->description, priv_ab->description);
1522  return FALSE;
1523  }
1524 
1525  if (!gnc_commodity_equal(priv_aa->commodity, priv_ab->commodity))
1526  {
1527  PWARN ("commodities differ");
1528  return FALSE;
1529  }
1530 
1531  if (check_guids)
1532  {
1533  if (qof_instance_guid_compare(aa, ab) != 0)
1534  {
1535  PWARN ("GUIDs differ");
1536  return FALSE;
1537  }
1538  }
1539 
1540  if (qof_instance_compare_kvp (QOF_INSTANCE (aa), QOF_INSTANCE (ab)) != 0)
1541  {
1542  char *frame_a;
1543  char *frame_b;
1544 
1545  frame_a = qof_instance_kvp_as_string (QOF_INSTANCE (aa));
1546  frame_b = qof_instance_kvp_as_string (QOF_INSTANCE (ab));
1547 
1548  PWARN ("kvp frames differ:\n%s\n\nvs\n\n%s", frame_a, frame_b);
1549 
1550  g_free (frame_a);
1551  g_free (frame_b);
1552 
1553  return FALSE;
1554  }
1555 
1556  if (!gnc_numeric_equal(priv_aa->starting_balance, priv_ab->starting_balance))
1557  {
1558  char *str_a;
1559  char *str_b;
1560 
1561  str_a = gnc_numeric_to_string(priv_aa->starting_balance);
1562  str_b = gnc_numeric_to_string(priv_ab->starting_balance);
1563 
1564  PWARN ("starting balances differ: %s vs %s", str_a, str_b);
1565 
1566  g_free (str_a);
1567  g_free (str_b);
1568 
1569  return FALSE;
1570  }
1571 
1572  if (!gnc_numeric_equal(priv_aa->starting_cleared_balance,
1573  priv_ab->starting_cleared_balance))
1574  {
1575  char *str_a;
1576  char *str_b;
1577 
1578  str_a = gnc_numeric_to_string(priv_aa->starting_cleared_balance);
1579  str_b = gnc_numeric_to_string(priv_ab->starting_cleared_balance);
1580 
1581  PWARN ("starting cleared balances differ: %s vs %s", str_a, str_b);
1582 
1583  g_free (str_a);
1584  g_free (str_b);
1585 
1586  return FALSE;
1587  }
1588 
1589  if (!gnc_numeric_equal(priv_aa->starting_reconciled_balance,
1590  priv_ab->starting_reconciled_balance))
1591  {
1592  char *str_a;
1593  char *str_b;
1594 
1595  str_a = gnc_numeric_to_string(priv_aa->starting_reconciled_balance);
1596  str_b = gnc_numeric_to_string(priv_ab->starting_reconciled_balance);
1597 
1598  PWARN ("starting reconciled balances differ: %s vs %s", str_a, str_b);
1599 
1600  g_free (str_a);
1601  g_free (str_b);
1602 
1603  return FALSE;
1604  }
1605 
1606  if (!gnc_numeric_equal(priv_aa->balance, priv_ab->balance))
1607  {
1608  char *str_a;
1609  char *str_b;
1610 
1611  str_a = gnc_numeric_to_string(priv_aa->balance);
1612  str_b = gnc_numeric_to_string(priv_ab->balance);
1613 
1614  PWARN ("balances differ: %s vs %s", str_a, str_b);
1615 
1616  g_free (str_a);
1617  g_free (str_b);
1618 
1619  return FALSE;
1620  }
1621 
1622  if (!gnc_numeric_equal(priv_aa->cleared_balance, priv_ab->cleared_balance))
1623  {
1624  char *str_a;
1625  char *str_b;
1626 
1627  str_a = gnc_numeric_to_string(priv_aa->cleared_balance);
1628  str_b = gnc_numeric_to_string(priv_ab->cleared_balance);
1629 
1630  PWARN ("cleared balances differ: %s vs %s", str_a, str_b);
1631 
1632  g_free (str_a);
1633  g_free (str_b);
1634 
1635  return FALSE;
1636  }
1637 
1638  if (!gnc_numeric_equal(priv_aa->reconciled_balance, priv_ab->reconciled_balance))
1639  {
1640  char *str_a;
1641  char *str_b;
1642 
1643  str_a = gnc_numeric_to_string(priv_aa->reconciled_balance);
1644  str_b = gnc_numeric_to_string(priv_ab->reconciled_balance);
1645 
1646  PWARN ("reconciled balances differ: %s vs %s", str_a, str_b);
1647 
1648  g_free (str_a);
1649  g_free (str_b);
1650 
1651  return FALSE;
1652  }
1653 
1654  /* no parent; always compare downwards. */
1655 
1656  {
1657  GList *la = priv_aa->splits;
1658  GList *lb = priv_ab->splits;
1659 
1660  if ((la && !lb) || (!la && lb))
1661  {
1662  PWARN ("only one has splits");
1663  return FALSE;
1664  }
1665 
1666  if (la && lb)
1667  {
1668  /* presume that the splits are in the same order */
1669  while (la && lb)
1670  {
1671  Split *sa = (Split *) la->data;
1672  Split *sb = (Split *) lb->data;
1673 
1674  if (!xaccSplitEqual(sa, sb, check_guids, TRUE, FALSE))
1675  {
1676  PWARN ("splits differ");
1677  return(FALSE);
1678  }
1679 
1680  la = la->next;
1681  lb = lb->next;
1682  }
1683 
1684  if ((la != NULL) || (lb != NULL))
1685  {
1686  PWARN ("number of splits differs");
1687  return(FALSE);
1688  }
1689  }
1690  }
1691 
1692  if (!xaccAcctChildrenEqual(priv_aa->children, priv_ab->children, check_guids))
1693  {
1694  PWARN ("children differ");
1695  return FALSE;
1696  }
1697 
1698  return(TRUE);
1699 }
gboolean gnc_numeric_equal(gnc_numeric a, gnc_numeric b)
Equivalence predicate: Returns TRUE (1) if a and b represent the same number.
gboolean gnc_commodity_equal(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equal.
gchar * gnc_numeric_to_string(gnc_numeric n)
Convert to string.
gboolean xaccSplitEqual(const Split *sa, const Split *sb, gboolean check_guids, gboolean check_balances, gboolean check_txn_splits)
Equality.
Definition: Split.c:776
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:243
gint qof_instance_guid_compare(gconstpointer ptr1, gconstpointer ptr2)
Compare the GncGUID values of two instances.

◆ xaccAccountGainsAccount()

Account* xaccAccountGainsAccount ( Account acc,
gnc_commodity *  curr 
)

Retrieve the gains account used by this account for the indicated currency, creating and recording a new one if necessary.

FIXME: There is at present no interface to designate an existing account, and the new account name is hard coded to "Orphaned Gains -- CUR"

FIXME: There is no provision for creating separate accounts for anything other than currency, e.g. holding period of a security.

Definition at line 4550 of file Account.c.

4551 {
4552  GValue v = G_VALUE_INIT;
4553  gchar *curr_name = g_strdup_printf ("/lot-mgmt/gains-act/%s",
4555  GncGUID *guid = NULL;
4556  Account *gains_account;
4557 
4558  g_return_val_if_fail (acc != NULL, NULL);
4559  qof_instance_get_kvp (QOF_INSTANCE(acc), curr_name, &v);
4560  if (G_VALUE_HOLDS_BOXED (&v))
4561  guid = (GncGUID*)g_value_get_boxed (&v);
4562  if (guid == NULL) /* No gains account for this currency */
4563  {
4564  gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc),
4565  curr);
4566  guid = (GncGUID*)qof_instance_get_guid (QOF_INSTANCE (gains_account));
4567  xaccAccountBeginEdit (acc);
4568  {
4569  GValue vr = G_VALUE_INIT;
4570  g_value_init (&vr, GNC_TYPE_GUID);
4571  g_value_set_boxed (&vr, guid);
4572  qof_instance_set_kvp (QOF_INSTANCE (acc), curr_name, &vr);
4573  qof_instance_set_dirty (QOF_INSTANCE (acc));
4574  }
4575  xaccAccountCommitEdit (acc);
4576  }
4577  else
4578  gains_account = xaccAccountLookup (guid,
4579  qof_instance_get_book(acc));
4580 
4581  g_free (curr_name);
4582  return gains_account;
4583 }
void qof_instance_get_kvp(const QofInstance *inst, const gchar *key, GValue *value)
Retrieves the contents of a KVP slot into a provided GValue.
const GncGUID * qof_instance_get_guid(gconstpointer inst)
Return the GncGUID of this instance.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
STRUCTS.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the 'unique' name for the specified commodity.
void qof_instance_set_kvp(QofInstance *inst, const gchar *key, const GValue *value)
Sets a KVP slot to a value from a GValue.
Account * gnc_account_get_root(Account *acc)
This routine returns the root account of the account tree that the specified account belongs to...
Definition: Account.c:2631
The type used to store guids in C.
Definition: guid.h:75
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.c:1842

◆ xaccAccountGetAutoInterestXfer()

gboolean xaccAccountGetAutoInterestXfer ( const Account account,
gboolean  default_value 
)

Returns a per-account flag: Prior to reconciling an account which charges or pays interest, this flag tells whether to prompt the user to enter a transaction for the interest charge or payment.

This per-account flag overrides the global preference.

Definition at line 4461 of file Account.c.

4462 {
4463  return boolean_from_key (acc, "reconcile-info/auto-interest-transfer");
4464 }

◆ xaccAccountGetCommoditySCU()

int xaccAccountGetCommoditySCU ( const Account account)

Return the SCU for the account.

If a non-standard SCU has been set for the account, that is returned; else the default SCU for the account commodity is returned.

Definition at line 2456 of file Account.c.

2457 {
2458  AccountPrivate *priv;
2459 
2460  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2461 
2462  priv = GET_PRIVATE(acc);
2463  if (priv->non_standard_scu || !priv->commodity)
2464  return priv->commodity_scu;
2465  return gnc_commodity_get_fraction(priv->commodity);
2466 }
int gnc_commodity_get_fraction(const gnc_commodity *cm)
Retrieve the fraction for the specified commodity.

◆ xaccAccountGetCommoditySCUi()

int xaccAccountGetCommoditySCUi ( const Account account)

Return the 'internal' SCU setting.

This returns the over-ride SCU for the account (which might not be set, and might be zero).

Definition at line 2449 of file Account.c.

2450 {
2451  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2452  return GET_PRIVATE(acc)->commodity_scu;
2453 }

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account account)

Return boolean, indicating whether this account uses a non-standard SCU.

Definition at line 2485 of file Account.c.

2486 {
2487  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2488  return GET_PRIVATE(acc)->non_standard_scu;
2489 }

◆ xaccAccountGetType()

GNCAccountType xaccAccountGetType ( const Account account)

Returns the account's account type.

This must not be confused with the GType as returned by gnc_account_get_type(), which is related to glib's type system.

Definition at line 3010 of file Account.c.

3011 {
3012  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
3013  return GET_PRIVATE(acc)->type;
3014 }
Not a type.
Definition: Account.h:105

◆ xaccAccountHasAncestor()

gboolean xaccAccountHasAncestor ( const Account acc,
const Account ancestor 
)

Returns true if the account is 'ancestor' or has 'ancestor' as an ancestor.

An ancestor account may be the accounts parent, its parent's parent, its parent's parent's parent, etc. Returns false if either one is NULL.

Definition at line 4007 of file Account.c.

4008 {
4009  const Account *parent;
4010 
4011  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4012  g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);
4013 
4014  parent = acc;
4015  while (parent && parent != ancestor)
4016  parent = GET_PRIVATE(parent)->parent;
4017 
4018  return (parent == ancestor);
4019 }
STRUCTS.

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account acc)

Returns true if the account is a stock, mutual fund or currency, otherwise false.

Definition at line 4252 of file Account.c.

4253 {
4254  AccountPrivate *priv;
4255 
4256  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4257 
4258  priv = GET_PRIVATE(acc);
4259  return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
4260  priv->type == ACCT_TYPE_CURRENCY);
4261 }
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:125
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:122
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:129

◆ xaccAccountLookup()

Account* xaccAccountLookup ( const GncGUID guid,
QofBook *  book 
)

The xaccAccountLookup() subroutine will return the account associated with the given id, or NULL if there is no such account.

Definition at line 1842 of file Account.c.

1843 {
1844  QofCollection *col;
1845  if (!guid || !book) return NULL;
1846  col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
1847  return (Account *) qof_collection_lookup_entity (col, guid);
1848 }
QofInstance * qof_collection_lookup_entity(const QofCollection *col, const GncGUID *guid)
Find the entity going only from its guid.
Definition: qofid.cpp:214
STRUCTS.
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:599

◆ xaccAccountOrder()

int xaccAccountOrder ( const Account account_1,
const Account account_2 
)

The xaccAccountOrder() subroutine defines a sorting order on accounts.

It takes pointers to two accounts, and returns an int < 0 if the first account is "less than" the second, returns an int > 0 if the first is "greater than" the second, and 0 if they are equal. To determine the sort order, first the account codes are compared, and if these are equal, then account types, then account names. If still equal, it compares GUID to ensure that there aren't any ties.

Definition at line 2147 of file Account.c.

2148 {
2149  AccountPrivate *priv_aa, *priv_ab;
2150  char *da, *db;
2151  char *endptr = NULL;
2152  int ta, tb, result;
2153  long la, lb;
2154 
2155  if ( aa && !ab ) return -1;
2156  if ( !aa && ab ) return +1;
2157  if ( !aa && !ab ) return 0;
2158 
2159  priv_aa = GET_PRIVATE(aa);
2160  priv_ab = GET_PRIVATE(ab);
2161 
2162  /* sort on accountCode strings */
2163  da = priv_aa->accountCode;
2164  db = priv_ab->accountCode;
2165 
2166  /* If accountCodes are both base 36 integers do an integer sort */
2167  la = strtoul (da, &endptr, 36);
2168  if ((*da != '\0') && (*endptr == '\0'))
2169  {
2170  lb = strtoul (db, &endptr, 36);
2171  if ((*db != '\0') && (*endptr == '\0'))
2172  {
2173  if (la < lb) return -1;
2174  if (la > lb) return +1;
2175  }
2176  }
2177 
2178  /* Otherwise do a string sort */
2179  result = g_strcmp0 (da, db);
2180  if (result)
2181  return result;
2182 
2183  /* if account-type-order array not initialized, initialize it */
2184  /* this will happen at most once during program invocation */
2185  if (-1 == revorder[0])
2186  {
2187  int i;
2188  for (i = 0; i < NUM_ACCOUNT_TYPES; i++)
2189  {
2190  revorder [typeorder[i]] = i;
2191  }
2192  }
2193 
2194  /* otherwise, sort on account type */
2195  ta = priv_aa->type;
2196  tb = priv_ab->type;
2197  ta = revorder[ta];
2198  tb = revorder[tb];
2199  if (ta < tb) return -1;
2200  if (ta > tb) return +1;
2201 
2202  /* otherwise, sort on accountName strings */
2203  da = priv_aa->accountName;
2204  db = priv_ab->accountName;
2205  result = safe_utf8_collate(da, db);
2206  if (result)
2207  return result;
2208 
2209  /* guarantee a stable sort */
2210  return qof_instance_guid_compare(aa, ab);
2211 }
int safe_utf8_collate(const char *da, const char *db)
Collate two UTF-8 strings.
stop here; the following types just aren&#39;t ready for prime time
Definition: Account.h:161
gint qof_instance_guid_compare(gconstpointer ptr1, gconstpointer ptr2)
Compare the GncGUID values of two instances.

◆ xaccAccountSetAutoInterestXfer()

void xaccAccountSetAutoInterestXfer ( Account account,
gboolean  value 
)

Sets a per-account flag: Prior to reconciling an account which charges or pays interest, this flag tells whether to prompt the user to enter a transaction for the interest charge or payment.

This per-account flag overrides the global preference.

Definition at line 4470 of file Account.c.

4471 {
4472  set_boolean_key (acc, "reconcile-info/auto-interest-transfer", option);
4473 }

◆ xaccAccountSetCommoditySCU()

void xaccAccountSetCommoditySCU ( Account account,
int  frac 
)

Set the SCU for the account.

Normally, this routine is not required, as the default SCU for an account is given by its commodity.

Definition at line 2433 of file Account.c.

2434 {
2435  AccountPrivate *priv;
2436 
2437  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2438 
2439  priv = GET_PRIVATE(acc);
2440  xaccAccountBeginEdit(acc);
2441  priv->commodity_scu = scu;
2442  if (scu != gnc_commodity_get_fraction(priv->commodity))
2443  priv->non_standard_scu = TRUE;
2444  mark_account(acc);
2445  xaccAccountCommitEdit(acc);
2446 }
int gnc_commodity_get_fraction(const gnc_commodity *cm)
Retrieve the fraction for the specified commodity.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account account,
gboolean  flag 
)

Set the flag indicating that this account uses a non-standard SCU.

Definition at line 2469 of file Account.c.

2470 {
2471  AccountPrivate *priv;
2472 
2473  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2474 
2475  priv = GET_PRIVATE(acc);
2476  if (priv->non_standard_scu == flag)
2477  return;
2478  xaccAccountBeginEdit(acc);
2479  priv->non_standard_scu = flag;
2480  mark_account (acc);
2481  xaccAccountCommitEdit(acc);
2482 }
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.c:1295
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.c:1336

◆ xaccAccountSortSplits()

void xaccAccountSortSplits ( Account acc,
gboolean  force 
)

The xaccAccountSortSplits() routine will resort the account's splits if the sort is dirty.

If 'force' is true, the account is sorted even if the editlevel is not zero.

Definition at line 1796 of file Account.c.

1797 {
1798  AccountPrivate *priv;
1799 
1800  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1801 
1802  priv = GET_PRIVATE(acc);
1803  if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
1804  return;
1805  priv->splits = g_list_sort(priv->splits, (GCompareFunc)xaccSplitOrder);
1806  priv->sort_dirty = FALSE;
1807  priv->balance_dirty = TRUE;
1808 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1485

◆ xaccCloneAccount()

Account* xaccCloneAccount ( const Account source,
QofBook *  book 
)

The xaccCloneAccount() routine makes a simple copy of the indicated account, placing it in the indicated book.

It copies the account type, name, description, and the kvp values; it does not copy splits/transactions. The book should have a commodity table in it that has commodities with the same unique name as the ones being copied in the account (the commodities in the clone will be those from the book).

Definition at line 1130 of file Account.c.

1131 {
1132  Account *ret;
1133  AccountPrivate *from_priv, *priv;
1134 
1135  g_return_val_if_fail(GNC_IS_ACCOUNT(from), NULL);
1136  g_return_val_if_fail(QOF_IS_BOOK(book), NULL);
1137 
1138  ENTER (" ");
1139  ret = g_object_new (GNC_TYPE_ACCOUNT, NULL);
1140  g_return_val_if_fail (ret, NULL);
1141 
1142  from_priv = GET_PRIVATE(from);
1143  priv = GET_PRIVATE(ret);
1144  xaccInitAccount (ret, book);
1145 
1146  /* Do not Begin/CommitEdit() here; give the caller
1147  * a chance to fix things up, and let them do it.
1148  * Also let caller issue the generate_event (EVENT_CREATE) */
1149  priv->type = from_priv->type;
1150 
1151  priv->accountName = CACHE_INSERT(from_priv->accountName);
1152  priv->accountCode = CACHE_INSERT(from_priv->accountCode);
1153  priv->description = CACHE_INSERT(from_priv->description);
1154 
1155  qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));
1156 
1157  /* The new book should contain a commodity that matches
1158  * the one in the old book. Find it, use it. */
1159  priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
1160  gnc_commodity_increment_usage_count(priv->commodity);
1161 
1162  priv->commodity_scu = from_priv->commodity_scu;
1163  priv->non_standard_scu = from_priv->non_standard_scu;
1164 
1165  qof_instance_set_dirty(&ret->inst);
1166  LEAVE (" ");
1167  return ret;
1168 }
STRUCTS.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:261
void gnc_commodity_increment_usage_count(gnc_commodity *cm)
Increment a commodity&#39;s internal counter that tracks how many accounts are using that commodity...
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:271
gnc_commodity * gnc_commodity_obtain_twin(const gnc_commodity *from, QofBook *book)
Given the commodity &#39;findlike&#39;, this routine will find and return the equivalent commodity (commodity...