Account

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

Files
file	Account.h
	Account handling public routines.
file	Account.hpp
	Account public routines (C++ api)

Data Structures
struct	AccountClass

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

Typedefs
typedef gnc_numeric(*	xaccGetBalanceFn) (const Account *account)
typedef gnc_numeric(*	xaccGetBalanceInCurrencyFn) (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
typedef gnc_numeric(*	xaccGetBalanceAsOfDateFn) (Account *account, time64 date)
typedef void(*	AccountCb) (Account *a, gpointer data)
typedef gpointer(*	AccountCb2) (Account *a, gpointer data)
using	SplitsVec = std::vector< Split * >

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

Functions
GType	gnc_account_get_type (void)
	Returns the GType type system description of the Account class. More...
gboolean	gnc_account_and_descendants_empty (Account *acc)
gchar *	gnc_account_name_violations_errmsg (const gchar *separator, GList *invalid_account_names)
	Composes a translatable error message showing which account names clash with the current account separator. More...
GList *	gnc_account_list_name_violations (QofBook *book, const gchar *separator)
	Runs through all the accounts and returns a list of account names that contain the provided separator character. More...
void	xaccAccountSetReconcileChildrenStatus (Account *account, gboolean status)
	DOCUMENT ME!
gboolean	xaccAccountGetReconcileChildrenStatus (const Account *account)
	DOCUMENT ME!
gboolean	xaccAccountHasAncestor (const Account *acc, const Account *ancestor)
	Returns true if the account is 'ancestor' or has 'ancestor' as an ancestor. More...
const SplitsVec	xaccAccountGetSplits (const Account *)
void	gnc_account_foreach_split (const Account *, std::function< void(Split *)>, bool)
void	gnc_account_foreach_split_until_date (const Account *acc, time64 end_date, std::function< void(Split *)> f)
Split *	gnc_account_find_split (const Account *, std::function< bool(const Split *)>, bool)
	scans account split list (in forward or reverse order) until predicate split->bool returns true. More...

Account Constructors, Edit/Commit, Comparison
Account *	xaccMallocAccount (QofBook *book)
	Constructor.
Account *	gnc_account_create_root (QofBook *book)
	Create a new root level account. More...
Account *	xaccCloneAccount (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)
Account *	gnc_book_get_root_account (QofBook *book)
void	gnc_book_set_root_account (QofBook *book, Account *root)
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. 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	xaccAccountSetAssociatedAccount (Account *acc, const char *tag, const Account *assoc_acct)
	Set the account's associated account e.g. More...
void	xaccAccountSetLastNum (Account *account, const char *num)
	Set the last num field of an Account.
void	gnc_account_set_policy (Account *account, GNCPolicy *policy)
	Set the account's lot order policy.
GNCAccountType	xaccAccountGetType (const Account *account)
	Returns the account's account type. More...
gboolean	xaccAccountIsPriced (const Account *acc)
	Returns true if the account is a stock, mutual fund or currency, otherwise false. More...
void	gnc_account_set_start_balance (Account *acc, const gnc_numeric start_baln)
	This function will set the starting commodity balance for this account. More...
void	gnc_account_set_start_cleared_balance (Account *acc, const gnc_numeric start_baln)
	This function will set the starting cleared commodity balance for this account. More...
void	gnc_account_set_start_reconciled_balance (Account *acc, const gnc_numeric start_baln)
	This function will set the starting reconciled commodity balance for this account. More...
void	gnc_account_set_balance_dirty (Account *acc)
	Tell the account that the running balances may be incorrect and need to be recomputed. More...
void	gnc_account_set_sort_dirty (Account *acc)
	Tell the account believes that the splits may be incorrectly sorted and need to be resorted. More...
void	gnc_account_set_defer_bal_computation (Account *acc, gboolean defer)
	Set the defer balance flag. More...
gboolean	gnc_account_insert_split (Account *acc, Split *s)
	Insert the given split from an account. More...
gboolean	gnc_account_remove_split (Account *acc, Split *s)
	Remove the given split from an account. More...
const char *	xaccAccountGetName (const Account *account)
	Get the account's name.
const char *	xaccAccountGetCode (const Account *account)
	Get the account's accounting code.
const char *	xaccAccountGetDescription (const Account *account)
	Get the account's description.
const char *	xaccAccountGetColor (const Account *account)
	Get the account's color.
const char *	xaccAccountGetFilter (const Account *account)
	Get the account's filter.
const char *	xaccAccountGetSortOrder (const Account *account)
	Get the account's Sort Order.
gboolean	xaccAccountGetSortReversed (const Account *account)
	Get the account's Sort Order direction.
const char *	xaccAccountGetNotes (const Account *account)
	Get the account's notes.
Account *	xaccAccountGetAssociatedAccount (const Account *acc, const char *tag)
	Get the account's associated account e.g. More...
const char *	xaccAccountGetLastNum (const Account *account)
	Get the last num field of an Account.
GNCPolicy *	gnc_account_get_policy (Account *account)
	Get the account's lot order policy.
gboolean	gnc_account_get_defer_bal_computation (Account *acc)
	Get the account's flag for deferred balance computation.
void	xaccAccountRecomputeBalance (Account *)
	The following recompute the partial balances (stored with the transaction) and the total balance, for this account.
void	xaccAccountSortSplits (Account *acc, gboolean force)
	The xaccAccountSortSplits() routine will resort the account's splits if the sort is dirty. More...
gchar *	gnc_account_get_full_name (const Account *account)
	The gnc_account_get_full_name routine returns the fully qualified name of the account using the given separator char. More...
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. More...
void	dxaccAccountSetPriceSrc (Account *account, const char *src)
	Set a string that identifies the Finance::Quote backend that should be used to retrieve online prices. More...
const char *	dxaccAccountGetPriceSrc (const Account *account)
	Get a string that identifies the Finance::Quote backend that should be used to retrieve online prices. More...

Account Commodity setters/getters
Accounts are used to store an amount of 'something', that 'something' is called the 'commodity'. An account can only hold one kind of commodity. The following are used to get and set the commodity, and also to set the SCU, the 'Smallest Commodity Unit'. Note that when we say that a 'split' holds an 'amount', that amount is denominated in the account commodity. Do not confuse 'amount' and 'value'. The 'value' of a split is the value of the amount expressed in the currency of the transaction. Thus, for example, the 'amount' may be 12 apples, where the account commodity is 'apples'. The value of these 12 apples may be 12 dollars, where the transaction currency is 'dollars'. The SCU is the 'Smallest Commodity Unit', signifying the smallest non-zero amount that can be stored in the account. It is represented as the integer denominator of a fraction. Thus, for example, a SCU of 12 means that 1/12 of something is the smallest amount that can be stored in the account. SCU's can be any value; they do not need to be decimal. This allows the use of accounts with unusual, non-decimal commodities and currencies. Normally, the SCU is determined by the commodity of the account. However, this default SCU can be over-ridden and set to an account-specific value. This is account-specific value is called the 'non-standard' value in the documentation below.
void	xaccAccountSetCommodity (Account *account, gnc_commodity *comm)
	Set the account's commodity.
gnc_commodity *	xaccAccountGetCommodity (const Account *account)
	Get the account's commodity.
gnc_commodity *	gnc_account_get_currency_or_parent (const Account *account)
	Returns a gnc_commodity that is a currency, suitable for being a Transaction's currency. More...
int	xaccAccountGetCommoditySCU (const Account *account)
	Return the SCU for the account. More...
int	xaccAccountGetCommoditySCUi (const Account *account)
	Return the 'internal' SCU setting. More...
void	xaccAccountSetCommoditySCU (Account *account, int frac)
	Set the SCU for the account. More...
void	xaccAccountSetNonStdSCU (Account *account, gboolean flag)
	Set the flag indicating that this account uses a non-standard SCU. More...
gboolean	xaccAccountGetNonStdSCU (const Account *account)
	Return boolean, indicating whether this account uses a non-standard SCU. More...

Account Balance
gnc_numeric	xaccAccountGetBalance (const Account *account)
	Get the current balance of the account, which may include future splits.
gnc_numeric	xaccAccountGetClearedBalance (const Account *account)
	Get the current balance of the account, only including cleared transactions.
gnc_numeric	xaccAccountGetReconciledBalance (const Account *account)
	Get the current balance of the account, only including reconciled transactions.
gnc_numeric	xaccAccountGetPresentBalance (const Account *account)
gnc_numeric	xaccAccountGetProjectedMinimumBalance (const Account *account)
gnc_numeric	xaccAccountGetBalanceAsOfDate (Account *account, time64 date)
	Get the balance of the account at the end of the day before the date specified. More...
gnc_numeric	xaccAccountGetReconciledBalanceAsOfDate (Account *account, time64 date)
	Get the reconciled balance of the account at the end of the day of the date specified. More...
gnc_numeric	xaccAccountConvertBalanceToCurrency (const Account *account, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency)
gnc_numeric	xaccAccountConvertBalanceToCurrencyAsOfDate (const Account *account, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency, time64 date)
gnc_numeric	xaccAccountGetBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
gnc_numeric	xaccAccountGetClearedBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
gnc_numeric	xaccAccountGetReconciledBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
gnc_numeric	xaccAccountGetPresentBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
gnc_numeric	xaccAccountGetProjectedMinimumBalanceInCurrency (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)
gnc_numeric	xaccAccountGetNoclosingBalanceAsOfDateInCurrency (Account *acc, time64 date, gnc_commodity *report_commodity, gboolean include_children)
	This function gets the balance at the end of the given date, ignoring closing entries, in the desired commodity. More...
gnc_numeric	xaccAccountGetBalanceAsOfDateInCurrency (Account *account, time64 date, gnc_commodity *report_commodity, gboolean include_children)
	This function gets the balance at the end of the given date in the desired commodity. More...
gnc_numeric	xaccAccountGetNoclosingBalanceChangeForPeriod (Account *acc, time64 date1, time64 date2, gboolean recurse)
gnc_numeric	xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod (Account *acc, time64 date1, time64 date2, gboolean recurse)
gnc_numeric	xaccAccountGetBalanceChangeForPeriod (Account *acc, time64 date1, time64 date2, gboolean recurse)

Account Children and Parents.
The set of accounts is represented as a doubly-linked tree, so that given any account, both its parent and its children can be easily found. At the top of the tree hierarchy lies a single root node, the root account. The account tree hierarchy is unique, in that a given account can have only one parent account.
void	gnc_account_append_child (Account *new_parent, Account *child)
	This function will remove from the child account any pre-existing parent relationship, and will then add the account as a child of the new parent. More...
void	gnc_account_remove_child (Account *parent, Account *child)
	This function will remove the specified child account from the specified parent account. More...
Account *	gnc_account_get_parent (const Account *account)
	This routine returns a pointer to the parent of the specified account. More...
Account *	gnc_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...
Account *	gnc_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

enum GNCAccountType

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

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

Note

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

Enumerator
ACCT_TYPE_INVALID	Not a type.
ACCT_TYPE_NONE	Not a type.
ACCT_TYPE_BANK	The bank account type denotes a savings or checking account held at a bank. Often interest bearing.
ACCT_TYPE_CASH	The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
ACCT_TYPE_CREDIT	The Credit card account is used to denote credit (e.g. amex) and debit (e.g. visa, mastercard) card accounts
ACCT_TYPE_ASSET	asset (and liability) accounts indicate generic, generalized accounts that are none of the above.
ACCT_TYPE_LIABILITY	liability (and asset) accounts indicate generic, generalized accounts that are none of the above.
ACCT_TYPE_STOCK	Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
ACCT_TYPE_MUTUAL	Mutual Fund accounts will typically be shown in registers which show three columns: price, number of shares, and value.
ACCT_TYPE_CURRENCY	The currency account type indicates that the account is a currency trading account. In many ways, a currency trading account is like a stock * trading account. It is shown in the register with three columns: price, number of shares, and value. Note: Since version 1.7.0, this account is * no longer needed to exchange currencies between accounts, so this type is DEPRECATED.
ACCT_TYPE_INCOME	Income accounts are used to denote income.
ACCT_TYPE_EXPENSE	Expense accounts are used to denote expenses.
ACCT_TYPE_EQUITY	Equity account is used to balance the balance sheet.
ACCT_TYPE_RECEIVABLE	A/R account type.
ACCT_TYPE_PAYABLE	A/P account type.
ACCT_TYPE_ROOT	The hidden root account of an account tree.
ACCT_TYPE_TRADING	Account used to record multiple commodity transactions. This is not the same as ACCT_TYPE_CURRENCY above. Multiple commodity transactions have splits in these accounts to make the transaction balance in each commodity as well as in total value.
NUM_ACCOUNT_TYPES	stop here; the following types just aren't ready for prime time
ACCT_TYPE_CHECKING	bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
ACCT_TYPE_SAVINGS	bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
ACCT_TYPE_MONEYMRKT	bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
ACCT_TYPE_CREDITLINE	line of credit – don't use this for now, see NUM_ACCOUNT_TYPES

Definition at line 101 of file Account.h.

{
    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,  
    /* bank account types */
    ACCT_TYPE_CHECKING = 15, 
    ACCT_TYPE_SAVINGS = 16, 
    ACCT_TYPE_MONEYMRKT = 17, 
    ACCT_TYPE_CREDITLINE = 18, 
    ACCT_TYPE_LAST
#ifdef __cplusplus
};
#else
} GNCAccountType;

Function Documentation

dxaccAccountGetPriceSrc()

const char* dxaccAccountGetPriceSrc

(

const Account *

account

)

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

See price-quotes.scm for more information. This function uses a static char*.

Deprecated:

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

Definition at line 5280 of file Account.cpp.

{
    static char *source = nullptr;
    if (!acc) return nullptr;

    if (!xaccAccountIsPriced(acc)) return nullptr;

    g_free (source);

    GValue v = G_VALUE_INIT;
    auto rv = get_kvp_string_tag (acc, "old-price-source", &v);
    g_value_unset (&v);
    return rv;
}

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

{
    if (!acc) return;

    if (xaccAccountIsPriced(acc))
        set_kvp_string_tag (acc, "old-price-source", src);
}

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_parent	The new parent account to which the child should be attached.
child	The account to attach.

Definition at line 2804 of file Account.cpp.

{
    AccountPrivate *ppriv, *cpriv;
    Account *old_parent;
    QofCollection *col;

    /* errors */
    g_assert(GNC_IS_ACCOUNT(new_parent));
    g_assert(GNC_IS_ACCOUNT(child));

    /* optimizations */
    ppriv = GET_PRIVATE(new_parent);
    cpriv = GET_PRIVATE(child);
    old_parent = cpriv->parent;
    if (old_parent == new_parent)
        return;

    //  xaccAccountBeginEdit(new_parent);
    xaccAccountBeginEdit(child);
    if (old_parent)
    {
        gnc_account_remove_child(old_parent, child);

        if (!qof_instance_books_equal(old_parent, new_parent))
        {
            /* hack alert -- this implementation is not exactly correct.
             * If the entity tables are not identical, then the 'from' book
             * may have a different backend than the 'to' book.  This means
             * that we should get the 'from' backend to destroy this account,
             * and the 'to' backend to save it.  Right now, this is broken.
             *
             * A 'correct' implementation similar to this is in Period.c
             * except its for transactions ...
             *
             * Note also, we need to reparent the children to the new book as well.
             */
            PWARN ("reparenting accounts across books is not correctly supported\n");

            qof_event_gen (&child->inst, QOF_EVENT_DESTROY, nullptr);
            col = qof_book_get_collection (qof_instance_get_book(new_parent),
                                           GNC_ID_ACCOUNT);
            qof_collection_insert_entity (col, &child->inst);
            qof_event_gen (&child->inst, QOF_EVENT_CREATE, nullptr);
        }
    }
    cpriv->parent = new_parent;
    ppriv->children = g_list_append(ppriv->children, child);
    qof_instance_set_dirty(&new_parent->inst);
    qof_instance_set_dirty(&child->inst);

    /* Send events data. Warning: The call to commit_edit is also going
     * to send a MODIFY event. If the gtktreemodelfilter code gets the
     * MODIFY before it gets the ADD, it gets very confused and thinks
     * that two nodes have been added. */
    qof_event_gen (&child->inst, QOF_EVENT_ADD, nullptr);
    // qof_event_gen (&new_parent->inst, QOF_EVENT_MODIFY, nullptr);

    xaccAccountCommitEdit (child);
    //  xaccAccountCommitEdit(new_parent);
}

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

parent	The parent account to check.
child	The child account to find.

Returns

The index of the child account within the specified parent, or -1.

Definition at line 2962 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
    g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
    return g_list_index(GET_PRIVATE(parent)->children, child);
}

gnc_account_create_root()

Account* gnc_account_create_root

(

QofBook *

book

)

Create a new root level account.

Definition at line 1289 of file Account.cpp.

{
    Account *root;
    AccountPrivate *rpriv;

    root = xaccMallocAccount(book);
    rpriv = GET_PRIVATE(root);
    xaccAccountBeginEdit(root);
    rpriv->type = ACCT_TYPE_ROOT;
    rpriv->accountName = qof_string_cache_replace(rpriv->accountName, "Root Account");
    mark_account (root);
    xaccAccountCommitEdit(root);
    gnc_book_set_root_account(book, root);
    return root;
}

gnc_account_find_split()

Split* gnc_account_find_split	(	const Account *	,
		std::function< bool(const Split *)>	,
		bool
	)

scans account split list (in forward or reverse order) until predicate split->bool returns true.

Maybe return the split.

Parameters

acc	The account to which the split should be added.
predicate	A split->bool predicate.
reverse	To scan in reverse order

Returns

Split* or nullptr if not found

Definition at line 1172 of file Account.cpp.

{
    if (!GNC_IS_ACCOUNT (acc))
        return nullptr;

    auto splits{GET_PRIVATE(acc)->splits};
    if (reverse)
    {
        auto latest = std::find_if(splits.rbegin(), splits.rend(), predicate);
        return (latest == splits.rend()) ? nullptr : *latest;
    }
    else
    {
        auto earliest = std::find_if(splits.begin(), splits.end(), predicate);
        return (earliest == splits.end()) ? nullptr : *earliest;
    }
}

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

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

Definition at line 3230 of file Account.cpp.

{
    const AccountPrivate *priv;
    GList *node;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));
    g_return_if_fail(thunk);

    priv = GET_PRIVATE(acc);
    for (node = priv->children; node; node = node->next)
    {
        thunk (static_cast<Account*>(node->data), user_data);
    }
}

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

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

Definition at line 3248 of file Account.cpp.

{
    account_foreach_descendant (acc, thunk, user_data, FALSE);
}

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

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

Definition at line 3256 of file Account.cpp.

{
    gpointer result {nullptr};

    g_return_val_if_fail (GNC_IS_ACCOUNT(acc), nullptr);
    g_return_val_if_fail (thunk, nullptr);

    auto priv{GET_PRIVATE(acc)};

    for (auto node = priv->children; node; node = node->next)
    {
        auto child = static_cast<Account*>(node->data);
        result = thunk (child, user_data);
        if (result) break;

        result = gnc_account_foreach_descendant_until (child, thunk, user_data);
        if (result) break;
    }

    return result;
}

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

account

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

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(account), nullptr);
    return g_list_copy(GET_PRIVATE(account)->children);
}

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

{
    AccountPrivate *priv;

    /* errors */
    g_return_val_if_fail(GNC_IS_ACCOUNT(account), nullptr);

    /* optimizations */
    priv = GET_PRIVATE(account);
    if (!priv->children)
        return nullptr;
    return g_list_sort(g_list_copy(priv->children), (GCompareFunc)xaccAccountOrder);
}

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

{
    gnc_commodity * commodity;
    g_return_val_if_fail (account, nullptr);

    commodity = xaccAccountGetCommodity (account);
    if (gnc_commodity_is_currency(commodity))
        return commodity;
    else
    {
        const Account *parent_account = account;
        /* Account commodity is not a currency, walk up the tree until
         * we find a parent account that is a currency account and use
         * it's currency.
         */
        do
        {
            parent_account = gnc_account_get_parent (parent_account);
            if (parent_account)
            {
                commodity = xaccAccountGetCommodity (parent_account);
                if (gnc_commodity_is_currency(commodity))
                {
                    return commodity;
                    //break;
                }
            }
        }
        while (parent_account);
    }
    return nullptr; // no suitable commodity found.
}

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

account

The account to query.

Returns

The number of levels below the root.

Definition at line 2992 of file Account.cpp.

{
    AccountPrivate *priv;
    int depth = 0;

    g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);

    priv = GET_PRIVATE(account);
    while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
    {
        account = priv->parent;
        priv = GET_PRIVATE(account);
        depth++;
    }

    return depth;
}

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

account

The 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 3039 of file Account.cpp.

{
    GList* list = nullptr;
    account_foreach_descendant (account, collect_acct, &list, FALSE);
    return g_list_reverse (list);
}

gnc_account_get_descendants_sorted()

GList* gnc_account_get_descendants_sorted

(

const Account *

account

)

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

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

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

Parameters

account

The 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 3047 of file Account.cpp.

{
    GList* list = nullptr;
    account_foreach_descendant (account, collect_acct, &list, TRUE);
    return g_list_reverse (list);
}

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

{
    AccountPrivate *priv;
    const Account *a;
    char *fullname;
    const gchar **names;
    int level;

    /* So much for hardening the API. Too many callers to this function don't
     * bother to check if they have a non-nullptr pointer before calling. */
    if (nullptr == account)
        return g_strdup("");

    /* errors */
    g_return_val_if_fail(GNC_IS_ACCOUNT(account), g_strdup(""));

    /* optimizations */
    priv = GET_PRIVATE(account);
    if (!priv->parent)
        return g_strdup("");

    /* Figure out how much space is needed by counting the nodes up to
     * the root. */
    level = 0;
    for (a = account; a; a = priv->parent)
    {
        priv = GET_PRIVATE(a);
        level++;
    }

    /* Get all the pointers in the right order. The root node "entry"
     * becomes the terminating nullptr pointer for the array of strings. */
    names = (const gchar **)g_malloc(level * sizeof(gchar *));
    names[--level] = nullptr;
    for (a = account; level > 0; a = priv->parent)
    {
        priv = GET_PRIVATE(a);
        names[--level] = priv->accountName;
    }

    /* Build the full name */
    fullname = g_strjoinv(account_separator, (gchar **)names);
    g_free(names);

    return fullname;
}

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

account

A pointer to any exiting account.

Returns

A pointer to the parent account node, or NULL if there is no parent account.

Definition at line 2902 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
    return GET_PRIVATE(acc)->parent;
}

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

account

A 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 2909 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);

    priv = GET_PRIVATE(acc);
    while (priv->parent)
    {
        acc = priv->parent;
        priv = GET_PRIVATE(acc);
    }

    return acc;
}

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

account

The account to query.

Returns

The number of levels of descendants.

Definition at line 3011 of file Account.cpp.

{
    AccountPrivate *priv;
    GList *node;
    gint depth = 0, child_depth;

    g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);

    priv = GET_PRIVATE(account);
    if (!priv->children)
        return 1;

    for (node = priv->children; node; node = g_list_next(node))
    {
        child_depth = gnc_account_get_tree_depth(static_cast<Account const *>(node->data));
        depth = MAX(depth, child_depth);
    }
    return depth + 1;
}

gnc_account_get_type()

GType gnc_account_get_type

(

void

)

Returns the GType type system description of the Account class.

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

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

{
    return gnc_mockaccount_get_type();
}

gnc_account_insert_split()

gboolean gnc_account_insert_split	(	Account *	acc,
		Split *	s
	)

Insert the given split from an account.

Parameters

acc	The account to which the split should be added.
s	The 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 1964 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
    g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);

    priv = GET_PRIVATE(acc);
    if (!g_hash_table_add (priv->splits_hash, s))
        return false;

    priv->splits.push_back (s);

    if (qof_instance_get_editlevel(acc) == 0)
        std::sort (priv->splits.begin(), priv->splits.end(), split_cmp_less);
    else
        priv->sort_dirty = true;

    //FIXME: find better event
    qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, nullptr);
    /* Also send an event based on the account */
    qof_event_gen(&acc->inst, GNC_EVENT_ITEM_ADDED, s);

    priv->balance_dirty = TRUE;
//  DRH: Should the below be added? It is present in the delete path.
//  xaccAccountRecomputeBalance(acc);
    return TRUE;
}

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

account

A pointer to any account.

Returns

TRUE if this account is of type ROOT. FALSE otherwise.

Definition at line 2926 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(account), FALSE);
    return (GET_PRIVATE(account)->parent == nullptr);
}

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

{
    AccountPrivate *from_priv;
    GList *children, *node;

    /* errors */
    g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
    g_return_if_fail(GNC_IS_ACCOUNT(from_parent));

    /* optimizations */
    from_priv = GET_PRIVATE(from_parent);
    if (!from_priv->children)
        return;

    ENTER (" ");
    children = g_list_copy(from_priv->children);
    for (node = children; node; node = g_list_next(node))
        gnc_account_append_child(to_parent, static_cast <Account*> (node->data));
    g_list_free(children);
    LEAVE (" ");
}

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

book	Pointer to the book with accounts to verify
separator	The separator character to verify against

Returns

A GList of invalid account names. Should be freed with g_list_free_full (value, g_free) when no longer needed.

Definition at line 271 of file Account.cpp.

{
    g_return_val_if_fail (separator != nullptr, nullptr);
    if (!book) return nullptr;
    ViolationData cb = { nullptr, separator };
    gnc_account_foreach_descendant (gnc_book_get_root_account (book),
                                    (AccountCb)check_acct_name, &cb);
    return cb.list;
}

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

{
    AccountPrivate *ppriv, *priv_a, *priv_b;
    GList *node_a, *node_b, *work, *worker;

    g_return_if_fail(GNC_IS_ACCOUNT(parent));

    ppriv = GET_PRIVATE(parent);
    for (node_a = ppriv->children; node_a; node_a = node_a->next)
    {
        Account *acc_a = static_cast <Account*> (node_a->data);

        priv_a = GET_PRIVATE(acc_a);
        for (node_b = node_a->next; node_b; node_b = g_list_next(node_b))
        {
            Account *acc_b = static_cast <Account*> (node_b->data);

            priv_b = GET_PRIVATE(acc_b);
            if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
                continue;
            if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
                continue;
            if (0 != null_strcmp(priv_a->description, priv_b->description))
                continue;
            if (0 != null_strcmp(xaccAccountGetColor(acc_a),
                                 xaccAccountGetColor(acc_b)))
                continue;
            if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
                continue;
            if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
                                 xaccAccountGetNotes(acc_b)))
                continue;
            if (priv_a->type != priv_b->type)
                continue;

            /* consolidate children */
            if (priv_b->children)
            {
                work = g_list_copy(priv_b->children);
                for (worker = work; worker; worker = g_list_next(worker))
                    gnc_account_append_child (acc_a, (Account *)worker->data);
                g_list_free(work);

                qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, nullptr);
                qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, nullptr);
            }

            /* recurse to do the children's children */
            gnc_account_merge_children (acc_a);

            /* consolidate transactions */
            while (!priv_b->splits.empty())
                xaccSplitSetAccount (priv_b->splits.front(), acc_a);

            /* move back one before removal. next iteration around the loop
             * will get the node after node_b */
            node_b = g_list_previous(node_b);

            /* The destroy function will remove from list -- node_a is ok,
             * it's before node_b */
            xaccAccountBeginEdit (acc_b);
            xaccAccountDestroy (acc_b);
        }
    }
}

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

account

The account to query.

Returns

The number of children of the specified account.

Definition at line 2955 of file Account.cpp.

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

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

account

The account to query.

Returns

The number of descendants of the specified account.

Definition at line 2984 of file Account.cpp.

{
    int count {0};
    account_foreach_descendant (account, count_acct, &count, FALSE);
    return count;
}

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

separator	The separator character that was verified against
invalid_account_names	A 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 233 of file Account.cpp.

{
    gchar *message = nullptr;

    if ( !invalid_account_names )
        return nullptr;

    auto account_list {gnc_g_list_stringjoin (invalid_account_names, "\n")};

    /* Translators: The first %s will be the account separator character,
       the second %s is a list of account names.
       The resulting string will be displayed to the user if there are
       account names containing the separator character. */
    message = g_strdup_printf(
                  _("The separator character \"%s\" is used in one or more account names.\n\n"
                    "This will result in unexpected behaviour. "
                    "Either change the account names or choose another separator character.\n\n"
                    "Below you will find the list of invalid account names:\n"
                    "%s"), separator, account_list );
    g_free ( account_list );
    return message;
}

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

parent	The parent account to check.
num	The index number of the child account that should be returned.

Returns

A pointer to the specified child account, or NULL

Definition at line 2970 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(parent), nullptr);
    return static_cast<Account*>(g_list_nth_data(GET_PRIVATE(parent)->children, num));
}

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

parent	The parent account from which the child should be removed.
child	The child account to remove.

Definition at line 2866 of file Account.cpp.

{
    AccountPrivate *ppriv, *cpriv;
    GncEventData ed;

    if (!child) return;

    /* Note this routine might be called on accounts which
     * are not yet parented. */
    if (!parent) return;

    ppriv = GET_PRIVATE(parent);
    cpriv = GET_PRIVATE(child);

    if (cpriv->parent != parent)
    {
        PERR ("account not a child of parent");
        return;
    }

    /* Gather event data */
    ed.node = parent;
    ed.idx = g_list_index(ppriv->children, child);

    ppriv->children = g_list_remove(ppriv->children, child);

    /* Now send the event. */
    qof_event_gen(&child->inst, QOF_EVENT_REMOVE, &ed);

    /* clear the account's parent pointer after REMOVE event generation. */
    cpriv->parent = nullptr;

    qof_event_gen (&parent->inst, QOF_EVENT_MODIFY, nullptr);
}

gnc_account_remove_split()

gboolean gnc_account_remove_split	(	Account *	acc,
		Split *	s
	)

Remove the given split from an account.

Parameters

acc	The account from which the split should be removed.
s	The 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 1994 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
    g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);

    priv = GET_PRIVATE(acc);

    if (!g_hash_table_remove (priv->splits_hash, s))
        return false;
    auto it = std::remove (priv->splits.begin(), priv->splits.end(), s);
    priv->splits.erase (it, priv->splits.end());
    //FIXME: find better event type
    qof_event_gen(&acc->inst, QOF_EVENT_MODIFY, nullptr);
    // And send the account-based event, too
    qof_event_gen(&acc->inst, GNC_EVENT_ITEM_REMOVED, s);

    priv->balance_dirty = TRUE;
    xaccAccountRecomputeBalance(acc);
    return TRUE;
}

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

acc	Set the flag on this account.

Definition at line 1919 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    if (qof_instance_get_destroying(acc))
        return;

    priv = GET_PRIVATE(acc);
    priv->balance_dirty = TRUE;
}

gnc_account_set_defer_bal_computation()

void gnc_account_set_defer_bal_computation	(	Account *	acc,
		gboolean	defer
	)

Set the defer balance flag.

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

Parameters

acc	Set the flag on this account.
defer	New value for the flag.

Definition at line 1932 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_if_fail (GNC_IS_ACCOUNT (acc));

    if (qof_instance_get_destroying (acc))
        return;

    priv = GET_PRIVATE (acc);
    priv->defer_bal_computation = defer;
}

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

acc	Set the flag on this account.

Definition at line 1905 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    if (qof_instance_get_destroying(acc))
        return;

    priv = GET_PRIVATE(acc);
    priv->sort_dirty = TRUE;
}

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

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    priv->starting_balance = start_baln;
    priv->balance_dirty = TRUE;
}

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

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    priv->starting_cleared_balance = start_baln;
    priv->balance_dirty = TRUE;
}

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

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    priv->starting_reconciled_balance = start_baln;
    priv->balance_dirty = TRUE;
}

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

{
    return account_separator;
}

xaccAccountBeginEdit()

void xaccAccountBeginEdit

(

Account *

account

)

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

Definition at line 1485 of file Account.cpp.

{
    g_return_if_fail(acc);
    qof_begin_edit(&acc->inst);
}

xaccAccountCommitEdit()

void xaccAccountCommitEdit

(

Account *

account

)

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

Definition at line 1526 of file Account.cpp.

{
    AccountPrivate *priv;
    QofBook *book;

    g_return_if_fail(acc);
    if (!qof_commit_edit(&acc->inst)) return;

    /* If marked for deletion, get rid of subaccounts first,
     * and then the splits ... */
    priv = GET_PRIVATE(acc);
    if (qof_instance_get_destroying(acc))
    {
        QofCollection *col;

        qof_instance_increase_editlevel(acc);

        /* First, recursively free children */
        xaccFreeAccountChildren(acc);

        PINFO ("freeing splits for account %p (%s)",
               acc, priv->accountName ? priv->accountName : "(null)");

        book = qof_instance_get_book(acc);

        /* If book is shutting down, just clear the split list.  The splits
           themselves will be destroyed by the transaction code */
        if (!qof_book_shutting_down(book))
        {
            for (auto s : priv->splits)
                xaccSplitDestroy (s);
        }
        else
        {
            priv->splits.clear();
            g_hash_table_remove_all (priv->splits_hash);
        }

        /* It turns out there's a case where this assertion does not hold:
           When the user tries to delete an Imbalance account, while also
           deleting all the splits in it.  The splits will just get
           recreated and put right back into the same account!

           g_assert(priv->splits == nullptr || qof_book_shutting_down(acc->inst.book));
        */

        if (!qof_book_shutting_down(book))
        {
            col = qof_book_get_collection(book, GNC_ID_TRANS);
            qof_collection_foreach(col, destroy_pending_splits_for_account, acc);

            /* the lots should be empty by now */
            for (auto lp = priv->lots; lp; lp = lp->next)
            {
                GNCLot *lot = static_cast<GNCLot*>(lp->data);
                gnc_lot_destroy (lot);
            }
        }
        g_list_free(priv->lots);
        priv->lots = nullptr;

        qof_instance_set_dirty(&acc->inst);
        qof_instance_decrease_editlevel(acc);
    }
    else
    {
        xaccAccountBringUpToDate(acc);
    }

    qof_commit_edit_part2(&acc->inst, on_err, on_done, acc_free);
}

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

{
    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    qof_instance_set_destroying(acc, TRUE);

    xaccAccountCommitEdit (acc);
}

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

{
    AccountPrivate *priv_aa, *priv_ab;

    if (!aa && !ab) return TRUE;

    g_return_val_if_fail(GNC_IS_ACCOUNT(aa), FALSE);
    g_return_val_if_fail(GNC_IS_ACCOUNT(ab), FALSE);

    priv_aa = GET_PRIVATE(aa);
    priv_ab = GET_PRIVATE(ab);
    if (priv_aa->type != priv_ab->type)
    {
        PWARN ("types differ: %d vs %d", priv_aa->type, priv_ab->type);
        return FALSE;
    }

    if (g_strcmp0(priv_aa->accountName, priv_ab->accountName) != 0)
    {
        PWARN ("names differ: %s vs %s", priv_aa->accountName, priv_ab->accountName);
        return FALSE;
    }

    if (g_strcmp0(priv_aa->accountCode, priv_ab->accountCode) != 0)
    {
        PWARN ("codes differ: %s vs %s", priv_aa->accountCode, priv_ab->accountCode);
        return FALSE;
    }

    if (g_strcmp0(priv_aa->description, priv_ab->description) != 0)
    {
        PWARN ("descriptions differ: %s vs %s", priv_aa->description, priv_ab->description);
        return FALSE;
    }

    if (!gnc_commodity_equal(priv_aa->commodity, priv_ab->commodity))
    {
        PWARN ("commodities differ");
        return FALSE;
    }

    if (check_guids)
    {
        if (qof_instance_guid_compare(aa, ab) != 0)
        {
            PWARN ("GUIDs differ");
            return FALSE;
        }
    }

    if (qof_instance_compare_kvp (QOF_INSTANCE (aa), QOF_INSTANCE (ab)) != 0)
    {
        char *frame_a;
        char *frame_b;

        frame_a = qof_instance_kvp_as_string (QOF_INSTANCE (aa));
        frame_b = qof_instance_kvp_as_string (QOF_INSTANCE (ab));

        PWARN ("kvp frames differ:\n%s\n\nvs\n\n%s", frame_a, frame_b);

        g_free (frame_a);
        g_free (frame_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->starting_balance, priv_ab->starting_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->starting_balance);
        str_b = gnc_numeric_to_string(priv_ab->starting_balance);

        PWARN ("starting balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->starting_noclosing_balance,
                           priv_ab->starting_noclosing_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->starting_noclosing_balance);
        str_b = gnc_numeric_to_string(priv_ab->starting_noclosing_balance);

        PWARN ("starting noclosing balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }
    if (!gnc_numeric_equal(priv_aa->starting_cleared_balance,
                           priv_ab->starting_cleared_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->starting_cleared_balance);
        str_b = gnc_numeric_to_string(priv_ab->starting_cleared_balance);

        PWARN ("starting cleared balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->starting_reconciled_balance,
                           priv_ab->starting_reconciled_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->starting_reconciled_balance);
        str_b = gnc_numeric_to_string(priv_ab->starting_reconciled_balance);

        PWARN ("starting reconciled balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->balance, priv_ab->balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->balance);
        str_b = gnc_numeric_to_string(priv_ab->balance);

        PWARN ("balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->noclosing_balance, priv_ab->noclosing_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->noclosing_balance);
        str_b = gnc_numeric_to_string(priv_ab->noclosing_balance);

        PWARN ("noclosing balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }
    if (!gnc_numeric_equal(priv_aa->cleared_balance, priv_ab->cleared_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->cleared_balance);
        str_b = gnc_numeric_to_string(priv_ab->cleared_balance);

        PWARN ("cleared balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    if (!gnc_numeric_equal(priv_aa->reconciled_balance, priv_ab->reconciled_balance))
    {
        char *str_a;
        char *str_b;

        str_a = gnc_numeric_to_string(priv_aa->reconciled_balance);
        str_b = gnc_numeric_to_string(priv_ab->reconciled_balance);

        PWARN ("reconciled balances differ: %s vs %s", str_a, str_b);

        g_free (str_a);
        g_free (str_b);

        return FALSE;
    }

    /* no parent; always compare downwards. */

    {
        if (priv_aa->splits.size() != priv_ab->splits.size())
        {
            PWARN ("number of splits differs");
            return false;
        }

        for (auto it_a = priv_aa->splits.begin(), it_b = priv_ab->splits.begin();
             it_a != priv_aa->splits.end() && it_b != priv_ab->splits.end();
             ++it_a, ++it_b)
        {
            Split *sa = *it_a;
            Split *sb = *it_b;

            if (!xaccSplitEqual(sa, sb, check_guids, TRUE, FALSE))
            {
                PWARN ("splits differ");
                return false;
            }
        }
    }

    if (!xaccAcctChildrenEqual(priv_aa->children, priv_ab->children, check_guids))
    {
        PWARN ("children differ");
        return FALSE;
    }

    return(TRUE);
}

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

{
    GValue v = G_VALUE_INIT;
    std::vector<std::string> path {KEY_LOT_MGMT, "gains-acct",
        gnc_commodity_get_unique_name (curr)};
    GncGUID *guid = nullptr;
    Account *gains_account;

    g_return_val_if_fail (acc != nullptr, nullptr);
    qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, path);
    if (G_VALUE_HOLDS_BOXED (&v))
        guid = (GncGUID*)g_value_get_boxed (&v);
    if (guid == nullptr) /* No gains account for this currency */
    {
        gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc),
                                                curr);
        guid = (GncGUID*)qof_instance_get_guid (QOF_INSTANCE (gains_account));
        xaccAccountBeginEdit (acc);
        {
             GValue vr = G_VALUE_INIT;
             g_value_init (&vr, GNC_TYPE_GUID);
             g_value_set_boxed (&vr, guid);
             qof_instance_set_path_kvp (QOF_INSTANCE (acc), &vr, path);
             qof_instance_set_dirty (QOF_INSTANCE (acc));
             g_value_unset (&vr);
        }
        xaccAccountCommitEdit (acc);
    }
    else
        gains_account = xaccAccountLookup (guid,
                                           qof_instance_get_book(acc));

    g_value_unset (&v);
    return gains_account;
}

xaccAccountGetAssociatedAccount()

Account* xaccAccountGetAssociatedAccount	(	const Account *	acc,
		const char *	tag
	)

Get the account's associated account e.g.

stock account -> dividend account

Definition at line 3423 of file Account.cpp.

{
    g_return_val_if_fail (GNC_IS_ACCOUNT(acc), nullptr);
    g_return_val_if_fail (tag && *tag, nullptr);

    GValue v = G_VALUE_INIT;
    qof_instance_get_path_kvp (QOF_INSTANCE (acc), &v, { "associated-account", tag });

    auto guid = static_cast<GncGUID*>(G_VALUE_HOLDS_BOXED (&v) ? g_value_get_boxed(&v) : nullptr);
    g_value_unset (&v);

    if (!guid)
        return nullptr;

    auto assoc_acct = xaccAccountLookup (guid, gnc_account_get_book (acc));
    PINFO ("retuning %s assoc %s account = %s", xaccAccountGetName (acc), tag,
           xaccAccountGetName (assoc_acct));
    return assoc_acct;
}

xaccAccountGetBalanceAsOfDate()

gnc_numeric xaccAccountGetBalanceAsOfDate	(	Account *	account,
		time64	date
	)

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

Definition at line 3607 of file Account.cpp.

{
    return GetBalanceAsOfDate (acc, date, xaccSplitGetBalance);
}

xaccAccountGetBalanceAsOfDateInCurrency()

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

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

Definition at line 3925 of file Account.cpp.

{
    return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive (
               acc, date, xaccAccountGetBalanceAsOfDate, report_commodity,
               include_children);
}

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

{
    AccountPrivate *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);

    priv = GET_PRIVATE(acc);
    if (priv->non_standard_scu || !priv->commodity)
        return priv->commodity_scu;
    return gnc_commodity_get_fraction(priv->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 2697 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
    return GET_PRIVATE(acc)->commodity_scu;
}

xaccAccountGetNoclosingBalanceAsOfDateInCurrency()

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

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

Definition at line 3935 of file Account.cpp.

{
    return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive
      (acc, date, xaccAccountGetNoclosingBalanceAsOfDate,
       report_commodity, include_children);
}

xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU

(

const Account *

account

)

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

Definition at line 2733 of file Account.cpp.

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
    return GET_PRIVATE(acc)->non_standard_scu;
}

xaccAccountGetReconciledBalanceAsOfDate()

gnc_numeric xaccAccountGetReconciledBalanceAsOfDate	(	Account *	account,
		time64	date
	)

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

Definition at line 3619 of file Account.cpp.

{
    return GetBalanceAsOfDate (acc, date, xaccSplitGetReconciledBalance);
}

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

{
    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
    return GET_PRIVATE(acc)->type;
}

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

{
    const Account *parent;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
    g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);

    parent = acc;
    while (parent && parent != ancestor)
        parent = GET_PRIVATE(parent)->parent;

    return (parent == ancestor);
}

xaccAccountIsPriced()

gboolean xaccAccountIsPriced

(

const Account *

acc

)

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

Definition at line 4698 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);

    priv = GET_PRIVATE(acc);
    return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
            priv->type == ACCT_TYPE_CURRENCY);
}

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

{
    QofCollection *col;
    if (!guid || !book) return nullptr;
    col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
    return (Account *) qof_collection_lookup_entity (col, guid);
}

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

{
    AccountPrivate *priv_aa, *priv_ab;
    const char *da, *db;
    int ta, tb, result;

    if ( aa && !ab ) return -1;
    if ( !aa && ab ) return +1;
    if ( !aa && !ab ) return 0;

    priv_aa = GET_PRIVATE(aa);
    priv_ab = GET_PRIVATE(ab);

    /* sort on accountCode strings */
    da = priv_aa->accountCode;
    db = priv_ab->accountCode;

    /* Otherwise do a string sort */
    result = g_strcmp0 (da, db);
    if (result)
        return result;

    /* if account-type-order array not initialized, initialize it */
    /* this will happen at most once during program invocation */
    if (-1 == revorder[0])
    {
        int i;
        for (i = 0; i < NUM_ACCOUNT_TYPES; i++)
        {
            revorder [typeorder[i]] = i;
        }
    }

    /* otherwise, sort on account type */
    ta = priv_aa->type;
    tb = priv_ab->type;
    ta = revorder[ta];
    tb = revorder[tb];
    if (ta < tb) return -1;
    if (ta > tb) return +1;

    /* otherwise, sort on accountName strings */
    da = priv_aa->accountName;
    db = priv_ab->accountName;
    result = safe_utf8_collate(da, db);
    if (result)
        return result;

    /* guarantee a stable sort */
    return qof_instance_guid_compare(aa, ab);
}

xaccAccountSetAssociatedAccount()

void xaccAccountSetAssociatedAccount	(	Account *	acc,
		const char *	tag,
		const Account *	assoc_acct
	)

Set the account's associated account e.g.

stock account -> dividend account

Definition at line 2610 of file Account.cpp.

{
    g_return_if_fail (GNC_IS_ACCOUNT(acc));
    g_return_if_fail (tag && *tag);

    std::vector<std::string> path = { "associated-account", tag };
    xaccAccountBeginEdit(acc);

    PINFO ("setting %s assoc %s account = %s", xaccAccountGetName (acc), tag,
           assoc_acct ? xaccAccountGetName (assoc_acct) : nullptr);

    if (GNC_IS_ACCOUNT(assoc_acct))
    {
        GValue v = G_VALUE_INIT;
        g_value_init (&v, GNC_TYPE_GUID);
        g_value_set_static_boxed (&v, xaccAccountGetGUID (assoc_acct));
        qof_instance_set_path_kvp (QOF_INSTANCE (acc), &v, path);
        g_value_unset (&v);
    }
    else
        qof_instance_set_path_kvp (QOF_INSTANCE (acc), nullptr, path);

    mark_account (acc);
    xaccAccountCommitEdit(acc);
}

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

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    xaccAccountBeginEdit(acc);
    priv->commodity_scu = scu;
    if (scu != gnc_commodity_get_fraction(priv->commodity))
        priv->non_standard_scu = TRUE;
    mark_account(acc);
    xaccAccountCommitEdit(acc);
}

xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU	(	Account *	account,
		gboolean	flag
	)

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

Definition at line 2717 of file Account.cpp.

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    if (priv->non_standard_scu == flag)
        return;
    xaccAccountBeginEdit(acc);
    priv->non_standard_scu = flag;
    mark_account (acc);
    xaccAccountCommitEdit(acc);
}

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

{
    AccountPrivate *priv;

    g_return_if_fail(GNC_IS_ACCOUNT(acc));

    priv = GET_PRIVATE(acc);
    if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
        return;
    std::sort (priv->splits.begin(), priv->splits.end(), split_cmp_less);
    priv->sort_dirty = FALSE;
    priv->balance_dirty = TRUE;
}

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

{
    Account *ret;
    AccountPrivate *from_priv, *priv;

    g_return_val_if_fail(GNC_IS_ACCOUNT(from), nullptr);
    g_return_val_if_fail(QOF_IS_BOOK(book), nullptr);

    ENTER (" ");
    ret = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, nullptr));
    g_return_val_if_fail (ret, nullptr);

    from_priv = GET_PRIVATE(from);
    priv = GET_PRIVATE(ret);
    xaccInitAccount (ret, book);

    /* Do not Begin/CommitEdit() here; give the caller
     * a chance to fix things up, and let them do it.
     * Also let caller issue the generate_event (EVENT_CREATE) */
    priv->type = from_priv->type;

    priv->accountName = qof_string_cache_replace(priv->accountName, from_priv->accountName);
    priv->accountCode = qof_string_cache_replace(priv->accountCode, from_priv->accountCode);
    priv->description = qof_string_cache_replace(priv->description, from_priv->description);

    qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));

    /* The new book should contain a commodity that matches
     * the one in the old book. Find it, use it. */
    priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
    gnc_commodity_increment_usage_count(priv->commodity);

    priv->commodity_scu = from_priv->commodity_scu;
    priv->non_standard_scu = from_priv->non_standard_scu;

    qof_instance_set_dirty(&ret->inst);
    LEAVE (" ");
    return ret;
}