GnuCash  3.5-292-g8ed150896+
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 4630 of file Account.cpp.

4631 {
4632  GValue v = G_VALUE_INIT;
4633  if (!acc) return NULL;
4634 
4635  if (!xaccAccountIsPriced(acc)) return NULL;
4636 
4637  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {"old-price-source"});
4638  return G_VALUE_HOLDS_STRING (&v) ? g_value_get_string (&v) : NULL;
4639 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4267

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

4605 {
4606  if (!acc) return;
4607 
4608  if (xaccAccountIsPriced(acc))
4609  {
4610  xaccAccountBeginEdit(acc);
4611  if (src)
4612  {
4613  GValue v = G_VALUE_INIT;
4614  g_value_init (&v, G_TYPE_STRING);
4615  g_value_set_string (&v, src);
4616  qof_instance_set_path_kvp (QOF_INSTANCE(acc), &v, {"old-price-source"});
4617  }
4618  else
4619  qof_instance_set_path_kvp (QOF_INSTANCE(acc), nullptr, {"old-price-source"});
4620 
4621  mark_account (acc);
4622  xaccAccountCommitEdit(acc);
4623  }
4624 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4267
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1291
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1332

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

2523 {
2524  AccountPrivate *ppriv, *cpriv;
2525  Account *old_parent;
2526  QofCollection *col;
2527 
2528  /* errors */
2529  g_assert(GNC_IS_ACCOUNT(new_parent));
2530  g_assert(GNC_IS_ACCOUNT(child));
2531 
2532  /* optimizations */
2533  ppriv = GET_PRIVATE(new_parent);
2534  cpriv = GET_PRIVATE(child);
2535  old_parent = cpriv->parent;
2536  if (old_parent == new_parent)
2537  return;
2538 
2539  // xaccAccountBeginEdit(new_parent);
2540  xaccAccountBeginEdit(child);
2541  if (old_parent)
2542  {
2543  gnc_account_remove_child(old_parent, child);
2544 
2545  if (!qof_instance_books_equal(old_parent, new_parent))
2546  {
2547  /* hack alert -- this implementation is not exactly correct.
2548  * If the entity tables are not identical, then the 'from' book
2549  * may have a different backend than the 'to' book. This means
2550  * that we should get the 'from' backend to destroy this account,
2551  * and the 'to' backend to save it. Right now, this is broken.
2552  *
2553  * A 'correct' implementation similar to this is in Period.c
2554  * except its for transactions ...
2555  *
2556  * Note also, we need to reparent the children to the new book as well.
2557  */
2558  PWARN ("reparenting accounts across books is not correctly supported\n");
2559 
2560  qof_event_gen (&child->inst, QOF_EVENT_DESTROY, NULL);
2562  GNC_ID_ACCOUNT);
2563  qof_collection_insert_entity (col, &child->inst);
2564  qof_event_gen (&child->inst, QOF_EVENT_CREATE, NULL);
2565  }
2566  }
2567  cpriv->parent = new_parent;
2568  ppriv->children = g_list_append(ppriv->children, child);
2569  qof_instance_set_dirty(&new_parent->inst);
2570  qof_instance_set_dirty(&child->inst);
2571 
2572  /* Send events data. Warning: The call to commit_edit is also going
2573  * to send a MODIFY event. If the gtktreemodelfilter code gets the
2574  * MODIFY before it gets the ADD, it gets very confused and thinks
2575  * that two nodes have been added. */
2576  qof_event_gen (&child->inst, QOF_EVENT_ADD, NULL);
2577  // qof_event_gen (&new_parent->inst, QOF_EVENT_MODIFY, NULL);
2578 
2579  xaccAccountCommitEdit (child);
2580  // xaccAccountCommitEdit(new_parent);
2581 }
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:2584
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:1291
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:603
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:1332

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

2681 {
2682  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
2683  g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
2684  return g_list_index(GET_PRIVATE(parent)->children, child);
2685 }

◆ gnc_account_create_root()

Account* gnc_account_create_root ( QofBook *  book)

Create a new root level account.

Definition at line 1108 of file Account.cpp.

1109 {
1110  Account *root;
1111  AccountPrivate *rpriv;
1112 
1113  root = xaccMallocAccount(book);
1114  rpriv = GET_PRIVATE(root);
1115  xaccAccountBeginEdit(root);
1116  rpriv->type = ACCT_TYPE_ROOT;
1117  rpriv->accountName = qof_string_cache_replace(rpriv->accountName, "Root Account");
1118  mark_account (root);
1119  xaccAccountCommitEdit(root);
1120  gnc_book_set_root_account(book, root);
1121  return root;
1122 }
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:1291
Account * xaccMallocAccount(QofBook *book)
Constructor.
Definition: Account.cpp:1094
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1332
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 2937 of file Account.cpp.

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

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

2958 {
2959  const AccountPrivate *priv;
2960  GList *node;
2961  Account *child;
2962 
2963  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2964  g_return_if_fail(thunk);
2965 
2966  priv = GET_PRIVATE(acc);
2967  for (node = priv->children; node; node = node->next)
2968  {
2969  child = static_cast<Account*>(node->data);
2970  thunk(child, user_data);
2971  gnc_account_foreach_descendant(child, thunk, user_data);
2972  }
2973 }
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:2955
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 2976 of file Account.cpp.

2979 {
2980  const AccountPrivate *priv;
2981  GList *node;
2982  Account *child;
2983  gpointer result;
2984 
2985  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2986  g_return_val_if_fail(thunk, NULL);
2987 
2988  priv = GET_PRIVATE(acc);
2989  for (node = priv->children; node; node = node->next)
2990  {
2991  child = static_cast<Account*>(node->data);
2992  result = thunk(child, user_data);
2993  if (result)
2994  return(result);
2995 
2996  result = gnc_account_foreach_descendant_until(child, thunk, user_data);
2997  if (result)
2998  return(result);
2999  }
3000 
3001  return NULL;
3002 }
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:2976

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

2652 {
2653  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2654  return g_list_copy(GET_PRIVATE(account)->children);
2655 }

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

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

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

3159 {
3160  gnc_commodity * commodity;
3161  g_assert(account);
3162 
3163  commodity = xaccAccountGetCommodity (account);
3164  if (gnc_commodity_is_currency(commodity))
3165  return commodity;
3166  else
3167  {
3168  const Account *parent_account = account;
3169  /* Account commodity is not a currency, walk up the tree until
3170  * we find a parent account that is a currency account and use
3171  * it's currency.
3172  */
3173  do
3174  {
3175  parent_account = gnc_account_get_parent (parent_account);
3176  if (parent_account)
3177  {
3178  commodity = xaccAccountGetCommodity (parent_account);
3179  if (gnc_commodity_is_currency(commodity))
3180  {
3181  return commodity;
3182  //break;
3183  }
3184  }
3185  }
3186  while (parent_account);
3187  }
3188  return NULL; // no suitable commodity found.
3189 }
Account * gnc_account_get_parent(const Account *acc)
This routine returns a pointer to the parent of the specified account.
Definition: Account.cpp:2620
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:3151

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

2713 {
2714  AccountPrivate *priv;
2715  int depth = 0;
2716 
2717  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2718 
2719  priv = GET_PRIVATE(account);
2720  while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
2721  {
2722  account = priv->parent;
2723  priv = GET_PRIVATE(account);
2724  depth++;
2725  }
2726 
2727  return depth;
2728 }
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 2752 of file Account.cpp.

2753 {
2754  AccountPrivate *priv;
2755  GList *child, *descendants;
2756 
2757  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2758 
2759  priv = GET_PRIVATE(account);
2760  if (!priv->children)
2761  return NULL;
2762 
2763  descendants = NULL;
2764  for (child = priv->children; child; child = g_list_next(child))
2765  {
2766  descendants = g_list_append(descendants, child->data);
2767  descendants = g_list_concat(descendants,
2768  gnc_account_get_descendants(static_cast<Account const *>(child->data)));
2769  }
2770  return descendants;
2771 }
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:2752

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

2775 {
2776  AccountPrivate *priv;
2777  GList *child, *children, *descendants;
2778 
2779  /* errors */
2780  g_return_val_if_fail(GNC_IS_ACCOUNT(account), NULL);
2781 
2782  /* optimizations */
2783  priv = GET_PRIVATE(account);
2784  if (!priv->children)
2785  return NULL;
2786 
2787  descendants = NULL;
2788  children = g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
2789  for (child = children; child; child = g_list_next(child))
2790  {
2791  descendants = g_list_append(descendants, child->data);
2792  descendants = g_list_concat(descendants,
2793  gnc_account_get_descendants_sorted(static_cast<Account const *>(child->data)));
2794  }
2795  g_list_free(children);
2796  return descendants;
2797 }
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:2774
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition: Account.cpp:2143

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

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

2621 {
2622  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2623  return GET_PRIVATE(acc)->parent;
2624 }

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

2628 {
2629  AccountPrivate *priv;
2630 
2631  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
2632 
2633  priv = GET_PRIVATE(acc);
2634  while (priv->parent)
2635  {
2636  acc = priv->parent;
2637  priv = GET_PRIVATE(acc);
2638  }
2639 
2640  return acc;
2641 }

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

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

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

1732 {
1733  AccountPrivate *priv;
1734  GList *node;
1735 
1736  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1737  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1738 
1739  priv = GET_PRIVATE(acc);
1740  node = g_list_find(priv->splits, s);
1741  if (node)
1742  return FALSE;
1743 
1744  if (qof_instance_get_editlevel(acc) == 0)
1745  {
1746  priv->splits = g_list_insert_sorted(priv->splits, s,
1747  (GCompareFunc)xaccSplitOrder);
1748  }
1749  else
1750  {
1751  priv->splits = g_list_prepend(priv->splits, s);
1752  priv->sort_dirty = TRUE;
1753  }
1754 
1755  //FIXME: find better event
1756  qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, NULL);
1757  /* Also send an event based on the account */
1758  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_ADDED, s);
1759 
1760  priv->balance_dirty = TRUE;
1761 // DRH: Should the below be added? It is present in the delete path.
1762 // xaccAccountRecomputeBalance(acc);
1763  return TRUE;
1764 }
gint xaccSplitOrder(const Split *sa, const Split *sb)
The xaccSplitOrder(sa,sb) method is useful for sorting.
Definition: Split.c:1469
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 2644 of file Account.cpp.

2645 {
2646  g_return_val_if_fail(GNC_IS_ACCOUNT(account), FALSE);
2647  return (GET_PRIVATE(account)->parent == NULL);
2648 }

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

4780 {
4781  AccountPrivate *from_priv;
4782  GList *children, *node;
4783 
4784  /* errors */
4785  g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
4786  g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
4787 
4788  /* optimizations */
4789  from_priv = GET_PRIVATE(from_parent);
4790  if (!from_priv->children)
4791  return;
4792 
4793  ENTER (" ");
4794  children = g_list_copy(from_priv->children);
4795  for (node = children; node; node = g_list_next(node))
4796  gnc_account_append_child(to_parent, static_cast <Account*> (node->data));
4797  g_list_free(children);
4798  LEAVE (" ");
4799 }
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:2522
#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 211 of file Account.cpp.

212 {
213  Account *root_account = gnc_book_get_root_account(book);
214  GList *accounts, *node;
215  GList *invalid_list = NULL;
216 
217  g_return_val_if_fail (separator != NULL, NULL);
218 
219  if (root_account == NULL)
220  return NULL;
221 
222  accounts = gnc_account_get_descendants (root_account);
223  for (node = accounts; node; node = g_list_next(node))
224  {
225  Account *acct = (Account*)node->data;
226  gchar *acct_name = g_strdup ( xaccAccountGetName ( acct ) );
227 
228  if ( g_strstr_len ( acct_name, -1, separator ) )
229  invalid_list = g_list_prepend ( invalid_list, (gpointer) acct_name );
230  else
231  g_free ( acct_name );
232  }
233  if (accounts != NULL)
234  {
235  g_list_free(accounts);
236  }
237 
238  return invalid_list;
239 }
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:2752
const char * xaccAccountGetName(const Account *acc)
Get the account&#39;s name.
Definition: Account.cpp:3028

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

4805 {
4806  AccountPrivate *ppriv, *priv_a, *priv_b;
4807  GList *node_a, *node_b, *work, *worker;
4808 
4809  g_return_if_fail(GNC_IS_ACCOUNT(parent));
4810 
4811  ppriv = GET_PRIVATE(parent);
4812  for (node_a = ppriv->children; node_a; node_a = node_a->next)
4813  {
4814  Account *acc_a = static_cast <Account*> (node_a->data);
4815 
4816  priv_a = GET_PRIVATE(acc_a);
4817  for (node_b = node_a->next; node_b; node_b = g_list_next(node_b))
4818  {
4819  Account *acc_b = static_cast <Account*> (node_b->data);
4820 
4821  priv_b = GET_PRIVATE(acc_b);
4822  if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
4823  continue;
4824  if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
4825  continue;
4826  if (0 != null_strcmp(priv_a->description, priv_b->description))
4827  continue;
4828  if (0 != null_strcmp(xaccAccountGetColor(acc_a),
4829  xaccAccountGetColor(acc_b)))
4830  continue;
4831  if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
4832  continue;
4833  if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
4834  xaccAccountGetNotes(acc_b)))
4835  continue;
4836  if (priv_a->type != priv_b->type)
4837  continue;
4838 
4839  /* consolidate children */
4840  if (priv_b->children)
4841  {
4842  work = g_list_copy(priv_b->children);
4843  for (worker = work; worker; worker = g_list_next(worker))
4844  gnc_account_append_child (acc_a, (Account *)worker->data);
4845  g_list_free(work);
4846 
4847  qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, NULL);
4848  qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, NULL);
4849  }
4850 
4851  /* recurse to do the children's children */
4853 
4854  /* consolidate transactions */
4855  while (priv_b->splits)
4856  xaccSplitSetAccount (static_cast <Split*> (priv_b->splits->data), acc_a);
4857 
4858  /* move back one before removal. next iteration around the loop
4859  * will get the node after node_b */
4860  node_b = g_list_previous(node_b);
4861 
4862  /* The destroy function will remove from list -- node_a is ok,
4863  * it's before node_b */
4864  xaccAccountBeginEdit (acc_b);
4865  xaccAccountDestroy (acc_b);
4866  }
4867  }
4868 }
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:2522
STRUCTS.
void xaccAccountDestroy(Account *acc)
The xaccAccountDestroy() routine can be used to get rid of an account.
Definition: Account.cpp:1411
const char * xaccAccountGetColor(const Account *acc)
Get the account&#39;s color.
Definition: Account.cpp:3097
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:1291
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:4804
const char * xaccAccountGetNotes(const Account *acc)
Get the account&#39;s notes.
Definition: Account.cpp:3126

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

2674 {
2675  g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2676  return g_list_length(GET_PRIVATE(account)->children);
2677 }

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

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

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

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

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

2689 {
2690  g_return_val_if_fail(GNC_IS_ACCOUNT(parent), NULL);
2691  return static_cast<Account*>(g_list_nth_data(GET_PRIVATE(parent)->children, num));
2692 }
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 2584 of file Account.cpp.

2585 {
2586  AccountPrivate *ppriv, *cpriv;
2587  GncEventData ed;
2588 
2589  if (!child) return;
2590 
2591  /* Note this routine might be called on accounts which
2592  * are not yet parented. */
2593  if (!parent) return;
2594 
2595  ppriv = GET_PRIVATE(parent);
2596  cpriv = GET_PRIVATE(child);
2597 
2598  if (cpriv->parent != parent)
2599  {
2600  PERR ("account not a child of parent");
2601  return;
2602  }
2603 
2604  /* Gather event data */
2605  ed.node = parent;
2606  ed.idx = g_list_index(ppriv->children, child);
2607 
2608  ppriv->children = g_list_remove(ppriv->children, child);
2609 
2610  /* Now send the event. */
2611  qof_event_gen(&child->inst, QOF_EVENT_REMOVE, &ed);
2612 
2613  /* clear the account's parent pointer after REMOVE event generation. */
2614  cpriv->parent = NULL;
2615 
2616  qof_event_gen (&parent->inst, QOF_EVENT_MODIFY, NULL);
2617 }
#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 1767 of file Account.cpp.

1768 {
1769  AccountPrivate *priv;
1770  GList *node;
1771 
1772  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1773  g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1774 
1775  priv = GET_PRIVATE(acc);
1776  node = g_list_find(priv->splits, s);
1777  if (NULL == node)
1778  return FALSE;
1779 
1780  priv->splits = g_list_delete_link(priv->splits, node);
1781  //FIXME: find better event type
1782  qof_event_gen(&acc->inst, QOF_EVENT_MODIFY, NULL);
1783  // And send the account-based event, too
1784  qof_event_gen(&acc->inst, GNC_EVENT_ITEM_REMOVED, s);
1785 
1786  priv->balance_dirty = TRUE;
1788  return TRUE;
1789 }
void xaccAccountRecomputeBalance(Account *acc)
The following recompute the partial balances (stored with the transaction) and the total balance...
Definition: Account.cpp:2069
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 1714 of file Account.cpp.

1715 {
1716  AccountPrivate *priv;
1717 
1718  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1719 
1720  if (qof_instance_get_destroying(acc))
1721  return;
1722 
1723  priv = GET_PRIVATE(acc);
1724  priv->balance_dirty = TRUE;
1725 }
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 1700 of file Account.cpp.

1701 {
1702  AccountPrivate *priv;
1703 
1704  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1705 
1706  if (qof_instance_get_destroying(acc))
1707  return;
1708 
1709  priv = GET_PRIVATE(acc);
1710  priv->sort_dirty = TRUE;
1711 }
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 3194 of file Account.cpp.

3195 {
3196  AccountPrivate *priv;
3197 
3198  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3199 
3200  priv = GET_PRIVATE(acc);
3201  priv->starting_balance = start_baln;
3202  priv->balance_dirty = TRUE;
3203 }

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

3208 {
3209  AccountPrivate *priv;
3210 
3211  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3212 
3213  priv = GET_PRIVATE(acc);
3214  priv->starting_cleared_balance = start_baln;
3215  priv->balance_dirty = TRUE;
3216 }

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

3221 {
3222  AccountPrivate *priv;
3223 
3224  g_return_if_fail(GNC_IS_ACCOUNT(acc));
3225 
3226  priv = GET_PRIVATE(acc);
3227  priv->starting_reconciled_balance = start_baln;
3228  priv->balance_dirty = TRUE;
3229 }

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

145 {
146  return account_separator;
147 }

◆ xaccAccountBeginEdit()

void xaccAccountBeginEdit ( Account account)

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

Definition at line 1291 of file Account.cpp.

1292 {
1293  g_return_if_fail(acc);
1294  qof_begin_edit(&acc->inst);
1295 }
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 1332 of file Account.cpp.

1333 {
1334  AccountPrivate *priv;
1335  QofBook *book;
1336 
1337  g_return_if_fail(acc);
1338  if (!qof_commit_edit(&acc->inst)) return;
1339 
1340  /* If marked for deletion, get rid of subaccounts first,
1341  * and then the splits ... */
1342  priv = GET_PRIVATE(acc);
1343  if (qof_instance_get_destroying(acc))
1344  {
1345  GList *lp, *slist;
1346  QofCollection *col;
1347 
1348  qof_instance_increase_editlevel(acc);
1349 
1350  /* First, recursively free children */
1351  xaccFreeAccountChildren(acc);
1352 
1353  PINFO ("freeing splits for account %p (%s)",
1354  acc, priv->accountName ? priv->accountName : "(null)");
1355 
1356  book = qof_instance_get_book(acc);
1357 
1358  /* If book is shutting down, just clear the split list. The splits
1359  themselves will be destroyed by the transaction code */
1360  if (!qof_book_shutting_down(book))
1361  {
1362  slist = g_list_copy(priv->splits);
1363  for (lp = slist; lp; lp = lp->next)
1364  {
1365  Split *s = static_cast<Split *>(lp->data);
1366  xaccSplitDestroy (s);
1367  }
1368  g_list_free(slist);
1369  }
1370  else
1371  {
1372  g_list_free(priv->splits);
1373  priv->splits = NULL;
1374  }
1375 
1376  /* It turns out there's a case where this assertion does not hold:
1377  When the user tries to delete an Imbalance account, while also
1378  deleting all the splits in it. The splits will just get
1379  recreated and put right back into the same account!
1380 
1381  g_assert(priv->splits == NULL || qof_book_shutting_down(acc->inst.book));
1382  */
1383 
1384  if (!qof_book_shutting_down(book))
1385  {
1386  col = qof_book_get_collection(book, GNC_ID_TRANS);
1387  qof_collection_foreach(col, destroy_pending_splits_for_account, acc);
1388 
1389  /* the lots should be empty by now */
1390  for (lp = priv->lots; lp; lp = lp->next)
1391  {
1392  GNCLot *lot = static_cast<GNCLot*>(lp->data);
1393  gnc_lot_destroy (lot);
1394  }
1395  }
1396  g_list_free(priv->lots);
1397  priv->lots = NULL;
1398 
1399  qof_instance_set_dirty(&acc->inst);
1400  qof_instance_decrease_editlevel(acc);
1401  }
1402  else
1403  {
1404  xaccAccountBringUpToDate(acc);
1405  }
1406 
1407  qof_commit_edit_part2(&acc->inst, on_err, on_done, acc_free);
1408 }
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:1439
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:322
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:603
gboolean qof_book_shutting_down(const QofBook *book)
Is the book shutting down?
Definition: qofbook.cpp:530

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

1412 {
1413  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1414 
1415  qof_instance_set_destroying(acc, TRUE);
1416 
1417  xaccAccountCommitEdit (acc);
1418 }
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1332

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

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

4567 {
4568  GValue v = G_VALUE_INIT;
4569  std::vector<std::string> path {KEY_LOT_MGMT, "gains-acct",
4571  GncGUID *guid = NULL;
4572  Account *gains_account;
4573 
4574  g_return_val_if_fail (acc != NULL, NULL);
4575  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, path);
4576  if (G_VALUE_HOLDS_BOXED (&v))
4577  guid = (GncGUID*)g_value_get_boxed (&v);
4578  if (guid == NULL) /* No gains account for this currency */
4579  {
4580  gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc),
4581  curr);
4582  guid = (GncGUID*)qof_instance_get_guid (QOF_INSTANCE (gains_account));
4583  xaccAccountBeginEdit (acc);
4584  {
4585  GValue vr = G_VALUE_INIT;
4586  g_value_init (&vr, GNC_TYPE_GUID);
4587  g_value_set_boxed (&vr, guid);
4588  qof_instance_set_path_kvp (QOF_INSTANCE (acc), &vr, path);
4589  qof_instance_set_dirty (QOF_INSTANCE (acc));
4590  }
4591  xaccAccountCommitEdit (acc);
4592  }
4593  else
4594  gains_account = xaccAccountLookup (guid,
4595  qof_instance_get_book(acc));
4596 
4597  return gains_account;
4598 }
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:1291
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:2627
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:1332
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.cpp:1838

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

4478 {
4479  return boolean_from_key (acc, {KEY_RECONCILE_INFO, "auto-interest-transfer"});
4480 }

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

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

2446 {
2447  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2448  return GET_PRIVATE(acc)->commodity_scu;
2449 }

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account account)

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

Definition at line 2481 of file Account.cpp.

2482 {
2483  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2484  return GET_PRIVATE(acc)->non_standard_scu;
2485 }

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

3007 {
3008  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
3009  return GET_PRIVATE(acc)->type;
3010 }
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 3982 of file Account.cpp.

3983 {
3984  const Account *parent;
3985 
3986  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
3987  g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);
3988 
3989  parent = acc;
3990  while (parent && parent != ancestor)
3991  parent = GET_PRIVATE(parent)->parent;
3992 
3993  return (parent == ancestor);
3994 }
STRUCTS.

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account acc)

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

Definition at line 4267 of file Account.cpp.

4268 {
4269  AccountPrivate *priv;
4270 
4271  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4272 
4273  priv = GET_PRIVATE(acc);
4274  return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
4275  priv->type == ACCT_TYPE_CURRENCY);
4276 }
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 1838 of file Account.cpp.

1839 {
1840  QofCollection *col;
1841  if (!guid || !book) return NULL;
1842  col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
1843  return (Account *) qof_collection_lookup_entity (col, guid);
1844 }
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:603

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

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

4487 {
4488  set_boolean_key (acc, {KEY_RECONCILE_INFO, "auto-interest-transfer"}, option);
4489 }

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

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

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account account,
gboolean  flag 
)

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

Definition at line 2465 of file Account.cpp.

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

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

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

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

1126 {
1127  Account *ret;
1128  AccountPrivate *from_priv, *priv;
1129 
1130  g_return_val_if_fail(GNC_IS_ACCOUNT(from), NULL);
1131  g_return_val_if_fail(QOF_IS_BOOK(book), NULL);
1132 
1133  ENTER (" ");
1134  ret = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, NULL));
1135  g_return_val_if_fail (ret, NULL);
1136 
1137  from_priv = GET_PRIVATE(from);
1138  priv = GET_PRIVATE(ret);
1139  xaccInitAccount (ret, book);
1140 
1141  /* Do not Begin/CommitEdit() here; give the caller
1142  * a chance to fix things up, and let them do it.
1143  * Also let caller issue the generate_event (EVENT_CREATE) */
1144  priv->type = from_priv->type;
1145 
1146  priv->accountName = static_cast<char*>(qof_string_cache_insert(from_priv->accountName));
1147  priv->accountCode = static_cast<char*>(qof_string_cache_insert(from_priv->accountCode));
1148  priv->description = static_cast<char*>(qof_string_cache_insert(from_priv->description));
1149 
1150  qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));
1151 
1152  /* The new book should contain a commodity that matches
1153  * the one in the old book. Find it, use it. */
1154  priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
1155  gnc_commodity_increment_usage_count(priv->commodity);
1156 
1157  priv->commodity_scu = from_priv->commodity_scu;
1158  priv->non_standard_scu = from_priv->non_standard_scu;
1159 
1160  qof_instance_set_dirty(&ret->inst);
1161  LEAVE (" ");
1162  return ret;
1163 }
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...