GnuCash  4.901
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
 

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...
 
gboolean gnc_account_and_descendants_empty (Account *acc)
 
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...
 
void gnc_account_set_defer_bal_computation (Account *acc, gboolean defer)
 Set the defer balance flag. 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.
 
gboolean gnc_account_get_defer_bal_computation (Account *acc)
 Get the account's flag for deferred balance computation.
 
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...
 

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 at the end of the day before the date specified. More...
 
gnc_numeric xaccAccountGetReconciledBalanceAsOfDate (Account *account, time64 date)
 Get the reconciled balance of the account at the end of the day of the date specified. More...
 
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, const gnc_commodity *balance_currency, const 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 xaccAccountGetNoclosingBalanceAsOfDateInCurrency (Account *acc, time64 date, gnc_commodity *report_commodity, gboolean include_children)
 This function gets the balance at the end of the given date, ignoring closing entries, in the desired commodity. More...
 
gnc_numeric xaccAccountGetBalanceAsOfDateInCurrency (Account *account, time64 date, gnc_commodity *report_commodity, gboolean include_children)
 This function gets the balance at the end of the given date in the desired commodity. More...
 
gnc_numeric xaccAccountGetNoclosingBalanceChangeForPeriod (Account *acc, time64 date1, time64 date2, gboolean recurse)
 
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 248 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 101 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
174 #ifdef __cplusplus
175 };
176 #else
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:101
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. This function uses a static char*.

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

Definition at line 5286 of file Account.cpp.

5287 {
5288  static char *source = nullptr;
5289  if (!acc) return NULL;
5290 
5291  if (!xaccAccountIsPriced(acc)) return NULL;
5292 
5293  g_free (source);
5294  source = get_kvp_string_tag (acc, "old-price-source");
5295  return source;
5296 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4700

◆ 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 5274 of file Account.cpp.

5275 {
5276  if (!acc) return;
5277 
5278  if (xaccAccountIsPriced(acc))
5279  set_kvp_string_tag (acc, "old-price-source", src);
5280 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4700

◆ 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 2810 of file Account.cpp.

2811 {
2812  AccountPrivate *ppriv, *cpriv;
2813  Account *old_parent;
2814  QofCollection *col;
2815 
2816  /* errors */
2817  g_assert(GNC_IS_ACCOUNT(new_parent));
2818  g_assert(GNC_IS_ACCOUNT(child));
2819 
2820  /* optimizations */
2821  ppriv = GET_PRIVATE(new_parent);
2822  cpriv = GET_PRIVATE(child);
2823  old_parent = cpriv->parent;
2824  if (old_parent == new_parent)
2825  return;
2826 
2827  // xaccAccountBeginEdit(new_parent);
2828  xaccAccountBeginEdit(child);
2829  if (old_parent)
2830  {
2831  gnc_account_remove_child(old_parent, child);
2832 
2833  if (!qof_instance_books_equal(old_parent, new_parent))
2834  {
2835  /* hack alert -- this implementation is not exactly correct.
2836  * If the entity tables are not identical, then the 'from' book
2837  * may have a different backend than the 'to' book. This means
2838  * that we should get the 'from' backend to destroy this account,
2839  * and the 'to' backend to save it. Right now, this is broken.
2840  *
2841  * A 'correct' implementation similar to this is in Period.c
2842  * except its for transactions ...
2843  *
2844  * Note also, we need to reparent the children to the new book as well.
2845  */
2846  PWARN ("reparenting accounts across books is not correctly supported\n");
2847 
2848  qof_event_gen (&child->inst, QOF_EVENT_DESTROY, NULL);
2850  GNC_ID_ACCOUNT);
2851  qof_collection_insert_entity (col, &child->inst);
2852  qof_event_gen (&child->inst, QOF_EVENT_CREATE, NULL);
2853  }
2854  }
2855  cpriv->parent = new_parent;
2856  ppriv->children = g_list_append(ppriv->children, child);
2857  qof_instance_set_dirty(&new_parent->inst);
2858  qof_instance_set_dirty(&child->inst);
2859 
2860  /* Send events data. Warning: The call to commit_edit is also going
2861  * to send a MODIFY event. If the gtktreemodelfilter code gets the
2862  * MODIFY before it gets the ADD, it gets very confused and thinks
2863  * that two nodes have been added. */
2864  qof_event_gen (&child->inst, QOF_EVENT_ADD, NULL);
2865  // qof_event_gen (&new_parent->inst, QOF_EVENT_MODIFY, NULL);
2866 
2867  xaccAccountCommitEdit (child);
2868  // xaccAccountCommitEdit(new_parent);
2869 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void gnc_account_remove_child(Account *parent, Account *child)
This function will remove the specified child account from the specified parent account.
Definition: Account.cpp:2872
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:95
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.cpp:1458
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:527
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ 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 2968 of file Account.cpp.

2969 {
2970  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
2971  g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
2972  return g_list_index(GET_PRIVATE(parent)->children, child);
2973 }

◆ gnc_account_create_root()

Account* gnc_account_create_root ( QofBook *  book)

Create a new root level account.

Definition at line 1251 of file Account.cpp.

1252 {
1253  Account *root;
1254  AccountPrivate *rpriv;
1255 
1256  root = xaccMallocAccount(book);
1257  rpriv = GET_PRIVATE(root);
1258  xaccAccountBeginEdit(root);
1259  rpriv->type = ACCT_TYPE_ROOT;
1260  rpriv->accountName = qof_string_cache_replace(rpriv->accountName, "Root Account");
1261  mark_account (root);
1262  xaccAccountCommitEdit(root);
1263  gnc_book_set_root_account(book, root);
1264  return root;
1265 }
const char * qof_string_cache_replace(char const *dst, char const *src)
Same as CACHE_REPLACE below, but safe to call from C++.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1458
Account * xaccMallocAccount(QofBook *book)
Constructor.
Definition: Account.cpp:1237
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499
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 3236 of file Account.cpp.

3239 {
3240  const AccountPrivate *priv;
3241  GList *node;
3242 
3243  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3244  g_return_if_fail(thunk);
3245 
3246  priv = GET_PRIVATE(acc);
3247  for (node = priv->children; node; node = node->next)
3248  {
3249  thunk (static_cast<Account*>(node->data), user_data);
3250  }
3251 }

◆ 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 3254 of file Account.cpp.

3257 {
3258  account_foreach_descendant (acc, thunk, user_data, FALSE);
3259 }

◆ 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 3262 of file Account.cpp.

3265 {
3266  gpointer result {nullptr};
3267 
3268  g_return_val_if_fail (GNC_IS_ACCOUNT(acc), nullptr);
3269  g_return_val_if_fail (thunk, nullptr);
3270 
3271  auto priv{GET_PRIVATE(acc)};
3272 
3273  for (auto node = priv->children; node; node = node->next)
3274  {
3275  auto child = static_cast<Account*>(node->data);
3276  result = thunk (child, user_data);
3277  if (result) break;
3278 
3279  result = gnc_account_foreach_descendant_until (child, thunk, user_data);
3280  if (result) break;
3281  }
3282 
3283  return result;
3284 }
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 &#39;func&#39; on each...
Definition: Account.cpp:3262

◆ 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 2939 of file Account.cpp.

2940 {
2941  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2942  return g_list_copy(GET_PRIVATE(account)->children);
2943 }

◆ 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 2946 of file Account.cpp.

2947 {
2948  AccountPrivate *priv;
2949 
2950  /* errors */
2951  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2952 
2953  /* optimizations */
2954  priv = GET_PRIVATE(account);
2955  if (!priv->children)
2956  return NULL;
2957  return g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2958 }
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.cpp:2371

◆ 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 3464 of file Account.cpp.

3465 {
3466  gnc_commodity * commodity;
3467  g_return_val_if_fail (account, NULL);
3468 
3469  commodity = xaccAccountGetCommodity (account);
3470  if (gnc_commodity_is_currency(commodity))
3471  return commodity;
3472  else
3473  {
3474  const Account *parent_account = account;
3475  /* Account commodity is not a currency, walk up the tree until
3476  * we find a parent account that is a currency account and use
3477  * it's currency.
3478  */
3479  do
3480  {
3481  parent_account = gnc_account_get_parent (parent_account);
3482  if (parent_account)
3483  {
3484  commodity = xaccAccountGetCommodity (parent_account);
3485  if (gnc_commodity_is_currency(commodity))
3486  {
3487  return commodity;
3488  //break;
3489  }
3490  }
3491  }
3492  while (parent_account);
3493  }
3494  return NULL; // no suitable commodity found.
3495 }
Account * gnc_account_get_parent(const Account *acc)
This routine returns a pointer to the parent of the specified account.
Definition: Account.cpp:2908
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...
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account&#39;s commodity.
Definition: Account.cpp:3457

◆ 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 2998 of file Account.cpp.

2999 {
3000  AccountPrivate *priv;
3001  int depth = 0;
3002 
3003  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
3004 
3005  priv = GET_PRIVATE(account);
3006  while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
3007  {
3008  account = priv->parent;
3009  priv = GET_PRIVATE(account);
3010  depth++;
3011  }
3012 
3013  return depth;
3014 }
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 3045 of file Account.cpp.

3046 {
3047  GList* list = nullptr;
3048  account_foreach_descendant (account, collect_acct, &list, FALSE);
3049  return g_list_reverse (list);
3050 }

◆ 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 some 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 3053 of file Account.cpp.

3054 {
3055  GList* list = nullptr;
3056  account_foreach_descendant (account, collect_acct, &list, TRUE);
3057  return g_list_reverse (list);
3058 }

◆ 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 3317 of file Account.cpp.

3318 {
3319  AccountPrivate *priv;
3320  const Account *a;
3321  char *fullname;
3322  const gchar **names;
3323  int level;
3324 
3325  /* So much for hardening the API. Too many callers to this function don't
3326  * bother to check if they have a non-NULL pointer before calling. */
3327  if (NULL == account)
3328  return g_strdup("");
3329 
3330  /* errors */
3331  g_return_val_if_fail(GNC_IS_ACCOUNT(account), g_strdup(""));
3332 
3333  /* optimizations */
3334  priv = GET_PRIVATE(account);
3335  if (!priv->parent)
3336  return g_strdup("");
3337 
3338  /* Figure out how much space is needed by counting the nodes up to
3339  * the root. */
3340  level = 0;
3341  for (a = account; a; a = priv->parent)
3342  {
3343  priv = GET_PRIVATE(a);
3344  level++;
3345  }
3346 
3347  /* Get all the pointers in the right order. The root node "entry"
3348  * becomes the terminating NULL pointer for the array of strings. */
3349  names = (const gchar **)g_malloc(level * sizeof(gchar *));
3350  names[--level] = NULL;
3351  for (a = account; level > 0; a = priv->parent)
3352  {
3353  priv = GET_PRIVATE(a);
3354  names[--level] = priv->accountName;
3355  }
3356 
3357  /* Build the full name */
3358  fullname = g_strjoinv(account_separator, (gchar **)names);
3359  g_free(names);
3360 
3361  return fullname;
3362 }

◆ 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 2908 of file Account.cpp.

2909 {
2910  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2911  return GET_PRIVATE(acc)->parent;
2912 }

◆ 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 2915 of file Account.cpp.

2916 {
2917  AccountPrivate *priv;
2918 
2919  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2920 
2921  priv = GET_PRIVATE(acc);
2922  while (priv->parent)
2923  {
2924  acc = priv->parent;
2925  priv = GET_PRIVATE(acc);
2926  }
2927 
2928  return acc;
2929 }

◆ 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 3017 of file Account.cpp.

3018 {
3019  AccountPrivate *priv;
3020  GList *node;
3021  gint depth = 0, child_depth;
3022 
3023  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
3024 
3025  priv = GET_PRIVATE(account);
3026  if (!priv->children)
3027  return 1;
3028 
3029  for (node = priv->children; node; node = g_list_next(node))
3030  {
3031  child_depth = gnc_account_get_tree_depth(static_cast<Account const *>(node->data));
3032  depth = MAX(depth, child_depth);
3033  }
3034  return depth + 1;
3035 }
gint gnc_account_get_tree_depth(const Account *account)
Return the number of levels of descendants accounts below the specified account.
Definition: Account.cpp:3017

◆ 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().

Definition at line 27 of file gmock-Account.cpp.

28 {
29  return gnc_mockaccount_get_type();
30 }

◆ 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 1952 of file Account.cpp.

1953 {
1954  AccountPrivate *priv;
1955  GList *node;
1956 
1957  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1958  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1959 
1960  priv = GET_PRIVATE(acc);
1961  node = g_list_find(priv->splits, s);
1962  if (node)
1963  return FALSE;
1964 
1965  if (qof_instance_get_editlevel(acc) == 0)
1966  {
1967  priv->splits = g_list_insert_sorted(priv->splits, s,
1968  (GCompareFunc)xaccSplitOrder);
1969  }
1970  else
1971  {
1972  priv->splits = g_list_prepend(priv->splits, s);
1973  priv->sort_dirty = TRUE;
1974  }
1975 
1976  //FIXME: find better event
1977  qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, NULL);
1978  /* Also send an event based on the account */
1979  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_ADDED, s);
1980 
1981  priv->balance_dirty = TRUE;
1982 // DRH: Should the below be added? It is present in the delete path.
1983 // xaccAccountRecomputeBalance(acc);
1984  return TRUE;
1985 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1498
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
#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 2932 of file Account.cpp.

2933 {
2934  g_return_val_if_fail(GNC_IS_ACCOUNT(account), FALSE);
2935  return (GET_PRIVATE(account)->parent == NULL);
2936 }

◆ 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 5435 of file Account.cpp.

5436 {
5437  AccountPrivate *from_priv;
5438  GList *children, *node;
5439 
5440  /* errors */
5441  g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
5442  g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
5443 
5444  /* optimizations */
5445  from_priv = GET_PRIVATE(from_parent);
5446  if (!from_priv->children)
5447  return;
5448 
5449  ENTER (" ");
5450  children = g_list_copy(from_priv->children);
5451  for (node = children; node; node = g_list_next(node))
5452  gnc_account_append_child(to_parent, static_cast <Account*> (node->data));
5453  g_list_free(children);
5454  LEAVE (" ");
5455 }
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.cpp:2810
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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_full (value, g_free) when no longer needed.

Definition at line 272 of file Account.cpp.

273 {
274  g_return_val_if_fail (separator != NULL, nullptr);
275  if (!book) return nullptr;
276  ViolationData cb = { nullptr, separator };
277  gnc_account_foreach_descendant (gnc_book_get_root_account (book),
278  (AccountCb)check_acct_name, &cb);
279  return cb.list;
280 }
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 &#39;func&#39; on each...
Definition: Account.cpp:3254

◆ 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 5460 of file Account.cpp.

5461 {
5462  AccountPrivate *ppriv, *priv_a, *priv_b;
5463  GList *node_a, *node_b, *work, *worker;
5464 
5465  g_return_if_fail(GNC_IS_ACCOUNT(parent));
5466 
5467  ppriv = GET_PRIVATE(parent);
5468  for (node_a = ppriv->children; node_a; node_a = node_a->next)
5469  {
5470  Account *acc_a = static_cast <Account*> (node_a->data);
5471 
5472  priv_a = GET_PRIVATE(acc_a);
5473  for (node_b = node_a->next; node_b; node_b = g_list_next(node_b))
5474  {
5475  Account *acc_b = static_cast <Account*> (node_b->data);
5476 
5477  priv_b = GET_PRIVATE(acc_b);
5478  if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
5479  continue;
5480  if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
5481  continue;
5482  if (0 != null_strcmp(priv_a->description, priv_b->description))
5483  continue;
5484  if (0 != null_strcmp(xaccAccountGetColor(acc_a),
5485  xaccAccountGetColor(acc_b)))
5486  continue;
5487  if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
5488  continue;
5489  if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
5490  xaccAccountGetNotes(acc_b)))
5491  continue;
5492  if (priv_a->type != priv_b->type)
5493  continue;
5494 
5495  /* consolidate children */
5496  if (priv_b->children)
5497  {
5498  work = g_list_copy(priv_b->children);
5499  for (worker = work; worker; worker = g_list_next(worker))
5500  gnc_account_append_child (acc_a, (Account *)worker->data);
5501  g_list_free(work);
5502 
5503  qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, NULL);
5504  qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, NULL);
5505  }
5506 
5507  /* recurse to do the children's children */
5509 
5510  /* consolidate transactions */
5511  while (priv_b->splits)
5512  xaccSplitSetAccount (static_cast <Split*> (priv_b->splits->data), acc_a);
5513 
5514  /* move back one before removal. next iteration around the loop
5515  * will get the node after node_b */
5516  node_b = g_list_previous(node_b);
5517 
5518  /* The destroy function will remove from list -- node_a is ok,
5519  * it's before node_b */
5520  xaccAccountBeginEdit (acc_b);
5521  xaccAccountDestroy (acc_b);
5522  }
5523  }
5524 }
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.cpp:2810
void xaccAccountDestroy(Account *acc)
The xaccAccountDestroy() routine can be used to get rid of an account.
Definition: Account.cpp:1578
const char * xaccAccountGetColor(const Account *acc)
Get the account&#39;s color.
Definition: Account.cpp:3379
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.cpp:1458
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
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.cpp:5460
const char * xaccAccountGetNotes(const Account *acc)
Get the account&#39;s notes.
Definition: Account.cpp:3425

◆ 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 2961 of file Account.cpp.

2962 {
2963  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2964  return g_list_length(GET_PRIVATE(account)->children);
2965 }

◆ 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 2990 of file Account.cpp.

2991 {
2992  int count {0};
2993  account_foreach_descendant (account, count_acct, &count, FALSE);
2994  return count;
2995 }

◆ 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 234 of file Account.cpp.

235 {
236  gchar *message = NULL;
237 
238  if ( !invalid_account_names )
239  return NULL;
240 
241  auto account_list {gnc_g_list_stringjoin (invalid_account_names, "\n")};
242 
243  /* Translators: The first %s will be the account separator character,
244  the second %s is a list of account names.
245  The resulting string will be displayed to the user if there are
246  account names containing the separator character. */
247  message = g_strdup_printf(
248  _("The separator character \"%s\" is used in one or more account names.\n\n"
249  "This will result in unexpected behaviour. "
250  "Either change the account names or choose another separator character.\n\n"
251  "Below you will find the list of invalid account names:\n"
252  "%s"), separator, account_list );
253  g_free ( account_list );
254  return message;
255 }
gchar * gnc_g_list_stringjoin(GList *list_of_strings, const gchar *sep)
Return a string joining a GList whose elements are gchar* strings.

◆ 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 2976 of file Account.cpp.

2977 {
2978  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), NULL);
2979  return static_cast<Account*>(g_list_nth_data(GET_PRIVATE(parent)->children, num));
2980 }

◆ 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 2872 of file Account.cpp.

2873 {
2874  AccountPrivate *ppriv, *cpriv;
2875  GncEventData ed;
2876 
2877  if (!child) return;
2878 
2879  /* Note this routine might be called on accounts which
2880  * are not yet parented. */
2881  if (!parent) return;
2882 
2883  ppriv = GET_PRIVATE(parent);
2884  cpriv = GET_PRIVATE(child);
2885 
2886  if (cpriv->parent != parent)
2887  {
2888  PERR ("account not a child of parent");
2889  return;
2890  }
2891 
2892  /* Gather event data */
2893  ed.node = parent;
2894  ed.idx = g_list_index(ppriv->children, child);
2895 
2896  ppriv->children = g_list_remove(ppriv->children, child);
2897 
2898  /* Now send the event. */
2899  qof_event_gen(&child->inst, QOF_EVENT_REMOVE, &ed);
2900 
2901  /* clear the account's parent pointer after REMOVE event generation. */
2902  cpriv->parent = NULL;
2903 
2904  qof_event_gen (&parent->inst, QOF_EVENT_MODIFY, NULL);
2905 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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 1988 of file Account.cpp.

1989 {
1990  AccountPrivate *priv;
1991  GList *node;
1992 
1993  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1994  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1995 
1996  priv = GET_PRIVATE(acc);
1997  node = g_list_find(priv->splits, s);
1998  if (NULL == node)
1999  return FALSE;
2000 
2001  priv->splits = g_list_delete_link(priv->splits, node);
2002  //FIXME: find better event type
2003  qof_event_gen(&acc->inst, QOF_EVENT_MODIFY, NULL);
2004  // And send the account-based event, too
2005  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_REMOVED, s);
2006 
2007  priv->balance_dirty = TRUE;
2009  return TRUE;
2010 }
void xaccAccountRecomputeBalance(Account *acc)
The following recompute the partial balances (stored with the transaction) and the total balance...
Definition: Account.cpp:2290
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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 1912 of file Account.cpp.

1913 {
1914  AccountPrivate *priv;
1915 
1916  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1917 
1918  if (qof_instance_get_destroying(acc))
1919  return;
1920 
1921  priv = GET_PRIVATE(acc);
1922  priv->balance_dirty = TRUE;
1923 }
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_defer_bal_computation()

void gnc_account_set_defer_bal_computation ( Account acc,
gboolean  defer 
)

Set the defer balance flag.

If defer is true, the account balance is not automatically computed, which can save a lot of time if multiple operations have to be done on the same account. If defer is false, further operations on account will cause the balance to be recomputed as normal.

Parameters
accSet the flag on this account.
deferNew value for the flag.

Definition at line 1925 of file Account.cpp.

1926 {
1927  AccountPrivate *priv;
1928 
1929  g_return_if_fail (GNC_IS_ACCOUNT (acc));
1930 
1931  if (qof_instance_get_destroying (acc))
1932  return;
1933 
1934  priv = GET_PRIVATE (acc);
1935  priv->defer_bal_computation = defer;
1936 }
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 1898 of file Account.cpp.

1899 {
1900  AccountPrivate *priv;
1901 
1902  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1903 
1904  if (qof_instance_get_destroying(acc))
1905  return;
1906 
1907  priv = GET_PRIVATE(acc);
1908  priv->sort_dirty = TRUE;
1909 }
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 3500 of file Account.cpp.

3501 {
3502  AccountPrivate *priv;
3503 
3504  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3505 
3506  priv = GET_PRIVATE(acc);
3507  priv->starting_balance = start_baln;
3508  priv->balance_dirty = TRUE;
3509 }

◆ 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 3512 of file Account.cpp.

3514 {
3515  AccountPrivate *priv;
3516 
3517  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3518 
3519  priv = GET_PRIVATE(acc);
3520  priv->starting_cleared_balance = start_baln;
3521  priv->balance_dirty = TRUE;
3522 }

◆ 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 3525 of file Account.cpp.

3527 {
3528  AccountPrivate *priv;
3529 
3530  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3531 
3532  priv = GET_PRIVATE(acc);
3533  priv->starting_reconciled_balance = start_baln;
3534  priv->balance_dirty = TRUE;
3535 }

◆ 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 204 of file Account.cpp.

205 {
206  return account_separator;
207 }

◆ xaccAccountBeginEdit()

void xaccAccountBeginEdit ( Account account)

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

Definition at line 1458 of file Account.cpp.

1459 {
1460  g_return_if_fail(acc);
1461  qof_begin_edit(&acc->inst);
1462 }
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 1499 of file Account.cpp.

1500 {
1501  AccountPrivate *priv;
1502  QofBook *book;
1503 
1504  g_return_if_fail(acc);
1505  if (!qof_commit_edit(&acc->inst)) return;
1506 
1507  /* If marked for deletion, get rid of subaccounts first,
1508  * and then the splits ... */
1509  priv = GET_PRIVATE(acc);
1510  if (qof_instance_get_destroying(acc))
1511  {
1512  GList *lp, *slist;
1513  QofCollection *col;
1514 
1515  qof_instance_increase_editlevel(acc);
1516 
1517  /* First, recursively free children */
1518  xaccFreeAccountChildren(acc);
1519 
1520  PINFO ("freeing splits for account %p (%s)",
1521  acc, priv->accountName ? priv->accountName : "(null)");
1522 
1523  book = qof_instance_get_book(acc);
1524 
1525  /* If book is shutting down, just clear the split list. The splits
1526  themselves will be destroyed by the transaction code */
1527  if (!qof_book_shutting_down(book))
1528  {
1529  slist = g_list_copy(priv->splits);
1530  for (lp = slist; lp; lp = lp->next)
1531  {
1532  Split *s = static_cast<Split *>(lp->data);
1533  xaccSplitDestroy (s);
1534  }
1535  g_list_free(slist);
1536  }
1537  else
1538  {
1539  g_list_free(priv->splits);
1540  priv->splits = NULL;
1541  }
1542 
1543  /* It turns out there's a case where this assertion does not hold:
1544  When the user tries to delete an Imbalance account, while also
1545  deleting all the splits in it. The splits will just get
1546  recreated and put right back into the same account!
1547 
1548  g_assert(priv->splits == NULL || qof_book_shutting_down(acc->inst.book));
1549  */
1550 
1551  if (!qof_book_shutting_down(book))
1552  {
1553  col = qof_book_get_collection(book, GNC_ID_TRANS);
1554  qof_collection_foreach(col, destroy_pending_splits_for_account, acc);
1555 
1556  /* the lots should be empty by now */
1557  for (lp = priv->lots; lp; lp = lp->next)
1558  {
1559  GNCLot *lot = static_cast<GNCLot*>(lp->data);
1560  gnc_lot_destroy (lot);
1561  }
1562  }
1563  g_list_free(priv->lots);
1564  priv->lots = NULL;
1565 
1566  qof_instance_set_dirty(&acc->inst);
1567  qof_instance_decrease_editlevel(acc);
1568  }
1569  else
1570  {
1571  xaccAccountBringUpToDate(acc);
1572  }
1573 
1574  qof_commit_edit_part2(&acc->inst, on_err, on_done, acc_free);
1575 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
gboolean xaccSplitDestroy(Split *split)
Destructor.
Definition: Split.c:1468
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:320
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:527
gboolean qof_book_shutting_down(const QofBook *book)
Is the book shutting down?
Definition: qofbook.cpp:454

◆ 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 1578 of file Account.cpp.

1579 {
1580  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1581 
1582  qof_instance_set_destroying(acc, TRUE);
1583 
1584  xaccAccountCommitEdit (acc);
1585 }
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ 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 1653 of file Account.cpp.

1654 {
1655  AccountPrivate *priv_aa, *priv_ab;
1656 
1657  if (!aa && !ab) return TRUE;
1658 
1659  g_return_val_if_fail(GNC_IS_ACCOUNT(aa), FALSE);
1660  g_return_val_if_fail(GNC_IS_ACCOUNT(ab), FALSE);
1661 
1662  priv_aa = GET_PRIVATE(aa);
1663  priv_ab = GET_PRIVATE(ab);
1664  if (priv_aa->type != priv_ab->type)
1665  {
1666  PWARN ("types differ: %d vs %d", priv_aa->type, priv_ab->type);
1667  return FALSE;
1668  }
1669 
1670  if (g_strcmp0(priv_aa->accountName, priv_ab->accountName) != 0)
1671  {
1672  PWARN ("names differ: %s vs %s", priv_aa->accountName, priv_ab->accountName);
1673  return FALSE;
1674  }
1675 
1676  if (g_strcmp0(priv_aa->accountCode, priv_ab->accountCode) != 0)
1677  {
1678  PWARN ("codes differ: %s vs %s", priv_aa->accountCode, priv_ab->accountCode);
1679  return FALSE;
1680  }
1681 
1682  if (g_strcmp0(priv_aa->description, priv_ab->description) != 0)
1683  {
1684  PWARN ("descriptions differ: %s vs %s", priv_aa->description, priv_ab->description);
1685  return FALSE;
1686  }
1687 
1688  if (!gnc_commodity_equal(priv_aa->commodity, priv_ab->commodity))
1689  {
1690  PWARN ("commodities differ");
1691  return FALSE;
1692  }
1693 
1694  if (check_guids)
1695  {
1696  if (qof_instance_guid_compare(aa, ab) != 0)
1697  {
1698  PWARN ("GUIDs differ");
1699  return FALSE;
1700  }
1701  }
1702 
1703  if (qof_instance_compare_kvp (QOF_INSTANCE (aa), QOF_INSTANCE (ab)) != 0)
1704  {
1705  char *frame_a;
1706  char *frame_b;
1707 
1708  frame_a = qof_instance_kvp_as_string (QOF_INSTANCE (aa));
1709  frame_b = qof_instance_kvp_as_string (QOF_INSTANCE (ab));
1710 
1711  PWARN ("kvp frames differ:\n%s\n\nvs\n\n%s", frame_a, frame_b);
1712 
1713  g_free (frame_a);
1714  g_free (frame_b);
1715 
1716  return FALSE;
1717  }
1718 
1719  if (!gnc_numeric_equal(priv_aa->starting_balance, priv_ab->starting_balance))
1720  {
1721  char *str_a;
1722  char *str_b;
1723 
1724  str_a = gnc_numeric_to_string(priv_aa->starting_balance);
1725  str_b = gnc_numeric_to_string(priv_ab->starting_balance);
1726 
1727  PWARN ("starting balances differ: %s vs %s", str_a, str_b);
1728 
1729  g_free (str_a);
1730  g_free (str_b);
1731 
1732  return FALSE;
1733  }
1734 
1735  if (!gnc_numeric_equal(priv_aa->starting_noclosing_balance,
1736  priv_ab->starting_noclosing_balance))
1737  {
1738  char *str_a;
1739  char *str_b;
1740 
1741  str_a = gnc_numeric_to_string(priv_aa->starting_noclosing_balance);
1742  str_b = gnc_numeric_to_string(priv_ab->starting_noclosing_balance);
1743 
1744  PWARN ("starting noclosing balances differ: %s vs %s", str_a, str_b);
1745 
1746  g_free (str_a);
1747  g_free (str_b);
1748 
1749  return FALSE;
1750  }
1751  if (!gnc_numeric_equal(priv_aa->starting_cleared_balance,
1752  priv_ab->starting_cleared_balance))
1753  {
1754  char *str_a;
1755  char *str_b;
1756 
1757  str_a = gnc_numeric_to_string(priv_aa->starting_cleared_balance);
1758  str_b = gnc_numeric_to_string(priv_ab->starting_cleared_balance);
1759 
1760  PWARN ("starting cleared balances differ: %s vs %s", str_a, str_b);
1761 
1762  g_free (str_a);
1763  g_free (str_b);
1764 
1765  return FALSE;
1766  }
1767 
1768  if (!gnc_numeric_equal(priv_aa->starting_reconciled_balance,
1769  priv_ab->starting_reconciled_balance))
1770  {
1771  char *str_a;
1772  char *str_b;
1773 
1774  str_a = gnc_numeric_to_string(priv_aa->starting_reconciled_balance);
1775  str_b = gnc_numeric_to_string(priv_ab->starting_reconciled_balance);
1776 
1777  PWARN ("starting reconciled balances differ: %s vs %s", str_a, str_b);
1778 
1779  g_free (str_a);
1780  g_free (str_b);
1781 
1782  return FALSE;
1783  }
1784 
1785  if (!gnc_numeric_equal(priv_aa->balance, priv_ab->balance))
1786  {
1787  char *str_a;
1788  char *str_b;
1789 
1790  str_a = gnc_numeric_to_string(priv_aa->balance);
1791  str_b = gnc_numeric_to_string(priv_ab->balance);
1792 
1793  PWARN ("balances differ: %s vs %s", str_a, str_b);
1794 
1795  g_free (str_a);
1796  g_free (str_b);
1797 
1798  return FALSE;
1799  }
1800 
1801  if (!gnc_numeric_equal(priv_aa->noclosing_balance, priv_ab->noclosing_balance))
1802  {
1803  char *str_a;
1804  char *str_b;
1805 
1806  str_a = gnc_numeric_to_string(priv_aa->noclosing_balance);
1807  str_b = gnc_numeric_to_string(priv_ab->noclosing_balance);
1808 
1809  PWARN ("noclosing balances differ: %s vs %s", str_a, str_b);
1810 
1811  g_free (str_a);
1812  g_free (str_b);
1813 
1814  return FALSE;
1815  }
1816  if (!gnc_numeric_equal(priv_aa->cleared_balance, priv_ab->cleared_balance))
1817  {
1818  char *str_a;
1819  char *str_b;
1820 
1821  str_a = gnc_numeric_to_string(priv_aa->cleared_balance);
1822  str_b = gnc_numeric_to_string(priv_ab->cleared_balance);
1823 
1824  PWARN ("cleared balances differ: %s vs %s", str_a, str_b);
1825 
1826  g_free (str_a);
1827  g_free (str_b);
1828 
1829  return FALSE;
1830  }
1831 
1832  if (!gnc_numeric_equal(priv_aa->reconciled_balance, priv_ab->reconciled_balance))
1833  {
1834  char *str_a;
1835  char *str_b;
1836 
1837  str_a = gnc_numeric_to_string(priv_aa->reconciled_balance);
1838  str_b = gnc_numeric_to_string(priv_ab->reconciled_balance);
1839 
1840  PWARN ("reconciled balances differ: %s vs %s", str_a, str_b);
1841 
1842  g_free (str_a);
1843  g_free (str_b);
1844 
1845  return FALSE;
1846  }
1847 
1848  /* no parent; always compare downwards. */
1849 
1850  {
1851  GList *la = priv_aa->splits;
1852  GList *lb = priv_ab->splits;
1853 
1854  if ((la && !lb) || (!la && lb))
1855  {
1856  PWARN ("only one has splits");
1857  return FALSE;
1858  }
1859 
1860  if (la && lb)
1861  {
1862  /* presume that the splits are in the same order */
1863  while (la && lb)
1864  {
1865  Split *sa = (Split *) la->data;
1866  Split *sb = (Split *) lb->data;
1867 
1868  if (!xaccSplitEqual(sa, sb, check_guids, TRUE, FALSE))
1869  {
1870  PWARN ("splits differ");
1871  return(FALSE);
1872  }
1873 
1874  la = la->next;
1875  lb = lb->next;
1876  }
1877 
1878  if ((la != NULL) || (lb != NULL))
1879  {
1880  PWARN ("number of splits differs");
1881  return(FALSE);
1882  }
1883  }
1884  }
1885 
1886  if (!xaccAcctChildrenEqual(priv_aa->children, priv_ab->children, check_guids))
1887  {
1888  PWARN ("children differ");
1889  return FALSE;
1890  }
1891 
1892  return(TRUE);
1893 }
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:771
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
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 5234 of file Account.cpp.

5235 {
5236  GValue v = G_VALUE_INIT;
5237  std::vector<std::string> path {KEY_LOT_MGMT, "gains-acct",
5239  GncGUID *guid = NULL;
5240  Account *gains_account;
5241 
5242  g_return_val_if_fail (acc != NULL, NULL);
5243  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, path);
5244  if (G_VALUE_HOLDS_BOXED (&v))
5245  guid = (GncGUID*)g_value_get_boxed (&v);
5246  if (guid == NULL) /* No gains account for this currency */
5247  {
5248  gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc),
5249  curr);
5250  guid = (GncGUID*)qof_instance_get_guid (QOF_INSTANCE (gains_account));
5251  xaccAccountBeginEdit (acc);
5252  {
5253  GValue vr = G_VALUE_INIT;
5254  g_value_init (&vr, GNC_TYPE_GUID);
5255  g_value_set_boxed (&vr, guid);
5256  qof_instance_set_path_kvp (QOF_INSTANCE (acc), &vr, path);
5257  qof_instance_set_dirty (QOF_INSTANCE (acc));
5258  g_value_unset (&vr);
5259  }
5260  xaccAccountCommitEdit (acc);
5261  }
5262  else
5263  gains_account = xaccAccountLookup (guid,
5264  qof_instance_get_book(acc));
5265 
5266  g_value_unset (&v);
5267  return gains_account;
5268 }
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.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1458
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the &#39;unique&#39; name for the specified commodity.
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.cpp:2915
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.cpp:1499
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.cpp:2059

◆ xaccAccountGetBalanceAsOfDate()

gnc_numeric xaccAccountGetBalanceAsOfDate ( Account account,
time64  date 
)

Get the balance of the account at the end of the day before the date specified.

Definition at line 3629 of file Account.cpp.

3630 {
3631  return GetBalanceAsOfDate (acc, date, FALSE);
3632 }

◆ xaccAccountGetBalanceAsOfDateInCurrency()

gnc_numeric xaccAccountGetBalanceAsOfDateInCurrency ( Account account,
time64  date,
gnc_commodity *  report_commodity,
gboolean  include_children 
)

This function gets the balance at the end of the given date in the desired commodity.

Definition at line 3959 of file Account.cpp.

3962 {
3963  return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive (
3964  acc, date, xaccAccountGetBalanceAsOfDate, report_commodity,
3965  include_children);
3966 }
gnc_numeric xaccAccountGetBalanceAsOfDate(Account *acc, time64 date)
Get the balance of the account at the end of the day before the date specified.
Definition: Account.cpp:3629

◆ 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 2710 of file Account.cpp.

2711 {
2712  AccountPrivate *priv;
2713 
2714  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2715 
2716  priv = GET_PRIVATE(acc);
2717  if (priv->non_standard_scu || !priv->commodity)
2718  return priv->commodity_scu;
2719  return gnc_commodity_get_fraction(priv->commodity);
2720 }
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 2703 of file Account.cpp.

2704 {
2705  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2706  return GET_PRIVATE(acc)->commodity_scu;
2707 }

◆ xaccAccountGetNoclosingBalanceAsOfDateInCurrency()

gnc_numeric xaccAccountGetNoclosingBalanceAsOfDateInCurrency ( Account acc,
time64  date,
gnc_commodity *  report_commodity,
gboolean  include_children 
)

This function gets the balance at the end of the given date, ignoring closing entries, in the desired commodity.

Definition at line 3969 of file Account.cpp.

3972 {
3973  return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive
3974  (acc, date, xaccAccountGetNoclosingBalanceAsOfDate,
3975  report_commodity, include_children);
3976 }

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account account)

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

Definition at line 2739 of file Account.cpp.

2740 {
2741  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2742  return GET_PRIVATE(acc)->non_standard_scu;
2743 }

◆ xaccAccountGetReconciledBalanceAsOfDate()

gnc_numeric xaccAccountGetReconciledBalanceAsOfDate ( Account account,
time64  date 
)

Get the reconciled balance of the account at the end of the day of the date specified.

Definition at line 3641 of file Account.cpp.

3642 {
3643  gnc_numeric balance = gnc_numeric_zero();
3644 
3645  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), gnc_numeric_zero());
3646 
3647  for (GList *node = GET_PRIVATE(acc)->splits; node; node = node->next)
3648  {
3649  Split *split = (Split*) node->data;
3650  if ((xaccSplitGetReconcile (split) == YREC) &&
3651  (xaccSplitGetDateReconciled (split) <= date))
3652  balance = gnc_numeric_add_fixed (balance, xaccSplitGetAmount (split));
3653  };
3654 
3655  return balance;
3656 }
char xaccSplitGetReconcile(const Split *split)
Returns the value of the reconcile flag.
#define YREC
The Split has been reconciled.
Definition: Split.h:72
time64 xaccSplitGetDateReconciled(const Split *split)
Retrieve the date when the Split was reconciled.
Definition: Split.c:1818
gnc_numeric xaccSplitGetAmount(const Split *split)
Returns the amount of the split in the account&#39;s commodity.
Definition: gmock-Split.cpp:69

◆ 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 3288 of file Account.cpp.

3289 {
3290  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
3291  return GET_PRIVATE(acc)->type;
3292 }
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 4373 of file Account.cpp.

4374 {
4375  const Account *parent;
4376 
4377  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4378  g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);
4379 
4380  parent = acc;
4381  while (parent && parent != ancestor)
4382  parent = GET_PRIVATE(parent)->parent;
4383 
4384  return (parent == ancestor);
4385 }

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account acc)

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

Definition at line 4700 of file Account.cpp.

4701 {
4702  AccountPrivate *priv;
4703 
4704  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4705 
4706  priv = GET_PRIVATE(acc);
4707  return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
4708  priv->type == ACCT_TYPE_CURRENCY);
4709 }
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 2059 of file Account.cpp.

2060 {
2061  QofCollection *col;
2062  if (!guid || !book) return NULL;
2063  col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
2064  return (Account *) qof_collection_lookup_entity (col, guid);
2065 }
QofInstance * qof_collection_lookup_entity(const QofCollection *col, const GncGUID *guid)
Find the entity going only from its guid.
Definition: qofid.cpp:212
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:527

◆ 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 2371 of file Account.cpp.

2372 {
2373  AccountPrivate *priv_aa, *priv_ab;
2374  const char *da, *db;
2375  char *endptr = NULL;
2376  int ta, tb, result;
2377  long la, lb;
2378 
2379  if ( aa && !ab ) return -1;
2380  if ( !aa && ab ) return +1;
2381  if ( !aa && !ab ) return 0;
2382 
2383  priv_aa = GET_PRIVATE(aa);
2384  priv_ab = GET_PRIVATE(ab);
2385 
2386  /* sort on accountCode strings */
2387  da = priv_aa->accountCode;
2388  db = priv_ab->accountCode;
2389 
2390  /* Otherwise do a string sort */
2391  result = g_strcmp0 (da, db);
2392  if (result)
2393  return result;
2394 
2395  /* if account-type-order array not initialized, initialize it */
2396  /* this will happen at most once during program invocation */
2397  if (-1 == revorder[0])
2398  {
2399  int i;
2400  for (i = 0; i < NUM_ACCOUNT_TYPES; i++)
2401  {
2402  revorder [typeorder[i]] = i;
2403  }
2404  }
2405 
2406  /* otherwise, sort on account type */
2407  ta = priv_aa->type;
2408  tb = priv_ab->type;
2409  ta = revorder[ta];
2410  tb = revorder[tb];
2411  if (ta < tb) return -1;
2412  if (ta > tb) return +1;
2413 
2414  /* otherwise, sort on accountName strings */
2415  da = priv_aa->accountName;
2416  db = priv_ab->accountName;
2417  result = safe_utf8_collate(da, db);
2418  if (result)
2419  return result;
2420 
2421  /* guarantee a stable sort */
2422  return qof_instance_guid_compare(aa, ab);
2423 }
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.

◆ 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 2687 of file Account.cpp.

2688 {
2689  AccountPrivate *priv;
2690 
2691  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2692 
2693  priv = GET_PRIVATE(acc);
2694  xaccAccountBeginEdit(acc);
2695  priv->commodity_scu = scu;
2696  if (scu != gnc_commodity_get_fraction(priv->commodity))
2697  priv->non_standard_scu = TRUE;
2698  mark_account(acc);
2699  xaccAccountCommitEdit(acc);
2700 }
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.cpp:1458
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account account,
gboolean  flag 
)

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

Definition at line 2723 of file Account.cpp.

2724 {
2725  AccountPrivate *priv;
2726 
2727  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2728 
2729  priv = GET_PRIVATE(acc);
2730  if (priv->non_standard_scu == flag)
2731  return;
2732  xaccAccountBeginEdit(acc);
2733  priv->non_standard_scu = flag;
2734  mark_account (acc);
2735  xaccAccountCommitEdit(acc);
2736 }
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1458
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ 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 2013 of file Account.cpp.

2014 {
2015  AccountPrivate *priv;
2016 
2017  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2018 
2019  priv = GET_PRIVATE(acc);
2020  if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
2021  return;
2022  priv->splits = g_list_sort(priv->splits, (GCompareFunc)xaccSplitOrder);
2023  priv->sort_dirty = FALSE;
2024  priv->balance_dirty = TRUE;
2025 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1498

◆ 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 1268 of file Account.cpp.

1269 {
1270  Account *ret;
1271  AccountPrivate *from_priv, *priv;
1272 
1273  g_return_val_if_fail(GNC_IS_ACCOUNT(from), NULL);
1274  g_return_val_if_fail(QOF_IS_BOOK(book), NULL);
1275 
1276  ENTER (" ");
1277  ret = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, NULL));
1278  g_return_val_if_fail (ret, NULL);
1279 
1280  from_priv = GET_PRIVATE(from);
1281  priv = GET_PRIVATE(ret);
1282  xaccInitAccount (ret, book);
1283 
1284  /* Do not Begin/CommitEdit() here; give the caller
1285  * a chance to fix things up, and let them do it.
1286  * Also let caller issue the generate_event (EVENT_CREATE) */
1287  priv->type = from_priv->type;
1288 
1289  priv->accountName = qof_string_cache_replace(priv->accountName, from_priv->accountName);
1290  priv->accountCode = qof_string_cache_replace(priv->accountCode, from_priv->accountCode);
1291  priv->description = qof_string_cache_replace(priv->description, from_priv->description);
1292 
1293  qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));
1294 
1295  /* The new book should contain a commodity that matches
1296  * the one in the old book. Find it, use it. */
1297  priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
1298  gnc_commodity_increment_usage_count(priv->commodity);
1299 
1300  priv->commodity_scu = from_priv->commodity_scu;
1301  priv->non_standard_scu = from_priv->non_standard_scu;
1302 
1303  qof_instance_set_dirty(&ret->inst);
1304  LEAVE (" ");
1305  return ret;
1306 }
const char * qof_string_cache_replace(char const *dst, char const *src)
Same as CACHE_REPLACE below, but safe to call from C++.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
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:282
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...