GnuCash 7574033+
Loading...
Searching...
No Matches

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)
#define GNC_ACCOUNT_CLASS(k)
#define GNC_IS_ACCOUNT(o)
#define GNC_IS_ACCOUNT_CLASS(k)
#define GNC_ACCOUNT_GET_CLASS(o)

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*>
using AccountVec = std::vector<Account*>

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.
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.
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.
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.
const SplitsVec & xaccAccountGetSplits (const Account *)
void gnc_account_foreach_descendant (const Account *, std::function< void(Account *)> func)
template<typename Fn>
void gnc_account_foreach_split_between_dates (const Account *account, std::optional< time64 > start_date, std::optional< time64 > end_date, bool include_descendants, Fn &&fn)
void gnc_account_foreach_split (const Account *, std::function< void(Split *)>)
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.
std::vector< const Account * > gnc_account_get_all_parents (const Account *account)

Account Constructors, Edit/Commit, Comparison

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

Account lookup and GncGUID routines

const gchar * gnc_get_account_separator_string (void)
 Returns the account separation character chosen by the user.
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.
#define xaccAccountGetGUID(X)
#define xaccAccountReturnGUID(X)
#define xaccAccountLookupDirect(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 xaccAccountSetOnlineID (Account *account, const char *id)
 Set the account's online_id, the identifier (e.g.
void xaccAccountSetAssociatedAccount (Account *acc, const char *tag, const Account *assoc_acct)
 Set the account's associated account e.g.
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.
gboolean xaccAccountIsPriced (const Account *acc)
 Returns true if the account is a stock, mutual fund or currency, otherwise false.
void gnc_account_set_start_balance (Account *acc, const gnc_numeric start_baln)
 This function will set the starting commodity balance for this account.
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.
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.
void gnc_account_set_balance_dirty (Account *acc)
 Tell the account that the running balances may be incorrect and need to be recomputed.
void gnc_account_set_sort_dirty (Account *acc)
 Tell the account believes that the splits may be incorrectly sorted and need to be resorted.
void gnc_account_set_defer_bal_computation (Account *acc, gboolean defer)
 Set the defer balance flag.
gboolean gnc_account_insert_split (Account *acc, Split *s)
 Insert the given split from an account.
gboolean gnc_account_remove_split (Account *acc, Split *s)
 Remove the given split from an account.
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 * xaccAccountGetOnlineID (const Account *account)
 Get the account's online_id (see xaccAccountSetOnlineID).
Account * xaccAccountGetAssociatedAccount (const Account *acc, const char *tag)
 Get the account's associated account e.g.
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.
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.
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.
void dxaccAccountSetPriceSrc (Account *account, const char *src)
 Set a string that identifies the Finance::Quote backend that should be used to retrieve online prices.
const char * dxaccAccountGetPriceSrc (const Account *account)
 Get a string that identifies the Finance::Quote backend that should be used to retrieve online prices.

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.
int xaccAccountGetCommoditySCU (const Account *account)
 Return the SCU for the account.
int xaccAccountGetCommoditySCUi (const Account *account)
 Return the 'internal' SCU setting.
void xaccAccountSetCommoditySCU (Account *account, int frac)
 Set the SCU for the account.
void xaccAccountSetNonStdSCU (Account *account, gboolean flag)
 Set the flag indicating that this account uses a non-standard SCU.
gboolean xaccAccountGetNonStdSCU (const Account *account)
 Return boolean, indicating whether this account uses a non-standard SCU.

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.
gnc_numeric xaccAccountGetReconciledBalanceAsOfDate (Account *account, time64 date)
 Get the reconciled balance of the account at the end of the day 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, 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.
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.
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)
gboolean xaccAccountHasStockSplit (const Account *acc)
 Returns true if the account has a stock split, otherwise false.

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.
void gnc_account_remove_child (Account *parent, Account *child)
 This function will remove the specified child account from the specified parent account.
Account * gnc_account_get_parent (const Account *account)
 This routine returns a pointer to the parent of the specified account.
Account * gnc_account_get_root (Account *account)
 This routine returns the root account of the account tree that the specified account belongs to.
gboolean gnc_account_is_root (const Account *account)
 This routine indicates whether the specified account is the root node of an account tree.
GList * gnc_account_get_children (const Account *account)
 This routine returns a GList of all children accounts of the specified account.
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().
gint gnc_account_n_children (const Account *account)
 Return the number of children of the specified account.
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.
Account * gnc_account_nth_child (const Account *parent, gint num)
 Return the n'th child account of the specified parent account.
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.
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.
gint gnc_account_n_descendants (const Account *account)
 Return the number of descendants of the specified account.
gint gnc_account_get_current_depth (const Account *account)
 Return the number of levels of this account below the root account.
gint gnc_account_get_tree_depth (const Account *account)
 Return the number of levels of descendants accounts below the specified account.

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.
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.
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.

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.
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.

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

◆ GNC_ACCOUNT

#define GNC_ACCOUNT ( o)
Value:
(G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_ACCOUNT, Account))
STRUCTS.

Definition at line 73 of file Account.h.

73#define GNC_ACCOUNT(o) \
74 (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_ACCOUNT, Account))

◆ GNC_ACCOUNT_CLASS

#define GNC_ACCOUNT_CLASS ( k)
Value:
(G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_ACCOUNT, AccountClass))

Definition at line 75 of file Account.h.

75#define GNC_ACCOUNT_CLASS(k) \
76 (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_ACCOUNT, AccountClass))

◆ GNC_ACCOUNT_GET_CLASS

#define GNC_ACCOUNT_GET_CLASS ( o)
Value:
(G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_ACCOUNT, AccountClass))

Definition at line 81 of file Account.h.

81#define GNC_ACCOUNT_GET_CLASS(o) \
82 (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_ACCOUNT, AccountClass))

◆ GNC_IS_ACCOUNT

#define GNC_IS_ACCOUNT ( o)
Value:
(G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_ACCOUNT))

Definition at line 77 of file Account.h.

77#define GNC_IS_ACCOUNT(o) \
78 (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_ACCOUNT))

◆ GNC_IS_ACCOUNT_CLASS

#define GNC_IS_ACCOUNT_CLASS ( k)
Value:
(G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_ACCOUNT))

Definition at line 79 of file Account.h.

79#define GNC_IS_ACCOUNT_CLASS(k) \
80 (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_ACCOUNT))

◆ GNC_TYPE_ACCOUNT

#define GNC_TYPE_ACCOUNT   (gnc_account_get_type ())

Definition at line 72 of file Account.h.

◆ xaccAccountGetGUID

#define xaccAccountGetGUID ( X)
Value:
qof_entity_get_guid(QOF_INSTANCE(X))
const GncGUID * qof_entity_get_guid(gconstpointer ent)
Deprecated

Definition at line 252 of file Account.h.

◆ xaccAccountLookupDirect

#define xaccAccountLookupDirect ( g,
b )
Value:
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id,...
Definition Account.cpp:2039

Definition at line 259 of file Account.h.

◆ xaccAccountReturnGUID

#define xaccAccountReturnGUID ( X)
Value:
(X ? *(qof_entity_get_guid(QOF_INSTANCE(X))) : *(guid_null()))
const GncGUID * guid_null(void)
Returns a GncGUID which is guaranteed to never reference any entity.
Definition guid.cpp:165

Definition at line 253 of file Account.h.

Typedef Documentation

◆ AccountCb

typedef void(* AccountCb) (Account *a, gpointer data)

Definition at line 63 of file Account.h.

◆ AccountCb2

typedef gpointer(* AccountCb2) (Account *a, gpointer data)

Definition at line 64 of file Account.h.

◆ AccountVec

using AccountVec = std::vector<Account*>

Definition at line 45 of file Account.hpp.

◆ SplitsVec

using SplitsVec = std::vector<Split*>

Definition at line 44 of file Account.hpp.

◆ xaccGetBalanceAsOfDateFn

typedef gnc_numeric(* xaccGetBalanceAsOfDateFn) (Account *account, time64 date)

Definition at line 60 of file Account.h.

◆ xaccGetBalanceFn

typedef gnc_numeric(* xaccGetBalanceFn) (const Account *account)

Definition at line 54 of file Account.h.

◆ xaccGetBalanceInCurrencyFn

typedef gnc_numeric(* xaccGetBalanceInCurrencyFn) (const Account *account, const gnc_commodity *report_commodity, gboolean include_children)

Definition at line 56 of file Account.h.

Enumeration Type Documentation

◆ GNCAccountType

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

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

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

Not a type.

ACCT_TYPE_NONE 

Not a type.

ACCT_TYPE_BANK 

The bank account type denotes a savings or checking account held at a bank.

Often interest bearing.

ACCT_TYPE_CASH 

The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.

ACCT_TYPE_CREDIT 

The Credit card account is used to denote credit (e.g.

amex) and debit (e.g. visa, mastercard) card accounts

ACCT_TYPE_ASSET 

asset (and liability) accounts indicate generic, generalized accounts that are none of the above.

ACCT_TYPE_LIABILITY 

liability (and asset) accounts indicate generic, generalized accounts that are none of the above.

ACCT_TYPE_STOCK 

Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.

ACCT_TYPE_MUTUAL 

Mutual Fund accounts will typically be shown in registers which show three columns: price, number of shares, and value.

ACCT_TYPE_CURRENCY 

The currency account type indicates that the account is a currency trading account.

In many ways, a currency trading account is like a stock * trading account. It is shown in the register with three columns: price, number of shares, and value. Note: Since version 1.7.0, this account is * no longer needed to exchange currencies between accounts, so this type is DEPRECATED.

ACCT_TYPE_INCOME 

Income accounts are used to denote income.

ACCT_TYPE_EXPENSE 

Expense accounts are used to denote expenses.

ACCT_TYPE_EQUITY 

Equity account is used to balance the balance sheet.

ACCT_TYPE_RECEIVABLE 

A/R account type.

ACCT_TYPE_PAYABLE 

A/P account type.

ACCT_TYPE_ROOT 

The hidden root account of an account tree.

ACCT_TYPE_TRADING 

Account used to record multiple commodity transactions.

This is not the same as ACCT_TYPE_CURRENCY above. Multiple commodity transactions have splits in these accounts to make the transaction balance in each commodity as well as in total value.

NUM_ACCOUNT_TYPES 

stop here; the following types just aren't ready for prime time

ACCT_TYPE_CHECKING 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_SAVINGS 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_MONEYMRKT 

bank account type – don't use this for now, see NUM_ACCOUNT_TYPES

ACCT_TYPE_CREDITLINE 

line of credit – don't use this for now, see NUM_ACCOUNT_TYPES

Definition at line 101 of file Account.h.

103{
104 ACCT_TYPE_INVALID = -1,
105 ACCT_TYPE_NONE = -1,
106
107 ACCT_TYPE_BANK = 0,
110 ACCT_TYPE_CASH = 1,
113 ACCT_TYPE_CREDIT = 3,
116 ACCT_TYPE_ASSET = 2,
122 ACCT_TYPE_STOCK = 5,
125 ACCT_TYPE_MUTUAL = 6,
140 ACCT_TYPE_INCOME = 8,
142
145
146 ACCT_TYPE_EQUITY = 10,
148
150
151 ACCT_TYPE_PAYABLE = 12,
152
153 ACCT_TYPE_ROOT = 13,
154
155 ACCT_TYPE_TRADING = 14,
160
161 NUM_ACCOUNT_TYPES = 15,
163
164 /* bank account types */
165 ACCT_TYPE_CHECKING = 15,
167 ACCT_TYPE_SAVINGS = 16,
173 ACCT_TYPE_LAST
174#ifdef __cplusplus
175};
176#else
GNCAccountType
The account types are used to determine how the transaction data in the account is displayed.
Definition Account.h:103
@ ACCT_TYPE_INCOME
Income accounts are used to denote income.
Definition Account.h:140
@ ACCT_TYPE_MUTUAL
Mutual Fund accounts will typically be shown in registers which show three columns: price,...
Definition Account.h:125
@ ACCT_TYPE_ROOT
The hidden root account of an account tree.
Definition Account.h:153
@ ACCT_TYPE_CREDITLINE
line of credit – don't use this for now, see NUM_ACCOUNT_TYPES
Definition Account.h:171
@ ACCT_TYPE_TRADING
Account used to record multiple commodity transactions.
Definition Account.h:155
@ ACCT_TYPE_EXPENSE
Expense accounts are used to denote expenses.
Definition Account.h:143
@ ACCT_TYPE_BANK
The bank account type denotes a savings or checking account held at a bank.
Definition Account.h:107
@ ACCT_TYPE_PAYABLE
A/P account type.
Definition Account.h:151
@ ACCT_TYPE_ASSET
asset (and liability) accounts indicate generic, generalized accounts that are none of the above.
Definition Account.h:116
@ ACCT_TYPE_CURRENCY
The currency account type indicates that the account is a currency trading account.
Definition Account.h:129
@ ACCT_TYPE_MONEYMRKT
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition Account.h:169
@ ACCT_TYPE_RECEIVABLE
A/R account type.
Definition Account.h:149
@ ACCT_TYPE_CASH
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition Account.h:110
@ ACCT_TYPE_LIABILITY
liability (and asset) accounts indicate generic, generalized accounts that are none of the above.
Definition Account.h:119
@ ACCT_TYPE_CHECKING
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition Account.h:165
@ ACCT_TYPE_EQUITY
Equity account is used to balance the balance sheet.
Definition Account.h:146
@ ACCT_TYPE_CREDIT
The Credit card account is used to denote credit (e.g.
Definition Account.h:113
@ NUM_ACCOUNT_TYPES
stop here; the following types just aren't ready for prime time
Definition Account.h:161
@ ACCT_TYPE_STOCK
Stock accounts will typically be shown in registers which show three columns: price,...
Definition Account.h:122
@ ACCT_TYPE_SAVINGS
bank account type – don't use this for now, see NUM_ACCOUNT_TYPES
Definition Account.h:167
@ ACCT_TYPE_INVALID
Not a type.
Definition Account.h:104
@ ACCT_TYPE_NONE
Not a type.
Definition Account.h:105

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

4829{
4830 if (!acc) return nullptr;
4831
4832 if (!xaccAccountIsPriced(acc)) return nullptr;
4833
4834 return get_kvp_string_path (acc, {"old-price-source"});
4835}
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false.
Definition Account.cpp:4532

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

4817{
4818 if (!acc) return;
4819
4820 if (xaccAccountIsPriced(acc))
4821 set_kvp_string_path (acc, {"old-price-source"}, src);
4822}

◆ gnc_account_and_descendants_empty()

gboolean gnc_account_and_descendants_empty ( Account * acc)

Definition at line 3946 of file Account.cpp.

3947{
3948 g_return_val_if_fail (GNC_IS_ACCOUNT (acc), FALSE);
3949 auto priv = GET_PRIVATE (acc);
3950 if (!priv->splits.empty()) return FALSE;
3951 return std::all_of (priv->children.begin(), priv->children.end(),
3952 gnc_account_and_descendants_empty);
3953}

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

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

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

2965{
2966 g_return_val_if_fail(GNC_IS_ACCOUNT(parent), -1);
2967 g_return_val_if_fail(GNC_IS_ACCOUNT(child), -1);
2968 auto& children = GET_PRIVATE(parent)->children;
2969 auto find_it = std::find (children.begin(), children.end(), child);
2970 return find_it == children.end() ? -1 : std::distance (children.begin(), find_it);
2971}

◆ gnc_account_create_root()

Account * gnc_account_create_root ( QofBook * book)

Create a new root level account.

Definition at line 1273 of file Account.cpp.

1274{
1275 Account *root;
1276 AccountPrivate *rpriv;
1277
1278 root = xaccMallocAccount(book);
1279 rpriv = GET_PRIVATE(root);
1281 rpriv->type = ACCT_TYPE_ROOT;
1282 rpriv->accountName = qof_string_cache_replace(rpriv->accountName, "Root Account");
1283 mark_account (root);
1285 gnc_book_set_root_account(book, root);
1286 return root;
1287}
Account * xaccMallocAccount(QofBook *book)
Constructor.
Definition Account.cpp:1259
const char * qof_string_cache_replace(char const *dst, char const *src)
Same as CACHE_REPLACE below, but safe to call from C++.

◆ gnc_account_find_split()

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

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

Maybe return the split.

Parameters
accThe account to which the split should be added.
predicateA split->bool predicate.
reverseTo scan in reverse order
Returns
Split* or nullptr if not found

Definition at line 1156 of file Account.cpp.

1158{
1159 if (!GNC_IS_ACCOUNT (acc))
1160 return nullptr;
1161
1162 const auto& splits{GET_PRIVATE(acc)->splits};
1163 if (reverse)
1164 {
1165 auto latest = std::find_if(splits.rbegin(), splits.rend(), predicate);
1166 return (latest == splits.rend()) ? nullptr : *latest;
1167 }
1168 else
1169 {
1170 auto earliest = std::find_if(splits.begin(), splits.end(), predicate);
1171 return (earliest == splits.end()) ? nullptr : *earliest;
1172 }
1173}

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

3209{
3210 g_return_if_fail(GNC_IS_ACCOUNT(acc));
3211 g_return_if_fail(thunk);
3212 std::for_each (GET_PRIVATE(acc)->children.begin(), GET_PRIVATE(acc)->children.end(),
3213 [user_data, thunk](auto a){ thunk (a, user_data); });
3214}

◆ gnc_account_foreach_descendant() [1/2]

void gnc_account_foreach_descendant ( const Account * acc,
std::function< void(Account *)> func )

Definition at line 2785 of file Account.cpp.

2786{
2787 g_return_if_fail (GNC_IS_ACCOUNT(acc));
2788
2789 // children must be a vector copy instead of reference because
2790 // some callers e.g. xaccAccountTreeScrubLots will modify the
2791 // children
2792 auto children = GET_PRIVATE(acc)->children;
2793 for (auto child : children)
2794 {
2795 account_cb (child);
2796 gnc_account_foreach_descendant (child, account_cb);
2797 }
2798}

◆ gnc_account_foreach_descendant() [2/2]

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

3220{
3221 gnc_account_foreach_descendant (acc, [&](auto acc){ thunk (acc, user_data); });
3222}

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

3228{
3229 gpointer result {nullptr};
3230
3231 g_return_val_if_fail (GNC_IS_ACCOUNT(acc), nullptr);
3232 g_return_val_if_fail (thunk, nullptr);
3233
3234 for (auto child : GET_PRIVATE(acc)->children)
3235 {
3236 result = thunk (child, user_data);
3237 if (result) break;
3238
3239 result = gnc_account_foreach_descendant_until (child, thunk, user_data);
3240 if (result) break;
3241 }
3242
3243 return result;
3244}
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 'func' on each...
Definition Account.cpp:3225

◆ gnc_account_foreach_split()

void gnc_account_foreach_split ( const Account * acc,
std::function< void(Split *)> func )

Definition at line 1142 of file Account.cpp.

1143{
1144 gnc_account_foreach_split_between_dates (acc, {}, {}, false, func);
1145}

◆ gnc_account_foreach_split_between_dates()

template<typename Fn>
void gnc_account_foreach_split_between_dates ( const Account * account,
std::optional< time64 > start_date,
std::optional< time64 > end_date,
bool include_descendants,
Fn && fn )

Definition at line 69 of file Account.hpp.

73{
74 g_return_if_fail (GNC_IS_ACCOUNT (account));
75 g_return_if_fail (!start_date || !end_date || *start_date <= *end_date);
76
77 auto scan_account = [&](const Account* acc)
78 {
79 const auto& splits = xaccAccountGetSplits (acc);
80 std::for_each (splits_start (splits, start_date), splits_end (splits, end_date),
81 fn);
82 };
83
84 scan_account (account);
85 if (include_descendants)
86 gnc_account_foreach_descendant (account, scan_account);
87}

◆ gnc_account_foreach_split_until_date()

void gnc_account_foreach_split_until_date ( const Account * acc,
time64 end_date,
std::function< void(Split *)> f )

Definition at line 1148 of file Account.cpp.

1150{
1151 gnc_account_foreach_split_between_dates (acc, {}, end_date, false, f);
1152}

◆ gnc_account_get_all_parents()

std::vector< const Account * > gnc_account_get_all_parents ( const Account * account)

Definition at line 3277 of file Account.cpp.

3278{
3279 std::vector<const Account*> rv;
3280 for (auto a = account; !gnc_account_is_root (a); a = gnc_account_get_parent (a))
3281 rv.push_back (a);
3282 return rv;
3283}
gboolean gnc_account_is_root(const Account *account)
This routine indicates whether the specified account is the root node of an account tree.
Definition Account.cpp:2934
Account * gnc_account_get_parent(const Account *acc)
This routine returns a pointer to the parent of the specified account.
Definition Account.cpp:2916

◆ gnc_account_get_book()

QofBook * gnc_account_get_book ( const Account * account)

Definition at line 1179 of file Account.cpp.

1180{
1181 if (!account) return nullptr;
1182 return qof_instance_get_book(QOF_INSTANCE(account));
1183}

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

2942{
2943 g_return_val_if_fail(GNC_IS_ACCOUNT(account), nullptr);
2944 auto& children = GET_PRIVATE(account)->children;
2945 return std::accumulate (children.rbegin(), children.rend(), static_cast<GList*>(nullptr),
2946 g_list_prepend);
2947}

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

2951{
2952 g_return_val_if_fail(GNC_IS_ACCOUNT(account), nullptr);
2953 return g_list_sort(gnc_account_get_children (account), (GCompareFunc)xaccAccountOrder);
2954}
GList * gnc_account_get_children(const Account *account)
This routine returns a GList of all children accounts of the specified account.
Definition Account.cpp:2941
int xaccAccountOrder(const Account *aa, const Account *ab)
The xaccAccountOrder() subroutine defines a sorting order on accounts.
Definition Account.cpp:2367

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

3397{
3398 g_return_val_if_fail (GNC_IS_ACCOUNT (account), nullptr);
3399
3400 for (auto acc = account; acc; acc = gnc_account_get_parent (acc))
3401 if (auto comm = xaccAccountGetCommodity (acc); gnc_commodity_is_currency (comm))
3402 return comm;
3403
3404 return nullptr; // no suitable commodity found.
3405}
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account's commodity.
Definition Account.cpp:3389
gboolean gnc_commodity_is_currency(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency or a legacy currency.

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

2992{
2993 AccountPrivate *priv;
2994 int depth = 0;
2995
2996 g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2997
2998 priv = GET_PRIVATE(account);
2999 while (priv->parent && (priv->type != ACCT_TYPE_ROOT))
3000 {
3001 account = priv->parent;
3002 priv = GET_PRIVATE(account);
3003 depth++;
3004 }
3005
3006 return depth;
3007}

◆ gnc_account_get_defer_bal_computation()

gboolean gnc_account_get_defer_bal_computation ( Account * acc)

Get the account's flag for deferred balance computation.

Definition at line 1913 of file Account.cpp.

1914{
1915 AccountPrivate *priv;
1916 if (!acc)
1917 return false;
1918 priv = GET_PRIVATE (acc);
1919 return priv->defer_bal_computation;
1920}

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

3026{
3027 GList* list = nullptr;
3028 gnc_account_foreach_descendant (account, [&list](auto a){ list = g_list_prepend (list, a); });
3029 return g_list_reverse (list);
3030}

◆ gnc_account_get_descendants_sorted()

GList * gnc_account_get_descendants_sorted ( const Account * account)

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

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

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

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

Definition at line 3033 of file Account.cpp.

3034{
3035 GList* list = nullptr;
3036 account_foreach_descendant_sorted (account, [&list](auto a){ list = g_list_prepend (list, a); });
3037 return g_list_reverse (list);
3038}

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

3287{
3288 /* So much for hardening the API. Too many callers to this function don't
3289 * bother to check if they have a non-nullptr pointer before calling. */
3290 if (nullptr == account)
3291 return g_strdup("");
3292
3293 /* errors */
3294 g_return_val_if_fail(GNC_IS_ACCOUNT(account), g_strdup(""));
3295
3296 auto path{gnc_account_get_all_parents (account)};
3297 auto seps_size{path.empty() ? 0 : strlen (account_separator) * (path.size() - 1)};
3298 auto alloc_size{std::accumulate (path.begin(), path.end(), seps_size,
3299 [](auto sum, auto acc)
3300 { return sum + strlen (xaccAccountGetName (acc)); })};
3301 auto rv = g_new (char, alloc_size + 1);
3302 auto p = rv;
3303
3304 std::for_each (path.rbegin(), path.rend(),
3305 [&p, rv](auto a)
3306 {
3307 if (p != rv)
3308 p = stpcpy (p, account_separator);
3309 p = stpcpy (p, xaccAccountGetName (a));
3310 });
3311 *p = '\0';
3312
3313 return rv;
3314}

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

2917{
2918 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
2919 return GET_PRIVATE(acc)->parent;
2920}

◆ gnc_account_get_policy()

GNCPolicy * gnc_account_get_policy ( Account * account)

Get the account's lot order policy.

Definition at line 2089 of file Account.cpp.

2090{
2091 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
2092
2093 return GET_PRIVATE(acc)->policy;
2094}

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

2924{
2925 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
2926
2927 while (auto parent = gnc_account_get_parent (acc))
2928 acc = parent;
2929
2930 return acc;
2931}

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

3011{
3012 AccountPrivate *priv;
3013 g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
3014
3015 priv = GET_PRIVATE(account);
3016 if (!priv->children.size())
3017 return 1;
3018
3019 return 1 + std::accumulate (priv->children.begin(), priv->children.end(),
3020 0, [](auto a, auto b)
3021 { return std::max (a, gnc_account_get_tree_depth (b)); });
3022}

◆ gnc_account_get_type()

GType gnc_account_get_type ( void )

Returns the GType type system description of the Account class.

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

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

28{
29 return gnc_mockaccount_get_type();
30}

◆ gnc_account_insert_split()

gboolean gnc_account_insert_split ( Account * acc,
Split * s )

Insert the given split from an account.

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

Definition at line 1932 of file Account.cpp.

1933{
1934 AccountPrivate *priv;
1935
1936 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1937 g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1938
1939 priv = GET_PRIVATE(acc);
1940 if (!g_hash_table_add (priv->splits_hash, s))
1941 return false;
1942
1943 priv->splits.push_back (s);
1944
1945 if (qof_instance_get_editlevel(acc) == 0)
1946 std::sort (priv->splits.begin(), priv->splits.end(), split_cmp_less);
1947 else
1948 priv->sort_dirty = true;
1949
1950 //FIXME: find better event
1951 qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, nullptr);
1952 /* Also send an event based on the account */
1953 qof_event_gen(&acc->inst, GNC_EVENT_ITEM_ADDED, s);
1954
1955 priv->balance_dirty = TRUE;
1956// DRH: Should the below be added? It is present in the delete path.
1957// xaccAccountRecomputeBalance(acc);
1958 return TRUE;
1959}
#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 2934 of file Account.cpp.

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

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

4913{
4914
4915 /* errors */
4916 g_return_if_fail(GNC_IS_ACCOUNT(to_parent));
4917 g_return_if_fail(GNC_IS_ACCOUNT(from_parent));
4918
4919 /* optimizations */
4920 auto from_priv = GET_PRIVATE(from_parent);
4921 if (from_priv->children.empty())
4922 return;
4923
4924 ENTER (" ");
4925 auto children = from_priv->children;
4926 for (auto child : children)
4927 gnc_account_append_child(to_parent, child);
4928 LEAVE (" ");
4929}
void gnc_account_append_child(Account *new_parent, Account *child)
This function will remove from the child account any pre-existing parent relationship,...
Definition Account.cpp:2817
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition qoflog.h:282
#define ENTER(format, args...)
Print a function entry debugging message.
Definition qoflog.h:272

◆ gnc_account_list_name_violations()

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

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

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

Parameters
bookPointer to the book with accounts to verify
separatorThe separator character to verify against
Returns
A GList of invalid account names. Should be freed with g_list_free_full (value, g_free) when no longer needed.

Definition at line 274 of file Account.cpp.

275{
276 g_return_val_if_fail (separator != nullptr, nullptr);
277 if (!book) return nullptr;
278 ViolationData cb = { nullptr, separator };
279 gnc_account_foreach_descendant (gnc_book_get_root_account (book),
280 (AccountCb)check_acct_name, &cb);
281 return cb.list;
282}

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

4935{
4936 g_return_if_fail(GNC_IS_ACCOUNT(parent));
4937
4938 auto ppriv = GET_PRIVATE(parent);
4939 for (auto it_a = ppriv->children.begin(); it_a != ppriv->children.end(); it_a++)
4940 {
4941 auto acc_a = *it_a;
4942 auto priv_a = GET_PRIVATE(acc_a);
4943 for (auto it_b = std::next(it_a); it_b != ppriv->children.end(); it_b++)
4944 {
4945 auto acc_b = *it_b;
4946 auto priv_b = GET_PRIVATE(acc_b);
4947 if (0 != null_strcmp(priv_a->accountName, priv_b->accountName))
4948 continue;
4949 if (0 != null_strcmp(priv_a->accountCode, priv_b->accountCode))
4950 continue;
4951 if (0 != null_strcmp(priv_a->description, priv_b->description))
4952 continue;
4953 if (0 != null_strcmp(xaccAccountGetColor(acc_a),
4954 xaccAccountGetColor(acc_b)))
4955 continue;
4956 if (!gnc_commodity_equiv(priv_a->commodity, priv_b->commodity))
4957 continue;
4958 if (0 != null_strcmp(xaccAccountGetNotes(acc_a),
4959 xaccAccountGetNotes(acc_b)))
4960 continue;
4961 if (priv_a->type != priv_b->type)
4962 continue;
4963
4964 /* consolidate children */
4965 if (!priv_b->children.empty())
4966 {
4967 auto work = priv_b->children;
4968 for (auto w : work)
4969 gnc_account_append_child (acc_a, w);
4970
4971 qof_event_gen (&acc_a->inst, QOF_EVENT_MODIFY, nullptr);
4972 qof_event_gen (&acc_b->inst, QOF_EVENT_MODIFY, nullptr);
4973 }
4974
4975 /* recurse to do the children's children */
4977
4978 /* consolidate transactions */
4979 while (!priv_b->splits.empty())
4980 xaccSplitSetAccount (priv_b->splits.front(), acc_a);
4981
4982 /* move back one before removal. next iteration around the loop
4983 * will get the node after node_b */
4984 it_b--;
4985
4986 /* The destroy function will remove from list -- node_a is ok,
4987 * it's before node_b */
4988 xaccAccountBeginEdit (acc_b);
4989 xaccAccountDestroy (acc_b);
4990 }
4991 }
4992}
const char * xaccAccountGetColor(const Account *acc)
Get the account's color.
Definition Account.cpp:3331
void xaccAccountDestroy(Account *acc)
The xaccAccountDestroy() routine can be used to get rid of an account.
Definition Account.cpp:1579
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:4934
const char * xaccAccountGetNotes(const Account *acc)
Get the account's notes.
Definition Account.cpp:3355
gboolean gnc_commodity_equiv(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equivalent.
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

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

2958{
2959 g_return_val_if_fail(GNC_IS_ACCOUNT(account), 0);
2960 return GET_PRIVATE(account)->children.size();
2961}

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

2984{
2985 int count {0};
2986 gnc_account_foreach_descendant (account, [&count](auto acc){ count++; });
2987 return count;
2988}

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

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

◆ gnc_account_nth_child()

Account * gnc_account_nth_child ( const Account * parent,
gint num )

Return the n'th child account of the specified parent account.

If the parent account is not specified or the child index number is invalid, this function returns NULL.

Parameters
parentThe parent account to check.
numThe index number of the child account that should be returned.
Returns
A pointer to the specified child account, or NULL

Definition at line 2974 of file Account.cpp.

2975{
2976 g_return_val_if_fail(GNC_IS_ACCOUNT(parent), nullptr);
2977 if ((size_t)num >= GET_PRIVATE(parent)->children.size())
2978 return nullptr;
2979 return static_cast<Account*>(GET_PRIVATE(parent)->children.at (num));
2980}

◆ gnc_account_remove_child()

void gnc_account_remove_child ( Account * parent,
Account * child )

This function will remove the specified child account from the specified parent account.

It will NOT free the associated memory or otherwise alter the account: the account can now be reparented to a new location. Note, however, that it will mark the old parents as having been modified.

Parameters
parentThe parent account from which the child should be removed.
childThe child account to remove.

Definition at line 2879 of file Account.cpp.

2880{
2881 AccountPrivate *ppriv, *cpriv;
2882 GncEventData ed;
2883
2884 if (!child) return;
2885
2886 /* Note this routine might be called on accounts which
2887 * are not yet parented. */
2888 if (!parent) return;
2889
2890 ppriv = GET_PRIVATE(parent);
2891 cpriv = GET_PRIVATE(child);
2892
2893 if (cpriv->parent != parent)
2894 {
2895 PERR ("account not a child of parent");
2896 return;
2897 }
2898
2899 /* Gather event data */
2900 ed.node = parent;
2901 ed.idx = gnc_account_child_index (parent, child);
2902
2903 ppriv->children.erase (std::remove (ppriv->children.begin(), ppriv->children.end(), child),
2904 ppriv->children.end());
2905
2906 /* Now send the event. */
2907 qof_event_gen(&child->inst, QOF_EVENT_REMOVE, &ed);
2908
2909 /* clear the account's parent pointer after REMOVE event generation. */
2910 cpriv->parent = nullptr;
2911
2912 qof_event_gen (&parent->inst, QOF_EVENT_MODIFY, nullptr);
2913}
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.
Definition Account.cpp:2964
#define PERR(format, args...)
Log a serious error.
Definition qoflog.h:244

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

1963{
1964 AccountPrivate *priv;
1965
1966 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
1967 g_return_val_if_fail(GNC_IS_SPLIT(s), FALSE);
1968
1969 priv = GET_PRIVATE(acc);
1970
1971 if (!g_hash_table_remove (priv->splits_hash, s))
1972 return false;
1973
1974 // shortcut pruning the last element. this is the most common
1975 // remove_split operation during UI or book shutdown.
1976 if (s == priv->splits.back())
1977 priv->splits.pop_back();
1978 else
1979 priv->splits.erase (std::remove (priv->splits.begin(), priv->splits.end(), s),
1980 priv->splits.end());
1981
1982 //FIXME: find better event type
1983 qof_event_gen(&acc->inst, QOF_EVENT_MODIFY, nullptr);
1984 // And send the account-based event, too
1985 qof_event_gen(&acc->inst, GNC_EVENT_ITEM_REMOVED, s);
1986
1987 priv->balance_dirty = TRUE;
1989 return TRUE;
1990}
void xaccAccountRecomputeBalance(Account *acc)
The following recompute the partial balances (stored with the transaction) and the total balance,...
Definition Account.cpp:2264

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

1888{
1889 AccountPrivate *priv;
1890
1891 g_return_if_fail(GNC_IS_ACCOUNT(acc));
1892
1894 return;
1895
1896 priv = GET_PRIVATE(acc);
1897 priv->balance_dirty = TRUE;
1898}
gboolean qof_instance_get_destroying(gconstpointer ptr)
Retrieve the flag that indicates whether or not this object is about to be destroyed.

◆ gnc_account_set_defer_bal_computation()

void gnc_account_set_defer_bal_computation ( Account * acc,
gboolean defer )

Set the defer balance flag.

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

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

Definition at line 1900 of file Account.cpp.

1901{
1902 AccountPrivate *priv;
1903
1904 g_return_if_fail (GNC_IS_ACCOUNT (acc));
1905
1907 return;
1908
1909 priv = GET_PRIVATE (acc);
1910 priv->defer_bal_computation = defer;
1911}

◆ gnc_account_set_policy()

void gnc_account_set_policy ( Account * account,
GNCPolicy * policy )

Set the account's lot order policy.

Definition at line 2097 of file Account.cpp.

2098{
2099 AccountPrivate *priv;
2100
2101 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2102
2103 priv = GET_PRIVATE(acc);
2104 priv->policy = policy ? policy : xaccGetFIFOPolicy();
2105}
GNCPolicy * xaccGetFIFOPolicy(void)
First-in, First-out Policy This policy will create FIFO Lots.
Definition policy.cpp:155

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

1874{
1875 AccountPrivate *priv;
1876
1877 g_return_if_fail(GNC_IS_ACCOUNT(acc));
1878
1880 return;
1881
1882 priv = GET_PRIVATE(acc);
1883 priv->sort_dirty = TRUE;
1884}

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

3411{
3412 AccountPrivate *priv;
3413
3414 g_return_if_fail(GNC_IS_ACCOUNT(acc));
3415
3416 priv = GET_PRIVATE(acc);
3417 priv->starting_balance = start_baln;
3418 priv->balance_dirty = TRUE;
3419}

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

3424{
3425 AccountPrivate *priv;
3426
3427 g_return_if_fail(GNC_IS_ACCOUNT(acc));
3428
3429 priv = GET_PRIVATE(acc);
3430 priv->starting_cleared_balance = start_baln;
3431 priv->balance_dirty = TRUE;
3432}

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

3437{
3438 AccountPrivate *priv;
3439
3440 g_return_if_fail(GNC_IS_ACCOUNT(acc));
3441
3442 priv = GET_PRIVATE(acc);
3443 priv->starting_reconciled_balance = start_baln;
3444 priv->balance_dirty = TRUE;
3445}

◆ gnc_book_get_root_account()

Account * gnc_book_get_root_account ( QofBook * book)

Definition at line 1226 of file Account.cpp.

1227{
1228 QofCollection *col;
1229 Account *root;
1230
1231 if (!book) return nullptr;
1232 col = qof_book_get_collection (book, GNC_ID_ROOT_ACCOUNT);
1233 root = gnc_coll_get_root_account (col);
1234 if (root == nullptr && !qof_book_shutting_down(book))
1235 root = gnc_account_create_root(book);
1236 return root;
1237}
Account * gnc_account_create_root(QofBook *book)
Create a new root level account.
Definition Account.cpp:1273
gboolean qof_book_shutting_down(const QofBook *book)
Is the book shutting down?
Definition qofbook.cpp:447

◆ gnc_book_set_root_account()

void gnc_book_set_root_account ( QofBook * book,
Account * root )

Definition at line 1240 of file Account.cpp.

1241{
1242 QofCollection *col;
1243 if (!book) return;
1244
1245 if (root && gnc_account_get_book(root) != book)
1246 {
1247 PERR ("cannot mix and match books freely!");
1248 return;
1249 }
1250
1251 col = qof_book_get_collection (book, GNC_ID_ROOT_ACCOUNT);
1252 gnc_coll_set_root_account (col, root);
1253}

◆ gnc_get_account_separator()

gunichar gnc_get_account_separator ( void )

Definition at line 212 of file Account.cpp.

213{
214 return account_uc_separator;
215}

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

207{
208 return account_separator;
209}

◆ gnc_set_account_separator()

void gnc_set_account_separator ( const gchar * separator)

Definition at line 218 of file Account.cpp.

219{
220 gunichar uc;
221 gint count;
222
223 uc = g_utf8_get_char_validated(separator, -1);
224 if ((uc == (gunichar) - 2) || (uc == (gunichar) - 1) || g_unichar_isalnum(uc))
225 {
226 account_uc_separator = ':';
227 strcpy(account_separator, ":");
228 return;
229 }
230
231 account_uc_separator = uc;
232 count = g_unichar_to_utf8(uc, account_separator);
233 account_separator[count] = '\0';
234}

◆ xaccAccountBeginEdit()

void xaccAccountBeginEdit ( Account * account)

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

Definition at line 1464 of file Account.cpp.

1465{
1466 g_return_if_fail(acc);
1467 qof_begin_edit(&acc->inst);
1468}
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 1505 of file Account.cpp.

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

◆ xaccAccountConvertBalanceToCurrency()

gnc_numeric xaccAccountConvertBalanceToCurrency ( const Account * account,
gnc_numeric balance,
const gnc_commodity * balance_currency,
const gnc_commodity * new_currency )

Definition at line 3554 of file Account.cpp.

3558{
3559 QofBook *book;
3560 GNCPriceDB *pdb;
3561
3562 if (gnc_numeric_zero_p (balance) ||
3563 gnc_commodity_equiv (balance_currency, new_currency))
3564 return balance;
3565
3566 book = gnc_account_get_book (acc);
3567 pdb = gnc_pricedb_get_db (book);
3568
3570 pdb, balance, balance_currency, new_currency);
3571
3572 return balance;
3573}
gboolean gnc_numeric_zero_p(gnc_numeric a)
Returns 1 if the given gnc_numeric is 0 (zero), else returns 0.
gnc_numeric gnc_pricedb_convert_balance_latest_price(GNCPriceDB *pdb, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency)
Convert a balance from one currency to another using the most recent price between the two.
GNCPriceDB * gnc_pricedb_get_db(QofBook *book)
Return the pricedb associated with the book.

◆ xaccAccountConvertBalanceToCurrencyAsOfDate()

gnc_numeric xaccAccountConvertBalanceToCurrencyAsOfDate ( const Account * account,
gnc_numeric balance,
const gnc_commodity * balance_currency,
const gnc_commodity * new_currency,
time64 date )

Definition at line 3580 of file Account.cpp.

3585{
3586 QofBook *book;
3587 GNCPriceDB *pdb;
3588
3589 if (gnc_numeric_zero_p (balance) ||
3590 gnc_commodity_equiv (balance_currency, new_currency))
3591 return balance;
3592
3593 book = gnc_account_get_book (acc);
3594 pdb = gnc_pricedb_get_db (book);
3595
3597 pdb, balance, balance_currency, new_currency, date);
3598
3599 return balance;
3600}
gnc_numeric gnc_pricedb_convert_balance_nearest_before_price_t64(GNCPriceDB *pdb, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency, time64 t)
Convert a balance from one currency to another using the price nearest to before the given time.

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

1580{
1581 g_return_if_fail(GNC_IS_ACCOUNT(acc));
1582
1583 qof_instance_set_destroying(acc, TRUE);
1584
1586}

◆ xaccAccountDestroyAllTransactions()

void xaccAccountDestroyAllTransactions ( Account * acc)

Destroy all of the transactions that parent splits in an account.

Definition at line 1589 of file Account.cpp.

1590{
1591 auto priv = GET_PRIVATE(acc);
1592 std::vector<Transaction*> transactions;
1593 transactions.reserve(priv->splits.size());
1594 std::transform(priv->splits.begin(), priv->splits.end(),
1595 back_inserter(transactions),
1596 [](auto split) { return split->parent; });
1597 std::stable_sort(transactions.begin(), transactions.end());
1598 transactions.erase(std::unique(transactions.begin(), transactions.end()),
1599 transactions.end());
1601 std::for_each(transactions.rbegin(), transactions.rend(),
1602 [](auto trans) { xaccTransDestroy (trans); });
1604}
void qof_event_resume(void)
Resume engine event generation.
Definition qofevent.cpp:156
void qof_event_suspend(void)
Suspend all engine events.
Definition qofevent.cpp:145

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

1656{
1657 AccountPrivate *priv_aa, *priv_ab;
1658
1659 if (!aa && !ab) return TRUE;
1660
1661 g_return_val_if_fail(GNC_IS_ACCOUNT(aa), FALSE);
1662 g_return_val_if_fail(GNC_IS_ACCOUNT(ab), FALSE);
1663
1664 priv_aa = GET_PRIVATE(aa);
1665 priv_ab = GET_PRIVATE(ab);
1666 if (priv_aa->type != priv_ab->type)
1667 {
1668 PWARN ("types differ: %d vs %d", priv_aa->type, priv_ab->type);
1669 return FALSE;
1670 }
1671
1672 if (g_strcmp0(priv_aa->accountName, priv_ab->accountName) != 0)
1673 {
1674 PWARN ("names differ: %s vs %s", priv_aa->accountName, priv_ab->accountName);
1675 return FALSE;
1676 }
1677
1678 if (g_strcmp0(priv_aa->accountCode, priv_ab->accountCode) != 0)
1679 {
1680 PWARN ("codes differ: %s vs %s", priv_aa->accountCode, priv_ab->accountCode);
1681 return FALSE;
1682 }
1683
1684 if (g_strcmp0(priv_aa->description, priv_ab->description) != 0)
1685 {
1686 PWARN ("descriptions differ: %s vs %s", priv_aa->description, priv_ab->description);
1687 return FALSE;
1688 }
1689
1690 if (!gnc_commodity_equal(priv_aa->commodity, priv_ab->commodity))
1691 {
1692 PWARN ("commodities differ");
1693 return FALSE;
1694 }
1695
1696 if (check_guids)
1697 {
1698 if (qof_instance_guid_compare(aa, ab) != 0)
1699 {
1700 PWARN ("GUIDs differ");
1701 return FALSE;
1702 }
1703 }
1704
1705 if (qof_instance_compare_kvp (QOF_INSTANCE (aa), QOF_INSTANCE (ab)) != 0)
1706 {
1707 char *frame_a;
1708 char *frame_b;
1709
1710 frame_a = qof_instance_kvp_as_string (QOF_INSTANCE (aa));
1711 frame_b = qof_instance_kvp_as_string (QOF_INSTANCE (ab));
1712
1713 PWARN ("kvp frames differ:\n%s\n\nvs\n\n%s", frame_a, frame_b);
1714
1715 g_free (frame_a);
1716 g_free (frame_b);
1717
1718 return FALSE;
1719 }
1720
1721 if (!gnc_numeric_equal(priv_aa->starting_balance, priv_ab->starting_balance))
1722 {
1723 char *str_a;
1724 char *str_b;
1725
1726 str_a = gnc_numeric_to_string(priv_aa->starting_balance);
1727 str_b = gnc_numeric_to_string(priv_ab->starting_balance);
1728
1729 PWARN ("starting balances differ: %s vs %s", str_a, str_b);
1730
1731 g_free (str_a);
1732 g_free (str_b);
1733
1734 return FALSE;
1735 }
1736
1737 if (!gnc_numeric_equal(priv_aa->starting_noclosing_balance,
1738 priv_ab->starting_noclosing_balance))
1739 {
1740 char *str_a;
1741 char *str_b;
1742
1743 str_a = gnc_numeric_to_string(priv_aa->starting_noclosing_balance);
1744 str_b = gnc_numeric_to_string(priv_ab->starting_noclosing_balance);
1745
1746 PWARN ("starting noclosing balances differ: %s vs %s", str_a, str_b);
1747
1748 g_free (str_a);
1749 g_free (str_b);
1750
1751 return FALSE;
1752 }
1753 if (!gnc_numeric_equal(priv_aa->starting_cleared_balance,
1754 priv_ab->starting_cleared_balance))
1755 {
1756 char *str_a;
1757 char *str_b;
1758
1759 str_a = gnc_numeric_to_string(priv_aa->starting_cleared_balance);
1760 str_b = gnc_numeric_to_string(priv_ab->starting_cleared_balance);
1761
1762 PWARN ("starting cleared balances differ: %s vs %s", str_a, str_b);
1763
1764 g_free (str_a);
1765 g_free (str_b);
1766
1767 return FALSE;
1768 }
1769
1770 if (!gnc_numeric_equal(priv_aa->starting_reconciled_balance,
1771 priv_ab->starting_reconciled_balance))
1772 {
1773 char *str_a;
1774 char *str_b;
1775
1776 str_a = gnc_numeric_to_string(priv_aa->starting_reconciled_balance);
1777 str_b = gnc_numeric_to_string(priv_ab->starting_reconciled_balance);
1778
1779 PWARN ("starting reconciled balances differ: %s vs %s", str_a, str_b);
1780
1781 g_free (str_a);
1782 g_free (str_b);
1783
1784 return FALSE;
1785 }
1786
1787 if (!gnc_numeric_equal(priv_aa->balance, priv_ab->balance))
1788 {
1789 char *str_a;
1790 char *str_b;
1791
1792 str_a = gnc_numeric_to_string(priv_aa->balance);
1793 str_b = gnc_numeric_to_string(priv_ab->balance);
1794
1795 PWARN ("balances differ: %s vs %s", str_a, str_b);
1796
1797 g_free (str_a);
1798 g_free (str_b);
1799
1800 return FALSE;
1801 }
1802
1803 if (!gnc_numeric_equal(priv_aa->noclosing_balance, priv_ab->noclosing_balance))
1804 {
1805 char *str_a;
1806 char *str_b;
1807
1808 str_a = gnc_numeric_to_string(priv_aa->noclosing_balance);
1809 str_b = gnc_numeric_to_string(priv_ab->noclosing_balance);
1810
1811 PWARN ("noclosing balances differ: %s vs %s", str_a, str_b);
1812
1813 g_free (str_a);
1814 g_free (str_b);
1815
1816 return FALSE;
1817 }
1818 if (!gnc_numeric_equal(priv_aa->cleared_balance, priv_ab->cleared_balance))
1819 {
1820 char *str_a;
1821 char *str_b;
1822
1823 str_a = gnc_numeric_to_string(priv_aa->cleared_balance);
1824 str_b = gnc_numeric_to_string(priv_ab->cleared_balance);
1825
1826 PWARN ("cleared balances differ: %s vs %s", str_a, str_b);
1827
1828 g_free (str_a);
1829 g_free (str_b);
1830
1831 return FALSE;
1832 }
1833
1834 if (!gnc_numeric_equal(priv_aa->reconciled_balance, priv_ab->reconciled_balance))
1835 {
1836 char *str_a;
1837 char *str_b;
1838
1839 str_a = gnc_numeric_to_string(priv_aa->reconciled_balance);
1840 str_b = gnc_numeric_to_string(priv_ab->reconciled_balance);
1841
1842 PWARN ("reconciled balances differ: %s vs %s", str_a, str_b);
1843
1844 g_free (str_a);
1845 g_free (str_b);
1846
1847 return FALSE;
1848 }
1849
1850 /* no parent; always compare downwards. */
1851
1852 if (!std::equal (priv_aa->splits.begin(), priv_aa->splits.end(),
1853 priv_ab->splits.begin(), priv_ab->splits.end(),
1854 [check_guids](auto sa, auto sb)
1855 { return xaccSplitEqual(sa, sb, check_guids, true, false); }))
1856 {
1857 PWARN ("splits differ");
1858 return false;
1859 }
1860
1861 if (!xaccAcctChildrenEqual(priv_aa->children, priv_ab->children, check_guids))
1862 {
1863 PWARN ("children differ");
1864 return FALSE;
1865 }
1866
1867 return(TRUE);
1868}
gboolean gnc_commodity_equal(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equal.
gint qof_instance_guid_compare(gconstpointer ptr1, gconstpointer ptr2)
Compare the GncGUID values of two instances.
gchar * gnc_numeric_to_string(gnc_numeric n)
Convert to string.
gboolean gnc_numeric_equal(gnc_numeric a, gnc_numeric b)
Equivalence predicate: Returns TRUE (1) if a and b represent the same number.

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

4799{
4800 Path path {KEY_LOT_MGMT, "gains-acct", gnc_commodity_get_unique_name (curr)};
4801 auto gains_account = get_kvp_account_path (acc, path);
4802
4803 if (gains_account == nullptr) /* No gains account for this currency */
4804 {
4805 gains_account = GetOrMakeOrphanAccount (gnc_account_get_root (acc), curr);
4806 set_kvp_account_path (acc, path, gains_account);
4807 }
4808
4809 return gains_account;
4810}
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:2923
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the 'unique' name for the specified commodity.

◆ xaccAccountGetAssociatedAccount()

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

Get the account's associated account e.g.

stock account -> dividend account

Definition at line 3368 of file Account.cpp.

3369{
3370 g_return_val_if_fail (tag && *tag, nullptr);
3371
3372 return get_kvp_account_path (acc, {"associated-account", tag});
3373}

◆ xaccAccountGetBalance()

gnc_numeric xaccAccountGetBalance ( const Account * account)

Get the current balance of the account, which may include future splits.

Definition at line 3448 of file Account.cpp.

3449{
3450 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), gnc_numeric_zero());
3451 return GET_PRIVATE(acc)->balance;
3452}

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

3515{
3516 return GetBalanceAsOfDate (acc, date, xaccSplitGetBalance);
3517}
gnc_numeric xaccSplitGetBalance(const Split *s)
Returns the running balance up to and including the indicated split.
Definition Split.cpp:1327

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

3835{
3836 return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive (
3837 acc, date, xaccAccountGetBalanceAsOfDate, report_commodity,
3838 include_children);
3839}
gnc_numeric xaccAccountGetBalanceAsOfDate(Account *acc, time64 date)
Get the balance of the account at the end of the day before the date specified.
Definition Account.cpp:3514

◆ xaccAccountGetBalanceChangeForPeriod()

gnc_numeric xaccAccountGetBalanceChangeForPeriod ( Account * acc,
time64 date1,
time64 date2,
gboolean recurse )

Definition at line 3852 of file Account.cpp.

3854{
3855 gnc_numeric b1, b2;
3856
3857 b1 = xaccAccountGetBalanceAsOfDateInCurrency(acc, t1, nullptr, recurse);
3858 b2 = xaccAccountGetBalanceAsOfDateInCurrency(acc, t2, nullptr, recurse);
3860}
gnc_numeric xaccAccountGetBalanceAsOfDateInCurrency(Account *acc, 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 Account.cpp:3832
gnc_numeric gnc_numeric_sub(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Return a-b.
#define GNC_DENOM_AUTO
Values that can be passed as the 'denom' argument.
@ GNC_HOW_DENOM_FIXED
All arguments are required to have the same denominator, that denominator is to be used in the output...

◆ xaccAccountGetBalanceInCurrency()

gnc_numeric xaccAccountGetBalanceInCurrency ( const Account * account,
const gnc_commodity * report_commodity,
gboolean include_children )

Definition at line 3777 of file Account.cpp.

3780{
3781 gnc_numeric rc;
3782 rc = xaccAccountGetXxxBalanceInCurrencyRecursive (
3783 acc, xaccAccountGetBalance, report_commodity, include_children);
3784 PINFO(" baln=%" G_GINT64_FORMAT "/%" G_GINT64_FORMAT, rc.num, rc.denom);
3785 return rc;
3786}
gnc_numeric xaccAccountGetBalance(const Account *acc)
Get the current balance of the account, which may include future splits.
Definition Account.cpp:3448

◆ xaccAccountGetClearedBalance()

gnc_numeric xaccAccountGetClearedBalance ( const Account * account)

Get the current balance of the account, only including cleared transactions.

Definition at line 3455 of file Account.cpp.

3456{
3457 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), gnc_numeric_zero());
3458 return GET_PRIVATE(acc)->cleared_balance;
3459}

◆ xaccAccountGetClearedBalanceInCurrency()

gnc_numeric xaccAccountGetClearedBalanceInCurrency ( const Account * account,
const gnc_commodity * report_commodity,
gboolean include_children )

Definition at line 3790 of file Account.cpp.

3793{
3794 return xaccAccountGetXxxBalanceInCurrencyRecursive (
3795 acc, xaccAccountGetClearedBalance, report_commodity,
3796 include_children);
3797}
gnc_numeric xaccAccountGetClearedBalance(const Account *acc)
Get the current balance of the account, only including cleared transactions.
Definition Account.cpp:3455

◆ xaccAccountGetCode()

const char * xaccAccountGetCode ( const Account * account)

Get the account's accounting code.

Definition at line 3317 of file Account.cpp.

3318{
3319 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
3320 return GET_PRIVATE(acc)->accountCode;
3321}

◆ xaccAccountGetColor()

const char * xaccAccountGetColor ( const Account * account)

Get the account's color.

Definition at line 3331 of file Account.cpp.

3332{
3333 return get_kvp_string_path (acc, {"color"});
3334}

◆ xaccAccountGetCommodity()

gnc_commodity * xaccAccountGetCommodity ( const Account * account)

Get the account's commodity.

Definition at line 3389 of file Account.cpp.

3390{
3391 if (!GNC_IS_ACCOUNT(acc))
3392 return nullptr;
3393 return GET_PRIVATE(acc)->commodity;
3394}

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

2727{
2728 AccountPrivate *priv;
2729
2730 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2731
2732 priv = GET_PRIVATE(acc);
2733 if (priv->non_standard_scu || !priv->commodity)
2734 return priv->commodity_scu;
2735 return gnc_commodity_get_fraction(priv->commodity);
2736}
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 2719 of file Account.cpp.

2720{
2721 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2722 return GET_PRIVATE(acc)->commodity_scu;
2723}

◆ xaccAccountGetDescription()

const char * xaccAccountGetDescription ( const Account * account)

Get the account's description.

Definition at line 3324 of file Account.cpp.

3325{
3326 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
3327 return GET_PRIVATE(acc)->description;
3328}

◆ xaccAccountGetFilter()

const char * xaccAccountGetFilter ( const Account * account)

Get the account's filter.

Definition at line 3337 of file Account.cpp.

3338{
3339 return get_kvp_string_path (acc, {"filter"});
3340}

◆ xaccAccountGetLastNum()

const char * xaccAccountGetLastNum ( const Account * account)

Get the last num field of an Account.

Definition at line 4664 of file Account.cpp.

4665{
4666 return get_kvp_string_path (acc, {"last-num"});
4667}

◆ xaccAccountGetName()

const char * xaccAccountGetName ( const Account * account)

Get the account's name.

Definition at line 3270 of file Account.cpp.

3271{
3272 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
3273 return GET_PRIVATE(acc)->accountName;
3274}

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

3845{
3846 return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive
3847 (acc, date, xaccAccountGetNoclosingBalanceAsOfDate,
3848 report_commodity, include_children);
3849}

◆ xaccAccountGetNoclosingBalanceChangeForPeriod()

gnc_numeric xaccAccountGetNoclosingBalanceChangeForPeriod ( Account * acc,
time64 date1,
time64 date2,
gboolean recurse )

Definition at line 3863 of file Account.cpp.

3865{
3866 gnc_numeric b1, b2;
3867
3868 b1 = xaccAccountGetNoclosingBalanceAsOfDateInCurrency(acc, t1, nullptr, recurse);
3869 b2 = xaccAccountGetNoclosingBalanceAsOfDateInCurrency(acc, t2, nullptr, recurse);
3871}
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,...
Definition Account.cpp:3842

◆ xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod()

gnc_numeric xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod ( Account * acc,
time64 date1,
time64 date2,
gboolean recurse )

Definition at line 3897 of file Account.cpp.

3899{
3900
3901
3902 gnc_numeric b1, b2;
3903 b1 = GetBalanceAsOfDate(acc, t1, xaccSplitGetNoclosingBalance);
3904 b2 = GetBalanceAsOfDate(acc, t2, xaccSplitGetNoclosingBalance);
3905 gnc_numeric balanceChange = gnc_numeric_sub(b2, b1, GNC_DENOM_AUTO, GNC_HOW_DENOM_FIXED);
3906
3907 gnc_commodity *report_commodity = xaccAccountGetCommodity(acc);
3908 CurrencyBalanceChange cbdiff = { report_commodity, balanceChange, t1, t2 };
3909
3910 if(recurse)
3911 {
3912 gnc_account_foreach_descendant (acc, xaccAccountBalanceChangeHelper, &cbdiff);
3913 balanceChange = cbdiff.balanceChange;
3914 }
3915 return balanceChange;
3916}
gnc_numeric xaccSplitGetNoclosingBalance(const Split *s)
The noclosing-balance is the currency-denominated balance of all transactions except 'closing' transa...
Definition Split.cpp:1333

◆ xaccAccountGetNonStdSCU()

gboolean xaccAccountGetNonStdSCU ( const Account * account)

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

Definition at line 2755 of file Account.cpp.

2756{
2757 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
2758 return GET_PRIVATE(acc)->non_standard_scu;
2759}

◆ xaccAccountGetNotes()

const char * xaccAccountGetNotes ( const Account * account)

Get the account's notes.

Definition at line 3355 of file Account.cpp.

3356{
3357 return get_kvp_string_path (acc, {"notes"});
3358}

◆ xaccAccountGetOnlineID()

const char * xaccAccountGetOnlineID ( const Account * account)

Get the account's online_id (see xaccAccountSetOnlineID).

The returned string is owned by the account and must NOT be freed; returns NULL if no online_id is set.

Definition at line 3361 of file Account.cpp.

3362{
3363 g_return_val_if_fail (GNC_IS_ACCOUNT(acc), nullptr);
3364 return get_kvp_string_path (acc, {KEY_ONLINE_ID});
3365}

◆ xaccAccountGetPresentBalance()

gnc_numeric xaccAccountGetPresentBalance ( const Account * account)

Definition at line 3535 of file Account.cpp.

3536{
3537 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), gnc_numeric_zero());
3538
3539 return xaccAccountGetBalanceAsOfDate (GNC_ACCOUNT (acc),
3541}
time64 gnc_time64_get_today_end(void)
The gnc_time64_get_today_end() routine returns a time64 value corresponding to the last second of tod...

◆ xaccAccountGetPresentBalanceInCurrency()

gnc_numeric xaccAccountGetPresentBalanceInCurrency ( const Account * account,
const gnc_commodity * report_commodity,
gboolean include_children )

Definition at line 3810 of file Account.cpp.

3813{
3814 return xaccAccountGetXxxBalanceAsOfDateInCurrencyRecursive (
3816 report_commodity,
3817 include_children);
3818}

◆ xaccAccountGetProjectedMinimumBalance()

gnc_numeric xaccAccountGetProjectedMinimumBalance ( const Account * account)

Definition at line 3469 of file Account.cpp.

3470{
3471 auto today{gnc_time64_get_today_end()};
3472 std::optional<gnc_numeric> minimum;
3473
3474 auto before_today_end = [&minimum, today](const Split *s) -> bool
3475 {
3476 auto bal{xaccSplitGetBalance(s)};
3477 if (!minimum || gnc_numeric_compare (bal, *minimum) < 0)
3478 minimum = bal;
3479 return (xaccTransGetDate(xaccSplitGetParent(s)) < today);
3480 };
3481 // scan to find today's split, but we're really interested in the
3482 // minimum balance
3483 [[maybe_unused]] auto todays_split = gnc_account_find_split (acc, before_today_end, true);
3484 return minimum ? *minimum : gnc_numeric_zero();
3485}
Split * gnc_account_find_split(const Account *acc, std::function< bool(const Split *)> predicate, bool reverse)
scans account split list (in forward or reverse order) until predicate split->bool returns true.
Definition Account.cpp:1156
time64 xaccTransGetDate(const Transaction *trans)
Retrieve the posted date of the transaction.
int gnc_numeric_compare(gnc_numeric a, gnc_numeric b)
Returns 1 if a>b, -1 if b>a, 0 if a == b.
Transaction * xaccSplitGetParent(const Split *split)
Returns the parent transaction of the split.

◆ xaccAccountGetProjectedMinimumBalanceInCurrency()

gnc_numeric xaccAccountGetProjectedMinimumBalanceInCurrency ( const Account * account,
const gnc_commodity * report_commodity,
gboolean include_children )

Definition at line 3821 of file Account.cpp.

3825{
3826 return xaccAccountGetXxxBalanceInCurrencyRecursive (
3827 acc, xaccAccountGetProjectedMinimumBalance, report_commodity,
3828 include_children);
3829}

◆ xaccAccountGetReconcileChildrenStatus()

gboolean xaccAccountGetReconcileChildrenStatus ( const Account * account)

DOCUMENT ME!

Definition at line 4876 of file Account.cpp.

4877{
4878 /* access the account's kvp-data for status and return that, if no value
4879 * is found then we can assume not to include the children, that being
4880 * the default behaviour
4881 */
4882 return get_kvp_boolean_path (acc, {KEY_RECONCILE_INFO, KEY_INCLUDE_CHILDREN});
4883}

◆ xaccAccountGetReconciledBalance()

gnc_numeric xaccAccountGetReconciledBalance ( const Account * account)

Get the current balance of the account, only including reconciled transactions.

Definition at line 3462 of file Account.cpp.

3463{
3464 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), gnc_numeric_zero());
3465 return GET_PRIVATE(acc)->reconciled_balance;
3466}

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

3527{
3528 return GetBalanceAsOfDate (acc, date, xaccSplitGetReconciledBalance);
3529}
gnc_numeric xaccSplitGetReconciledBalance(const Split *s)
Returns the reconciled-balance of this split.
Definition Split.cpp:1345

◆ xaccAccountGetReconciledBalanceInCurrency()

gnc_numeric xaccAccountGetReconciledBalanceInCurrency ( const Account * account,
const gnc_commodity * report_commodity,
gboolean include_children )

Definition at line 3800 of file Account.cpp.

3803{
3804 return xaccAccountGetXxxBalanceInCurrencyRecursive (
3805 acc, xaccAccountGetReconciledBalance, report_commodity,
3806 include_children);
3807}
gnc_numeric xaccAccountGetReconciledBalance(const Account *acc)
Get the current balance of the account, only including reconciled transactions.
Definition Account.cpp:3462

◆ xaccAccountGetSortOrder()

const char * xaccAccountGetSortOrder ( const Account * account)

Get the account's Sort Order.

Definition at line 3343 of file Account.cpp.

3344{
3345 return get_kvp_string_path (acc, {"sort-order"});
3346}

◆ xaccAccountGetSortReversed()

gboolean xaccAccountGetSortReversed ( const Account * account)

Get the account's Sort Order direction.

Definition at line 3349 of file Account.cpp.

3350{
3351 return get_kvp_boolean_path (acc, {"sort-reversed"});
3352}

◆ xaccAccountGetSplits()

const SplitsVec & xaccAccountGetSplits ( const Account * account)

Definition at line 3922 of file Account.cpp.

3923{
3924 static const SplitsVec empty;
3925 g_return_val_if_fail (GNC_IS_ACCOUNT(account), empty);
3926 return GET_PRIVATE(account)->splits;
3927}

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

3249{
3250 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), ACCT_TYPE_NONE);
3251 return GET_PRIVATE(acc)->type;
3252}

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

4206{
4207 const Account *parent;
4208
4209 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4210 g_return_val_if_fail(GNC_IS_ACCOUNT(ancestor), FALSE);
4211
4212 parent = acc;
4213 while (parent && parent != ancestor)
4214 parent = GET_PRIVATE(parent)->parent;
4215
4216 return (parent == ancestor);
4217}

◆ xaccAccountHasStockSplit()

gboolean xaccAccountHasStockSplit ( const Account * acc)

Returns true if the account has a stock split, otherwise false.

Definition at line 3488 of file Account.cpp.

3489{
3490 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), false);
3491 return GET_PRIVATE(acc)->has_stock_split;
3492}

◆ xaccAccountIsPriced()

gboolean xaccAccountIsPriced ( const Account * acc)

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

Definition at line 4532 of file Account.cpp.

4533{
4534 AccountPrivate *priv;
4535
4536 g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4537
4538 priv = GET_PRIVATE(acc);
4539 return (priv->type == ACCT_TYPE_STOCK || priv->type == ACCT_TYPE_MUTUAL ||
4540 priv->type == ACCT_TYPE_CURRENCY);
4541}

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

2040{
2041 QofCollection *col;
2042 if (!guid || !book) return nullptr;
2043 col = qof_book_get_collection (book, GNC_ID_ACCOUNT);
2044 return (Account *) qof_collection_lookup_entity (col, guid);
2045}
QofInstance * qof_collection_lookup_entity(const QofCollection *col, const GncGUID *guid)
Find the entity going only from its guid.
Definition qofid.cpp:209

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

2368{
2369 AccountPrivate *priv_aa, *priv_ab;
2370 const char *da, *db;
2371 int ta, tb, result;
2372
2373 if (aa == ab) return 0;
2374 if (!ab) return -1;
2375 if (!aa) return +1;
2376
2377 priv_aa = GET_PRIVATE(aa);
2378 priv_ab = GET_PRIVATE(ab);
2379
2380 /* sort on accountCode strings */
2381 da = priv_aa->accountCode;
2382 db = priv_ab->accountCode;
2383
2384 /* Otherwise do a string sort */
2385 result = g_strcmp0 (da, db);
2386 if (result)
2387 return result;
2388
2389 /* otherwise, sort on account type */
2390 ta = priv_aa->type;
2391 tb = priv_ab->type;
2392 ta = revorder[ta];
2393 tb = revorder[tb];
2394 if (ta < tb) return -1;
2395 if (ta > tb) return +1;
2396
2397 /* otherwise, sort on accountName strings */
2398 da = priv_aa->accountName;
2399 db = priv_ab->accountName;
2400 result = safe_utf8_collate(da, db);
2401 if (result)
2402 return result;
2403
2404 /* guarantee a stable sort */
2405 return qof_instance_guid_compare(aa, ab);
2406}
int safe_utf8_collate(const char *da, const char *db)
Collate two UTF-8 strings.

◆ xaccAccountRecomputeBalance()

void xaccAccountRecomputeBalance ( Account * acc)

The following recompute the partial balances (stored with the transaction) and the total balance, for this account.

Definition at line 2264 of file Account.cpp.

2265{
2266 if (nullptr == acc) return;
2267
2268 auto priv = GET_PRIVATE(acc);
2269 if (qof_instance_get_editlevel(acc) > 0) return;
2270 if (!priv->balance_dirty || priv->defer_bal_computation) return;
2271 if (qof_instance_get_destroying(acc)) return;
2273
2274 auto balance = priv->starting_balance;
2275 auto noclosing_balance = priv->starting_noclosing_balance;
2276 auto cleared_balance = priv->starting_cleared_balance;
2277 auto reconciled_balance = priv->starting_reconciled_balance;
2278 auto has_stock_split = false;
2279
2280 PINFO ("acct=%s starting baln=%" G_GINT64_FORMAT "/%" G_GINT64_FORMAT,
2281 priv->accountName, balance.num, balance.denom);
2282 for (auto split : priv->splits)
2283 {
2284 auto amt = xaccSplitGetAmount (split);
2285
2286 if (xaccSplitIsStockSplit(split))
2287 {
2288 if (gnc_numeric_zero_p(balance))
2289 continue;
2290 auto new_balance = gnc_numeric_add_fixed(balance, amt);
2291 if (gnc_numeric_zero_p(new_balance))
2292 continue;
2293 auto ratio = gnc_numeric_div(new_balance, balance, GNC_DENOM_AUTO,
2295 auto denom = xaccAccountGetCommoditySCU(acc);
2296 for (auto psplit : priv->splits)
2297 {
2298 if (psplit == split)
2299 break;
2301 gnc_numeric_mul(xaccSplitGetAdjustedAmount(psplit), ratio, denom,
2303 }
2304 balance = new_balance;
2305 has_stock_split = true;
2306 }
2307 else
2308 {
2309 split->adjusted_amount = amt;
2310 balance = gnc_numeric_add_fixed(balance, amt);
2311 }
2312
2313 if (NREC != split->reconciled)
2314 {
2315 cleared_balance = gnc_numeric_add_fixed(cleared_balance, amt);
2316 }
2317
2318 if (YREC == split->reconciled ||
2319 FREC == split->reconciled)
2320 {
2321 reconciled_balance =
2322 gnc_numeric_add_fixed(reconciled_balance, amt);
2323 }
2324
2325 if (!(xaccTransGetIsClosingTxn (split->parent)))
2326 noclosing_balance = gnc_numeric_add_fixed(noclosing_balance, amt);
2327
2328 split->balance = balance;
2329 split->noclosing_balance = noclosing_balance;
2330 split->cleared_balance = cleared_balance;
2331 split->reconciled_balance = reconciled_balance;
2332
2333 }
2334
2335 priv->balance = balance;
2336 priv->noclosing_balance = noclosing_balance;
2337 priv->cleared_balance = cleared_balance;
2338 priv->reconciled_balance = reconciled_balance;
2339 priv->balance_dirty = FALSE;
2340 priv->has_stock_split = has_stock_split;
2341}
int xaccAccountGetCommoditySCU(const Account *acc)
Return the SCU for the account.
Definition Account.cpp:2726
gboolean xaccTransGetIsClosingTxn(const Transaction *trans)
Returns whether this transaction is a "closing transaction".
gnc_numeric gnc_numeric_div(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Division.
gnc_numeric gnc_numeric_mul(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Multiply a times b, returning the product.
@ GNC_HOW_DENOM_REDUCE
Reduce the result value by common factor elimination, using the smallest possible value for the denom...
@ GNC_HOW_RND_ROUND_HALF_UP
Round to the nearest integer, rounding away from zero when there are two equidistant nearest integers...
void xaccSplitSetAdjustedAmount(Split *s, gnc_numeric amt)
Sets the stock split adjusted amount of a split.
Definition Split.cpp:1357
#define NREC
not reconciled or cleared
Definition Split.h:76
#define FREC
frozen into accounting period
Definition Split.h:75
gnc_numeric xaccSplitGetAdjustedAmount(const Split *s)
Returns the stock-split adjusted amount of the split in the account's commodity.
Definition Split.cpp:1351
#define YREC
The Split has been reconciled.
Definition Split.h:74
gboolean xaccSplitIsStockSplit(Split *s)
Returns true if the split is of type stock split.
Definition Split.cpp:2089
gnc_numeric xaccSplitGetAmount(const Split *split)
Returns the amount of the split in the account's commodity.

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

2651{
2652 g_return_if_fail (GNC_IS_ACCOUNT(acc));
2653 g_return_if_fail (tag && *tag);
2654
2655 set_kvp_account_path (acc, {"associated-account", tag}, assoc_acct);
2656}

◆ xaccAccountSetCode()

void xaccAccountSetCode ( Account * account,
const char * code )

Set the account's accounting code.

Definition at line 2459 of file Account.cpp.

2460{
2461 AccountPrivate *priv;
2462
2463 /* errors */
2464 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2465
2466 /* optimizations */
2467 priv = GET_PRIVATE(acc);
2468 if (g_strcmp0(str, priv->accountCode) == 0)
2469 return;
2470
2472 priv->accountCode = qof_string_cache_replace(priv->accountCode, str ? str : "");
2473 mark_account (acc);
2475}

◆ xaccAccountSetColor()

void xaccAccountSetColor ( Account * account,
const char * color )

Set the account's Color.

Definition at line 2594 of file Account.cpp.

2595{
2596 set_kvp_string_path (acc, {"color"}, str);
2597}

◆ xaccAccountSetCommodity()

void xaccAccountSetCommodity ( Account * account,
gnc_commodity * comm )

Set the account's commodity.

Definition at line 2659 of file Account.cpp.

2660{
2661 AccountPrivate *priv;
2662
2663 /* errors */
2664 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2665 g_return_if_fail(GNC_IS_COMMODITY(com));
2666
2667 /* optimizations */
2668 priv = GET_PRIVATE(acc);
2669 if (com == priv->commodity)
2670 return;
2671
2673 gnc_commodity_decrement_usage_count(priv->commodity);
2674 priv->commodity = com;
2676 priv->commodity_scu = gnc_commodity_get_fraction(com);
2677 priv->non_standard_scu = FALSE;
2678
2679 /* iterate over splits */
2680 for (auto s : priv->splits)
2681 {
2682 Transaction *trans = xaccSplitGetParent (s);
2683
2684 xaccTransBeginEdit (trans);
2686 xaccTransCommitEdit (trans);
2687 }
2688
2689 priv->sort_dirty = TRUE; /* Not needed. */
2690 priv->balance_dirty = TRUE;
2691 mark_account (acc);
2692
2694}
void gnc_commodity_increment_usage_count(gnc_commodity *cm)
Increment a commodity's internal counter that tracks how many accounts are using that commodity.
void gnc_commodity_decrement_usage_count(gnc_commodity *cm)
Decrement a commodity's internal counter that tracks how many accounts are using that commodity.
void xaccTransCommitEdit(Transaction *trans)
The xaccTransCommitEdit() method indicates that the changes to the transaction and its splits are com...
void xaccTransBeginEdit(Transaction *trans)
The xaccTransBeginEdit() method must be called before any changes are made to a transaction or any of...
void xaccSplitSetAmount(Split *split, gnc_numeric amt)
The xaccSplitSetAmount() method sets the amount in the account's commodity that the split should have...

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

2704{
2705 AccountPrivate *priv;
2706
2707 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2708
2709 priv = GET_PRIVATE(acc);
2711 priv->commodity_scu = scu;
2712 if (scu != gnc_commodity_get_fraction(priv->commodity))
2713 priv->non_standard_scu = TRUE;
2714 mark_account(acc);
2716}

◆ xaccAccountSetDescription()

void xaccAccountSetDescription ( Account * account,
const char * desc )

Set the account's description.

Definition at line 2478 of file Account.cpp.

2479{
2480 AccountPrivate *priv;
2481
2482 /* errors */
2483 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2484
2485 /* optimizations */
2486 priv = GET_PRIVATE(acc);
2487 if (g_strcmp0(str, priv->description) == 0)
2488 return;
2489
2491 priv->description = qof_string_cache_replace(priv->description, str ? str : "");
2492 mark_account (acc);
2494}

◆ xaccAccountSetFilter()

void xaccAccountSetFilter ( Account * account,
const char * filter )

Set the account's Filter.

Definition at line 2600 of file Account.cpp.

2601{
2602 set_kvp_string_path (acc, {"filter"}, str);
2603}

◆ xaccAccountSetLastNum()

void xaccAccountSetLastNum ( Account * account,
const char * num )

Set the last num field of an Account.

Definition at line 4673 of file Account.cpp.

4674{
4675 set_kvp_string_path (acc, {"last-num"}, num);
4676}

◆ xaccAccountSetName()

void xaccAccountSetName ( Account * account,
const char * name )

Set the account's name.

Definition at line 2439 of file Account.cpp.

2440{
2441 AccountPrivate *priv;
2442
2443 /* errors */
2444 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2445 g_return_if_fail(str);
2446
2447 /* optimizations */
2448 priv = GET_PRIVATE(acc);
2449 if (g_strcmp0(str, priv->accountName) == 0)
2450 return;
2451
2453 priv->accountName = qof_string_cache_replace(priv->accountName, str);
2454 mark_account (acc);
2456}

◆ xaccAccountSetNonStdSCU()

void xaccAccountSetNonStdSCU ( Account * account,
gboolean flag )

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

Definition at line 2739 of file Account.cpp.

2740{
2741 AccountPrivate *priv;
2742
2743 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2744
2745 priv = GET_PRIVATE(acc);
2746 if (priv->non_standard_scu == flag)
2747 return;
2749 priv->non_standard_scu = flag;
2750 mark_account (acc);
2752}

◆ xaccAccountSetNotes()

void xaccAccountSetNotes ( Account * account,
const char * notes )

Set the account's notes.

Definition at line 2636 of file Account.cpp.

2637{
2638 set_kvp_string_path (acc, {"notes"}, str);
2639}

◆ xaccAccountSetOnlineID()

void xaccAccountSetOnlineID ( Account * account,
const char * id )

Set the account's online_id, the identifier (e.g.

an OFX/HBCI BANKID+ACCTID composite) of the online account this GnuCash account is mapped to for bank imports. This is the same value (engine KVP slot "online_id") that the desktop OFX/HBCI importer uses to match a downloaded statement to its GnuCash account. Passing NULL or "" clears it. Wraps its own begin/commit edit.

Definition at line 2642 of file Account.cpp.

2643{
2644 g_return_if_fail (GNC_IS_ACCOUNT(acc));
2645 set_kvp_string_path (acc, {KEY_ONLINE_ID}, id);
2646}

◆ xaccAccountSetReconcileChildrenStatus()

void xaccAccountSetReconcileChildrenStatus ( Account * account,
gboolean status )

DOCUMENT ME!

Definition at line 4863 of file Account.cpp.

4864{
4865 /* Would have been nice to use G_TYPE_BOOLEAN, but the other
4866 * boolean kvps save the value as "true" or "false" and that would
4867 * be file-incompatible with this.
4868 */
4869 set_kvp_int64_path (acc, {KEY_RECONCILE_INFO, KEY_INCLUDE_CHILDREN}, status);
4870}

◆ xaccAccountSetSortOrder()

void xaccAccountSetSortOrder ( Account * account,
const char * sortorder )

Set the account's Sort Order.

Definition at line 2606 of file Account.cpp.

2607{
2608 set_kvp_string_path (acc, {"sort-order"}, str);
2609}

◆ xaccAccountSetSortReversed()

void xaccAccountSetSortReversed ( Account * account,
gboolean sortreversed )

Set the account's Sort Order direction.

Definition at line 2612 of file Account.cpp.

2613{
2614 set_kvp_boolean_path (acc, {"sort-reversed"}, sortreversed);
2615}

◆ xaccAccountSetType()

void xaccAccountSetType ( Account * account,
GNCAccountType tip )

Set the account's type.

Definition at line 2418 of file Account.cpp.

2419{
2420 AccountPrivate *priv;
2421
2422 /* errors */
2423 g_return_if_fail(GNC_IS_ACCOUNT(acc));
2424 g_return_if_fail(tip < NUM_ACCOUNT_TYPES);
2425
2426 /* optimizations */
2427 priv = GET_PRIVATE(acc);
2428 if (priv->type == tip)
2429 return;
2430
2432 priv->type = tip;
2433 priv->balance_dirty = TRUE; /* new type may affect balance computation */
2434 mark_account(acc);
2436}

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

1994{
1995 AccountPrivate *priv;
1996
1997 g_return_if_fail(GNC_IS_ACCOUNT(acc));
1998
1999 priv = GET_PRIVATE(acc);
2000 if (!priv->sort_dirty || (!force && qof_instance_get_editlevel(acc) > 0))
2001 return;
2002 std::sort (priv->splits.begin(), priv->splits.end(), split_cmp_less);
2003 priv->sort_dirty = FALSE;
2004 priv->balance_dirty = TRUE;
2005}

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

1291{
1292 Account *ret;
1293 AccountPrivate *from_priv, *priv;
1294
1295 g_return_val_if_fail(GNC_IS_ACCOUNT(from), nullptr);
1296 g_return_val_if_fail(QOF_IS_BOOK(book), nullptr);
1297
1298 ENTER (" ");
1299 ret = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, nullptr));
1300 g_return_val_if_fail (ret, nullptr);
1301
1302 from_priv = GET_PRIVATE(from);
1303 priv = GET_PRIVATE(ret);
1304 xaccInitAccount (ret, book);
1305
1306 /* Do not Begin/CommitEdit() here; give the caller
1307 * a chance to fix things up, and let them do it.
1308 * Also let caller issue the generate_event (EVENT_CREATE) */
1309 priv->type = from_priv->type;
1310
1311 priv->accountName = qof_string_cache_replace(priv->accountName, from_priv->accountName);
1312 priv->accountCode = qof_string_cache_replace(priv->accountCode, from_priv->accountCode);
1313 priv->description = qof_string_cache_replace(priv->description, from_priv->description);
1314
1315 qof_instance_copy_kvp (QOF_INSTANCE (ret), QOF_INSTANCE (from));
1316
1317 /* The new book should contain a commodity that matches
1318 * the one in the old book. Find it, use it. */
1319 priv->commodity = gnc_commodity_obtain_twin(from_priv->commodity, book);
1320 gnc_commodity_increment_usage_count(priv->commodity);
1321
1322 priv->commodity_scu = from_priv->commodity_scu;
1323 priv->non_standard_scu = from_priv->non_standard_scu;
1324
1325 qof_instance_set_dirty(&ret->inst);
1326 LEAVE (" ");
1327 return ret;
1328}
gnc_commodity * gnc_commodity_obtain_twin(const gnc_commodity *from, QofBook *book)
Given the commodity 'findlike', this routine will find and return the equivalent commodity (commodity...

◆ xaccMallocAccount()

Account * xaccMallocAccount ( QofBook * book)

Constructor.

Definition at line 1259 of file Account.cpp.

1260{
1261 Account *acc;
1262
1263 g_return_val_if_fail (book, nullptr);
1264
1265 acc = static_cast<Account*>(g_object_new (GNC_TYPE_ACCOUNT, nullptr));
1266 xaccInitAccount (acc, book);
1267 qof_event_gen (&acc->inst, QOF_EVENT_CREATE, nullptr);
1268
1269 return acc;
1270}