GnuCash  3.4-243-gdd64cec27+
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 4632 of file Account.cpp.

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

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

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

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

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

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

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

◆ gnc_account_create_root()

Account* gnc_account_create_root ( QofBook *  book)

Create a new root level account.

Definition at line 1110 of file Account.cpp.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4782 {
4783  AccountPrivate *from_priv;
4784  GList *children, *node;
4785 
4786  /* errors */
4787  g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
4788  g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
4789 
4790  /* optimizations */
4791  from_priv = GET_PRIVATE(from_parent);
4792  if (!from_priv->children)
4793  return;
4794 
4795  ENTER (" ");
4796  children = g_list_copy(from_priv->children);
4797  for (node = children; node; node = g_list_next(node))
4798  gnc_account_append_child(to_parent, static_cast <Account*> (node->data));
4799  g_list_free(children);
4800  LEAVE (" ");
4801 }
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:2524
#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:2754
const char * xaccAccountGetName(const Account *acc)
Get the account&#39;s name.
Definition: Account.cpp:3030

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account account)

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

Definition at line 2483 of file Account.cpp.

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

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

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

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

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account acc)

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

Definition at line 4269 of file Account.cpp.

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

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

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

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

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

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

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

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account account,
gboolean  flag 
)

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

Definition at line 2467 of file Account.cpp.

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

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

1795 {
1796  AccountPrivate *priv;
1797 
1798  g_return_if_fail(GNC_IS_ACCOUNT(acc));
1799 
1800  priv = GET_PRIVATE(acc);
1801  if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
1802  return;
1803  priv->splits = g_list_sort(priv->splits, (GCompareFunc)xaccSplitOrder);
1804  priv->sort_dirty = FALSE;
1805  priv->balance_dirty = TRUE;
1806 }
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 1127 of file Account.cpp.

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