GnuCash  3.1-61-g61071b9
Files | Data Structures | Macros | Typedefs | Enumerations | Functions

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

Files

file  Account.h
 Account handling public routines.
 

Data Structures

struct  AccountClass
 
struct  GncImportMatchMap
 

Macros

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

Typedefs

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

Enumerations

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

Functions

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

Account Constructors, Edit/Commit, Comparison

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

Account lookup and GncGUID routines

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

Account general setters/getters

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

Account Commodity setters/getters

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

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

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

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

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

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

Account Balance

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

Account Children and Parents.

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

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

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

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

ForEach

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

Concatenation, Merging

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

Detailed Description

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

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

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

Macro Definition Documentation

◆ xaccAccountGetGUID

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

Definition at line 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 105 of file Account.h.

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

Function Documentation

◆ dxaccAccountGetPriceSrc()

const char* dxaccAccountGetPriceSrc ( const Account account)

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

See price-quotes.scm for more information.

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

Definition at line 4641 of file Account.cpp.

4642 {
4643  GValue v = G_VALUE_INIT;
4644  if (!acc) return NULL;
4645 
4646  if (!xaccAccountIsPriced(acc)) return NULL;
4647 
4648  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {"old-price-source"});
4649  return G_VALUE_HOLDS_STRING (&v) ? g_value_get_string (&v) : NULL;
4650 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4278

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

4616 {
4617  if (!acc) return;
4618 
4619  if (xaccAccountIsPriced(acc))
4620  {
4621  xaccAccountBeginEdit(acc);
4622  if (src)
4623  {
4624  GValue v = G_VALUE_INIT;
4625  g_value_init (&v, G_TYPE_STRING);
4626  g_value_set_string (&v, src);
4627  qof_instance_set_path_kvp (QOF_INSTANCE(acc), &v, {"old-price-source"});
4628  }
4629  else
4630  qof_instance_set_path_kvp (QOF_INSTANCE(acc), nullptr, {"old-price-source"});
4631 
4632  mark_account (acc);
4633  xaccAccountCommitEdit(acc);
4634  }
4635 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4278
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1287
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1328

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

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

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

2677 {
2678  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
2679  g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
2680  return g_list_index(GET_PRIVATE(parent)->children, child);
2681 }

◆ gnc_account_create_root()

Account* gnc_account_create_root ( QofBook *  book)

Create a new root level account.

Definition at line 1104 of file Account.cpp.

1105 {
1106  Account *root;
1107  AccountPrivate *rpriv;
1108 
1109  root = xaccMallocAccount(book);
1110  rpriv = GET_PRIVATE(root);
1111  xaccAccountBeginEdit(root);
1112  rpriv->type = ACCT_TYPE_ROOT;
1113  rpriv->accountName = qof_string_cache_replace(rpriv->accountName, "Root Account");
1114  mark_account (root);
1115  xaccAccountCommitEdit(root);
1116  gnc_book_set_root_account(book, root);
1117  return root;
1118 }
char * qof_string_cache_replace(char const *dst, char const *src)
Same as CACHE_REPLACE below, but safe to call from C++.
STRUCTS.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1287
Account * xaccMallocAccount(QofBook *book)
Constructor.
Definition: Account.cpp:1090
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1328
The hidden root account of an account tree.
Definition: Account.h:156

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

2936 {
2937  const AccountPrivate *priv;
2938  GList *node;
2939 
2940  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2941  g_return_if_fail(thunk);
2942 
2943  priv = GET_PRIVATE(acc);
2944  for (node = priv->children; node; node = node->next)
2945  {
2946  thunk (static_cast<Account*>(node->data), user_data);
2947  }
2948 }

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

2954 {
2955  const AccountPrivate *priv;
2956  GList *node;
2957  Account *child;
2958 
2959  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2960  g_return_if_fail(thunk);
2961 
2962  priv = GET_PRIVATE(acc);
2963  for (node = priv->children; node; node = node->next)
2964  {
2965  child = static_cast<Account*>(node->data);
2966  thunk(child, user_data);
2967  gnc_account_foreach_descendant(child, thunk, user_data);
2968  }
2969 }
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:2951
STRUCTS.

◆ gnc_account_foreach_descendant_until()

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

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

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

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

Definition at line 2972 of file Account.cpp.

2975 {
2976  const AccountPrivate *priv;
2977  GList *node;
2978  Account *child;
2979  gpointer result;
2980 
2981  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2982  g_return_val_if_fail(thunk, NULL);
2983 
2984  priv = GET_PRIVATE(acc);
2985  for (node = priv->children; node; node = node->next)
2986  {
2987  child = static_cast<Account*>(node->data);
2988  result = thunk(child, user_data);
2989  if (result)
2990  return(result);
2991 
2992  result = gnc_account_foreach_descendant_until(child, thunk, user_data);
2993  if (result)
2994  return(result);
2995  }
2996 
2997  return NULL;
2998 }
STRUCTS.
gpointer gnc_account_foreach_descendant_until(const Account *acc, AccountCb2 thunk, gpointer user_data)
This method will traverse all children of this accounts and their descendants, calling &#39;func&#39; on each...
Definition: Account.cpp:2972

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

2648 {
2649  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2650  return g_list_copy(GET_PRIVATE(account)->children);
2651 }

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

2655 {
2656  AccountPrivate *priv;
2657 
2658  /* errors */
2659  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2660 
2661  /* optimizations */
2662  priv = GET_PRIVATE(account);
2663  if (!priv->children)
2664  return NULL;
2665  return g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2666 }
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.cpp:2139

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

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

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

2709 {
2710  AccountPrivate *priv;
2711  int depth = 0;
2712 
2713  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2714 
2715  priv = GET_PRIVATE(account);
2716  while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
2717  {
2718  account = priv->parent;
2719  priv = GET_PRIVATE(account);
2720  depth++;
2721  }
2722 
2723  return depth;
2724 }
The hidden root account of an account tree.
Definition: Account.h:156

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

2749 {
2750  AccountPrivate *priv;
2751  GList *child, *descendants;
2752 
2753  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2754 
2755  priv = GET_PRIVATE(account);
2756  if (!priv->children)
2757  return NULL;
2758 
2759  descendants = NULL;
2760  for (child = priv->children; child; child = g_list_next(child))
2761  {
2762  descendants = g_list_append(descendants, child->data);
2763  descendants = g_list_concat(descendants,
2764  gnc_account_get_descendants(static_cast<Account const *>(child->data)));
2765  }
2766  return descendants;
2767 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:2748

◆ gnc_account_get_descendants_sorted()

GList* gnc_account_get_descendants_sorted ( const Account account)

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

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

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

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

Definition at line 2770 of file Account.cpp.

2771 {
2772  AccountPrivate *priv;
2773  GList *child, *children, *descendants;
2774 
2775  /* errors */
2776  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2777 
2778  /* optimizations */
2779  priv = GET_PRIVATE(account);
2780  if (!priv->children)
2781  return NULL;
2782 
2783  descendants = NULL;
2784  children = g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2785  for (child = children; child; child = g_list_next(child))
2786  {
2787  descendants = g_list_append(descendants, child->data);
2788  descendants = g_list_concat(descendants,
2789  gnc_account_get_descendants_sorted(static_cast<Account const *>(child->data)));
2790  }
2791  g_list_free(children);
2792  return descendants;
2793 }
GList * gnc_account_get_descendants_sorted(const Account *account)
This function returns a GList containing all the descendants of the specified account, sorted at each level.
Definition: Account.cpp:2770
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.cpp:2139

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

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

◆ gnc_account_get_parent()

Account* gnc_account_get_parent ( const Account account)

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

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

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

Definition at line 2616 of file Account.cpp.

2617 {
2618  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2619  return GET_PRIVATE(acc)->parent;
2620 }

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

2624 {
2625  AccountPrivate *priv;
2626 
2627  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2628 
2629  priv = GET_PRIVATE(acc);
2630  while (priv->parent)
2631  {
2632  acc = priv->parent;
2633  priv = GET_PRIVATE(acc);
2634  }
2635 
2636  return acc;
2637 }

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

2728 {
2729  AccountPrivate *priv;
2730  GList *node;
2731  gint depth = 0, child_depth;
2732 
2733  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2734 
2735  priv = GET_PRIVATE(account);
2736  if (!priv->children)
2737  return 1;
2738 
2739  for (node = priv->children; node; node = g_list_next(node))
2740  {
2741  child_depth = gnc_account_get_tree_depth(static_cast<Account const *>(node->data));
2742  depth = MAX(depth, child_depth);
2743  }
2744  return depth + 1;
2745 }
gint gnc_account_get_tree_depth(const Account *account)
Return the number of levels of descendants accounts below the specified account.
Definition: Account.cpp:2727

◆ gnc_account_get_type()

GType gnc_account_get_type ( void  )

Returns the GType type system description of the Account class.

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

◆ gnc_account_insert_split()

gboolean gnc_account_insert_split ( Account acc,
Split *  s 
)

Insert the given split from an account.

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

Definition at line 1727 of file Account.cpp.

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

◆ gnc_account_is_root()

gboolean gnc_account_is_root ( const Account account)

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

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

Definition at line 2640 of file Account.cpp.

2641 {
2642  g_return_val_if_fail(GNC_IS_ACCOUNT(account), FALSE);
2643  return (GET_PRIVATE(account)->parent == NULL);
2644 }

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

4791 {
4792  AccountPrivate *from_priv;
4793  GList *children, *node;
4794 
4795  /* errors */
4796  g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
4797  g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
4798 
4799  /* optimizations */
4800  from_priv = GET_PRIVATE(from_parent);
4801  if (!from_priv->children)
4802  return;
4803 
4804  ENTER (" ");
4805  children = g_list_copy(from_priv->children);
4806  for (node = children; node; node = g_list_next(node))
4807  gnc_account_append_child(to_parent, static_cast <Account*> (node->data));
4808  g_list_free(children);
4809  LEAVE (" ");
4810 }
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:2518
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ gnc_account_list_name_violations()

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

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

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

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

Definition at line 206 of file Account.cpp.

207 {
208  Account *root_account = gnc_book_get_root_account(book);
209  GList *accounts, *node;
210  GList *invalid_list = NULL;
211 
212  g_return_val_if_fail (separator != NULL, NULL);
213 
214  if (root_account == NULL)
215  return NULL;
216 
217  accounts = gnc_account_get_descendants (root_account);
218  for (node = accounts; node; node = g_list_next(node))
219  {
220  Account *acct = (Account*)node->data;
221  gchar *acct_name = g_strdup ( xaccAccountGetName ( acct ) );
222 
223  if ( g_strstr_len ( acct_name, -1, separator ) )
224  invalid_list = g_list_prepend ( invalid_list, (gpointer) acct_name );
225  else
226  g_free ( acct_name );
227  }
228  if (accounts != NULL)
229  {
230  g_list_free(accounts);
231  }
232 
233  return invalid_list;
234 }
STRUCTS.
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:2748
const char * xaccAccountGetName(const Account *acc)
Get the account&#39;s name.
Definition: Account.cpp:3024

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

4816 {
4817  AccountPrivate *ppriv, *priv_a, *priv_b;
4818  GList *node_a, *node_b, *work, *worker;
4819 
4820  g_return_if_fail(GNC_IS_ACCOUNT(parent));
4821 
4822  ppriv = GET_PRIVATE(parent);
4823  for (node_a = ppriv->children; node_a; node_a = node_a->next)
4824  {
4825  Account *acc_a = static_cast <Account*> (node_a->data);
4826 
4827  priv_a = GET_PRIVATE(acc_a);
4828  for (node_b = node_a->next; node_b; node_b = g_list_next(node_b))
4829  {
4830  Account *acc_b = static_cast <Account*> (node_b->data);
4831 
4832  priv_b = GET_PRIVATE(acc_b);
4833  if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
4834  continue;
4835  if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
4836  continue;
4837  if (0 != null_strcmp(priv_a->description, priv_b->description))
4838  continue;
4839  if (0 != null_strcmp(xaccAccountGetColor(acc_a),
4840  xaccAccountGetColor(acc_b)))
4841  continue;
4842  if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
4843  continue;
4844  if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
4845  xaccAccountGetNotes(acc_b)))
4846  continue;
4847  if (priv_a->type != priv_b->type)
4848  continue;
4849 
4850  /* consolidate children */
4851  if (priv_b->children)
4852  {
4853  work = g_list_copy(priv_b->children);
4854  for (worker = work; worker; worker = g_list_next(worker))
4855  gnc_account_append_child (acc_a, (Account *)worker->data);
4856  g_list_free(work);
4857 
4858  qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, NULL);
4859  qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, NULL);
4860  }
4861 
4862  /* recurse to do the children's children */
4864 
4865  /* consolidate transactions */
4866  while (priv_b->splits)
4867  xaccSplitSetAccount (static_cast <Split*> (priv_b->splits->data), acc_a);
4868 
4869  /* move back one before removal. next iteration around the loop
4870  * will get the node after node_b */
4871  node_b = g_list_previous(node_b);
4872 
4873  /* The destroy function will remove from list -- node_a is ok,
4874  * it's before node_b */
4875  xaccAccountBeginEdit (acc_b);
4876  xaccAccountDestroy (acc_b);
4877  }
4878  }
4879 }
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:2518
STRUCTS.
void xaccAccountDestroy(Account *acc)
The xaccAccountDestroy() routine can be used to get rid of an account.
Definition: Account.cpp:1407
const char * xaccAccountGetColor(const Account *acc)
Get the account&#39;s color.
Definition: Account.cpp:3093
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:1287
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:234
gboolean gnc_commodity_equiv(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equivalent.
void gnc_account_merge_children(Account *parent)
The gnc_account_merge_children() subroutine will go through an account, merging all child accounts th...
Definition: Account.cpp:4815
const char * xaccAccountGetNotes(const Account *acc)
Get the account&#39;s notes.
Definition: Account.cpp:3122

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

2670 {
2671  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2672  return g_list_length(GET_PRIVATE(account)->children);
2673 }

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

2692 {
2693  AccountPrivate *priv;
2694  GList *node;
2695  gint count = 0;
2696 
2697  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2698 
2699  priv = GET_PRIVATE(account);
2700  for (node = priv->children; node; node = g_list_next(node))
2701  {
2702  count += gnc_account_n_descendants(static_cast<Account*>(node->data)) + 1;
2703  }
2704  return count;
2705 }
gint gnc_account_n_descendants(const Account *account)
Return the number of descendants of the specified account.
Definition: Account.cpp:2691

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

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

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

2685 {
2686  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), NULL);
2687  return static_cast<Account*>(g_list_nth_data(GET_PRIVATE(parent)->children, num));
2688 }
STRUCTS.

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

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

◆ gnc_account_remove_split()

gboolean gnc_account_remove_split ( Account acc,
Split *  s 
)

Remove the given split from an account.

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

Definition at line 1763 of file Account.cpp.

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

◆ gnc_account_set_balance_dirty()

void gnc_account_set_balance_dirty ( Account acc)

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

Parameters
accSet the flag on this account.

Definition at line 1710 of file Account.cpp.

1711 {
1712  AccountPrivate *priv;
1713 
1714  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1715 
1716  if (qof_instance_get_destroying(acc))
1717  return;
1718 
1719  priv = GET_PRIVATE(acc);
1720  priv->balance_dirty = TRUE;
1721 }
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 1696 of file Account.cpp.

1697 {
1698  AccountPrivate *priv;
1699 
1700  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1701 
1702  if (qof_instance_get_destroying(acc))
1703  return;
1704 
1705  priv = GET_PRIVATE(acc);
1706  priv->sort_dirty = TRUE;
1707 }
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 3190 of file Account.cpp.

3191 {
3192  AccountPrivate *priv;
3193 
3194  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3195 
3196  priv = GET_PRIVATE(acc);
3197  priv->starting_balance = start_baln;
3198  priv->balance_dirty = TRUE;
3199 }

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

3204 {
3205  AccountPrivate *priv;
3206 
3207  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3208 
3209  priv = GET_PRIVATE(acc);
3210  priv->starting_cleared_balance = start_baln;
3211  priv->balance_dirty = TRUE;
3212 }

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

3217 {
3218  AccountPrivate *priv;
3219 
3220  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3221 
3222  priv = GET_PRIVATE(acc);
3223  priv->starting_reconciled_balance = start_baln;
3224  priv->balance_dirty = TRUE;
3225 }

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

140 {
141  return account_separator;
142 }

◆ xaccAccountBeginEdit()

void xaccAccountBeginEdit ( Account account)

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

Definition at line 1287 of file Account.cpp.

1288 {
1289  g_return_if_fail(acc);
1290  qof_begin_edit(&acc->inst);
1291 }
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 1328 of file Account.cpp.

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

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

1408 {
1409  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1410 
1411  qof_instance_set_destroying(acc, TRUE);
1412 
1413  xaccAccountCommitEdit (acc);
1414 }
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1328

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

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

4578 {
4579  GValue v = G_VALUE_INIT;
4580  std::vector<std::string> path {"lot-mgmt", "gains-acct",
4582  GncGUID *guid = NULL;
4583  Account *gains_account;
4584 
4585  g_return_val_if_fail (acc != NULL, NULL);
4586  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, path);
4587  if (G_VALUE_HOLDS_BOXED (&v))
4588  guid = (GncGUID*)g_value_get_boxed (&v);
4589  if (guid == NULL) /* No gains account for this currency */
4590  {
4591  gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc),
4592  curr);
4593  guid = (GncGUID*)qof_instance_get_guid (QOF_INSTANCE (gains_account));
4594  xaccAccountBeginEdit (acc);
4595  {
4596  GValue vr = G_VALUE_INIT;
4597  g_value_init (&vr, GNC_TYPE_GUID);
4598  g_value_set_boxed (&vr, guid);
4599  qof_instance_set_path_kvp (QOF_INSTANCE (acc), &vr, path);
4600  qof_instance_set_dirty (QOF_INSTANCE (acc));
4601  }
4602  xaccAccountCommitEdit (acc);
4603  }
4604  else
4605  gains_account = xaccAccountLookup (guid,
4606  qof_instance_get_book(acc));
4607 
4608  return gains_account;
4609 }
const GncGUID * qof_instance_get_guid(gconstpointer inst)
Return the GncGUID of this instance.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
STRUCTS.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1287
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:2623
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:1328
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.cpp:1834

◆ xaccAccountGetAutoInterestXfer()

gboolean xaccAccountGetAutoInterestXfer ( const Account account,
gboolean  default_value 
)

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

This per-account flag overrides the global preference.

Definition at line 4488 of file Account.cpp.

4489 {
4490  return boolean_from_key (acc, {"reconcile-info", "auto-interest-transfer"});
4491 }

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

2449 {
2450  AccountPrivate *priv;
2451 
2452  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2453 
2454  priv = GET_PRIVATE(acc);
2455  if (priv->non_standard_scu || !priv->commodity)
2456  return priv->commodity_scu;
2457  return gnc_commodity_get_fraction(priv->commodity);
2458 }
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 2441 of file Account.cpp.

2442 {
2443  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2444  return GET_PRIVATE(acc)->commodity_scu;
2445 }

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account account)

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

Definition at line 2477 of file Account.cpp.

2478 {
2479  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2480  return GET_PRIVATE(acc)->non_standard_scu;
2481 }

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

3003 {
3004  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
3005  return GET_PRIVATE(acc)->type;
3006 }
Not a type.
Definition: Account.h:108

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

3994 {
3995  const Account *parent;
3996 
3997  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
3998  g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);
3999 
4000  parent = acc;
4001  while (parent && parent != ancestor)
4002  parent = GET_PRIVATE(parent)->parent;
4003 
4004  return (parent == ancestor);
4005 }
STRUCTS.

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account acc)

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

Definition at line 4278 of file Account.cpp.

4279 {
4280  AccountPrivate *priv;
4281 
4282  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4283 
4284  priv = GET_PRIVATE(acc);
4285  return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
4286  priv->type == ACCT_TYPE_CURRENCY);
4287 }
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:128
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:125
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:132

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

1835 {
1836  QofCollection *col;
1837  if (!guid || !book) return NULL;
1838  col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
1839  return (Account *) qof_collection_lookup_entity (col, guid);
1840 }
QofInstance * qof_collection_lookup_entity(const QofCollection *col, const GncGUID *guid)
Find the entity going only from its guid.
Definition: qofid.cpp:214
STRUCTS.
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:554

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

2140 {
2141  AccountPrivate *priv_aa, *priv_ab;
2142  char *da, *db;
2143  char *endptr = NULL;
2144  int ta, tb, result;
2145  long la, lb;
2146 
2147  if ( aa && !ab ) return -1;
2148  if ( !aa && ab ) return +1;
2149  if ( !aa && !ab ) return 0;
2150 
2151  priv_aa = GET_PRIVATE(aa);
2152  priv_ab = GET_PRIVATE(ab);
2153 
2154  /* sort on accountCode strings */
2155  da = priv_aa->accountCode;
2156  db = priv_ab->accountCode;
2157 
2158  /* If accountCodes are both base 36 integers do an integer sort */
2159  la = strtoul (da, &endptr, 36);
2160  if ((*da != '\0') && (*endptr == '\0'))
2161  {
2162  lb = strtoul (db, &endptr, 36);
2163  if ((*db != '\0') && (*endptr == '\0'))
2164  {
2165  if (la < lb) return -1;
2166  if (la > lb) return +1;
2167  }
2168  }
2169 
2170  /* Otherwise do a string sort */
2171  result = g_strcmp0 (da, db);
2172  if (result)
2173  return result;
2174 
2175  /* if account-type-order array not initialized, initialize it */
2176  /* this will happen at most once during program invocation */
2177  if (-1 == revorder[0])
2178  {
2179  int i;
2180  for (i = 0; i < NUM_ACCOUNT_TYPES; i++)
2181  {
2182  revorder [typeorder[i]] = i;
2183  }
2184  }
2185 
2186  /* otherwise, sort on account type */
2187  ta = priv_aa->type;
2188  tb = priv_ab->type;
2189  ta = revorder[ta];
2190  tb = revorder[tb];
2191  if (ta < tb) return -1;
2192  if (ta > tb) return +1;
2193 
2194  /* otherwise, sort on accountName strings */
2195  da = priv_aa->accountName;
2196  db = priv_ab->accountName;
2197  result = safe_utf8_collate(da, db);
2198  if (result)
2199  return result;
2200 
2201  /* guarantee a stable sort */
2202  return qof_instance_guid_compare(aa, ab);
2203 }
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:164
gint qof_instance_guid_compare(gconstpointer ptr1, gconstpointer ptr2)
Compare the GncGUID values of two instances.

◆ xaccAccountSetAutoInterestXfer()

void xaccAccountSetAutoInterestXfer ( Account account,
gboolean  value 
)

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

This per-account flag overrides the global preference.

Definition at line 4497 of file Account.cpp.

4498 {
4499  set_boolean_key (acc, {"reconcile-info", "auto-interest-transfer"}, option);
4500 }

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

2426 {
2427  AccountPrivate *priv;
2428 
2429  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2430 
2431  priv = GET_PRIVATE(acc);
2432  xaccAccountBeginEdit(acc);
2433  priv->commodity_scu = scu;
2434  if (scu != gnc_commodity_get_fraction(priv->commodity))
2435  priv->non_standard_scu = TRUE;
2436  mark_account(acc);
2437  xaccAccountCommitEdit(acc);
2438 }
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:1287
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1328

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account account,
gboolean  flag 
)

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

Definition at line 2461 of file Account.cpp.

2462 {
2463  AccountPrivate *priv;
2464 
2465  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2466 
2467  priv = GET_PRIVATE(acc);
2468  if (priv->non_standard_scu == flag)
2469  return;
2470  xaccAccountBeginEdit(acc);
2471  priv->non_standard_scu = flag;
2472  mark_account (acc);
2473  xaccAccountCommitEdit(acc);
2474 }
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1287
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1328

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

1789 {
1790  AccountPrivate *priv;
1791 
1792  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1793 
1794  priv = GET_PRIVATE(acc);
1795  if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
1796  return;
1797  priv->splits = g_list_sort(priv->splits, (GCompareFunc)xaccSplitOrder);
1798  priv->sort_dirty = FALSE;
1799  priv->balance_dirty = TRUE;
1800 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1465

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

1122 {
1123  Account *ret;
1124  AccountPrivate *from_priv, *priv;
1125 
1126  g_return_val_if_fail(GNC_IS_ACCOUNT(from), NULL);
1127  g_return_val_if_fail(QOF_IS_BOOK(book), NULL);
1128 
1129  ENTER (" ");
1130  ret = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, NULL));
1131  g_return_val_if_fail (ret, NULL);
1132 
1133  from_priv = GET_PRIVATE(from);
1134  priv = GET_PRIVATE(ret);
1135  xaccInitAccount (ret, book);
1136 
1137  /* Do not Begin/CommitEdit() here; give the caller
1138  * a chance to fix things up, and let them do it.
1139  * Also let caller issue the generate_event (EVENT_CREATE) */
1140  priv->type = from_priv->type;
1141 
1142  priv->accountName = static_cast<char*>(qof_string_cache_insert(from_priv->accountName));
1143  priv->accountCode = static_cast<char*>(qof_string_cache_insert(from_priv->accountCode));
1144  priv->description = static_cast<char*>(qof_string_cache_insert(from_priv->description));
1145 
1146  qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));
1147 
1148  /* The new book should contain a commodity that matches
1149  * the one in the old book. Find it, use it. */
1150  priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
1151  gnc_commodity_increment_usage_count(priv->commodity);
1152 
1153  priv->commodity_scu = from_priv->commodity_scu;
1154  priv->non_standard_scu = from_priv->non_standard_scu;
1155 
1156  qof_instance_set_dirty(&ret->inst);
1157  LEAVE (" ");
1158  return ret;
1159 }
STRUCTS.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
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...
char * qof_string_cache_insert(const char *key)
You can use this function with g_hash_table_insert(), for the key (or value), as long as you use the ...
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276
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...