GnuCash  4.6-313-gb6cbc9786+
Modules | Files | Data Structures | Macros | Typedefs | Enumerations | Functions
GnuCash Engine: Core, Non-GUI Accounting Functions

The GnuCash Engine provides a set of objects and classes that encapsulate typical financial accounting concepts. More...

Modules

 Environment
 The API in this file is used to read the environment configuration file and set up a number of environment variables based on the values found in it.
 
 Generic Preference Utilities
 The only function in this file is meant to initialize the preferences system early in the load process.
 
 
 Cap Gains
 This file implements the various routines to automatically compute and handle Cap Gains/Losses resulting from trading activities.
 
 Commodities
 A commodity is something of value that is easily tradeable or sellable; for example, currencies, stocks, bonds, grain, copper, and oil are all commodities.
 
 Lots: Core Function for AR/AP, Inventory, Stock Lots, Cap Gains
 One often needs to know that the item 'bought' in one transaction is the same one as the item 'sold' in a different transaction.
 
 Price Database
 The PriceDB is intended to be a database of price quotes, or more specifically, a database of GNCPrices.
 
 Prices
 Each price in the database represents an "instantaneous" quote for a given commodity with respect to another commodity.
 
 Business
 The Business Engine provides a set of structures for that provide small-business accounting features.
 
 Accounting Policy (FIFO/LIFO)
 This file implements Accounting Policy.
 
 Scheduled/Periodic/Recurring Transactions
 
Scheduled Transactions provide a framework for remembering information about a transactions that are set to occur in the future, either once or periodically.
 
 Data Validation
 Data scrubbing, repairing and forward migration routines.
 
 Transaction, Split
 A good overview of transactions, splits and accounts can be found in the texinfo documentation, together with an overview of how to use this API.
 
 Transaction Logging
 The transaction logging mechanism provides a very simple, low-level logging of user input to a file.
 

Files

file  gnc-engine.h
 All type declarations for the whole Gnucash engine.
 

Data Structures

struct  GncImapInfo
 

Macros

#define ACCOUNT_MATCH_ALL_TYPE   "account-match-all"
 This is the type-override when you want to match all accounts. More...
 
#define GNC_ID_NONE   QOF_ID_NONE
 IDENTIFIERS GncGUID Identifiers can be used to reference Accounts, Transactions, Splits and other objects. More...
 
#define GNC_ID_BOOK   QOF_ID_BOOK
 
#define GNC_ID_SESSION   QOF_ID_SESSION
 
#define GNC_ID_NULL   QOF_ID_NULL
 
#define GNC_ID_ACCOUNT   "Account"
 
#define GNC_ID_COMMODITY   "Commodity"
 
#define GNC_ID_COMMODITY_NAMESPACE   "CommodityNamespace"
 
#define GNC_ID_COMMODITY_TABLE   "CommodityTable"
 
#define GNC_ID_LOT   "Lot"
 
#define GNC_ID_PERIOD   "Period"
 
#define GNC_ID_PRICE   "Price"
 
#define GNC_ID_PRICEDB   "PriceDB"
 
#define GNC_ID_SPLIT   "Split"
 
#define GNC_ID_BUDGET   "Budget"
 
#define GNC_ID_SCHEDXACTION   "SchedXaction"
 
#define GNC_ID_SXES   "SchedXactions"
 
#define GNC_ID_SXTG   "SXTGroup"
 
#define GNC_ID_SXTT   "SXTTrans"
 
#define GNC_ID_TRANS   "Trans"
 
#define GNC_INVOICE_ID   "gncInvoice"
 STRING CONSTANTS ********************************************** Used to declare constant KVP keys used in more than one class.
 
#define GNC_INVOICE_GUID   "invoice-guid"
 
#define GNC_OWNER_ID   "gncOwner"
 
#define GNC_OWNER_TYPE   "owner-type"
 
#define GNC_OWNER_GUID   "owner-guid"
 
#define GNC_SX_ID   "sched-xaction"
 

Typedefs

typedef GList AccountList
 GList of Account.
 
typedef GList LotList
 GList of GNCLots.
 
typedef GList SplitList
 GList of Split.
 
typedef GList TransList
 GList of Transaction.
 
typedef GList AccountGUIDList
 GList of GUIDs of a Account.
 
typedef GList BookGUIDList
 GList of GUIDs of a QofBook.
 
typedef void(* EngineCommitErrorCallback) (gpointer data, QofBackendError errcode)
 
typedef gint(* SplitCallback) (Split *s, gpointer data)
 
typedef gint(* TransactionCallback) (Transaction *t, void *data)
 
typedef void(* gnc_engine_init_hook_t) (int, char **)
 Function type for init hooks in the engine. More...
 

Enumerations

enum  GNCPlaceholderType { PLACEHOLDER_NONE, PLACEHOLDER_THIS, PLACEHOLDER_CHILD }
 DOCUMENT ME!
 

Functions

void gnc_engine_init (int argc, char **argv)
 PROTOTYPES. More...
 
void gnc_engine_init_static (int argc, char **argv)
 This is the statically linked-in version of gnc_engine_init. More...
 
void gnc_engine_shutdown (void)
 Called to shutdown the engine. More...
 
gboolean gnc_engine_is_initialized (void)
 check the engine is fully initialized
 
void gnc_log_default (void)
 enable default log modules
 
void gnc_engine_add_init_hook (gnc_engine_init_hook_t hook)
 Pass a function pointer to gnc_engine_add_init_hook and it will be called during the evaluation of gnc_engine_init.
 
void gnc_engine_add_commit_error_callback (EngineCommitErrorCallback cb, gpointer data)
 Set a callback function to be called in case an engine commit fails.
 
void gnc_engine_signal_commit_error (QofBackendError errcode)
 

Lookup Accounts and Subaccounts by name or code

Accountgnc_account_lookup_by_name (const Account *parent, const char *name)
 The gnc_account_lookup_by_name() subroutine fetches the account by name from the descendants of the specified account. More...
 
Accountgnc_account_lookup_by_full_name (const Account *any_account, const gchar *name)
 The gnc_account_lookup_full_name() subroutine works like gnc_account_lookup_by_name, but uses fully-qualified names using the given separator.
 
Accountgnc_account_lookup_by_code (const Account *parent, const char *code)
 The gnc_account_lookup_by_code() subroutine works like gnc_account_lookup_by_name, but uses the account code.
 
Accountgnc_account_lookup_by_opening_balance (Account *account, gnc_commodity *commodity)
 Find the opening balance account for the currency. More...
 
GList * gnc_account_lookup_by_type_and_commodity (Account *root, const char *name, GNCAccountType acctype, gnc_commodity *commodity)
 Find a direct child account matching name, GNCAccountType, and/or commodity. More...
 

GNCAccountType conversion/checking

const char * xaccAccountTypeEnumAsString (GNCAccountType type)
 Conversion routines for the account types to/from strings that are used in persistent storage, communications. More...
 
gboolean xaccAccountStringToType (const char *str, GNCAccountType *type)
 Conversion routines for the account types to/from strings that are used in persistent storage, communications. More...
 
GNCAccountType xaccAccountStringToEnum (const char *str)
 Conversion routines for the account types to/from strings that are used in persistent storage, communications. More...
 
const char * xaccAccountGetTypeStr (GNCAccountType type)
 The xaccAccountGetTypeStr() routine returns a string suitable for use in the GUI/Interface. More...
 
guint32 xaccAccountTypesCompatibleWith (GNCAccountType type)
 Return the bitmask of account types compatible with a given type. More...
 
guint32 xaccParentAccountTypesCompatibleWith (GNCAccountType type)
 Return the bitmask of parent account types compatible with a given type. More...
 
gboolean xaccAccountTypesCompatible (GNCAccountType parent_type, GNCAccountType child_type)
 Return TRUE if accounts of type parent_type can have accounts of type child_type as children. More...
 
guint32 xaccAccountTypesValid (void)
 Returns the bitmask of the account type enums that are valid. More...
 
gboolean xaccAccountIsAssetLiabType (GNCAccountType t)
 Convenience function to check if the account is a valid Asset or Liability type, but not a business account type (meaning not an Accounts Payable/Accounts Receivable). More...
 
GNCAccountType xaccAccountTypeGetFundamental (GNCAccountType t)
 Convenience function to return the fundamental type asset/liability/income/expense/equity given an account type. More...
 
gboolean xaccAccountIsAPARType (GNCAccountType t)
 Convenience function to check if the account is a valid business account type (meaning an Accounts Payable/Accounts Receivable). More...
 
gboolean xaccAccountIsEquityType (GNCAccountType t)
 Convenience function to check if the account is a valid Equity type. More...
 

Account split/transaction list management

SplitListxaccAccountGetSplitList (const Account *account)
 The xaccAccountGetSplitList() routine returns a pointer to a GList of the splits in the account. More...
 
gint64 xaccAccountCountSplits (const Account *acc, gboolean include_children)
 The xaccAccountCountSplits() routine returns the number of all the splits in the account. More...
 
void xaccAccountMoveAllSplits (Account *accfrom, Account *accto)
 The xaccAccountMoveAllSplits() routine reassigns each of the splits in accfrom to accto. More...
 
gint xaccAccountForEachTransaction (const Account *account, TransactionCallback proc, void *data)
 The xaccAccountForEachTransaction() routine will traverse all of the transactions in account and call the callback function proc on each transaction. More...
 
Transaction * xaccAccountFindTransByDesc (const Account *account, const char *description)
 Returns a pointer to the transaction, not a copy. More...
 
Split * xaccAccountFindSplitByDesc (const Account *account, const char *description)
 Returns a pointer to the split, not a copy. More...
 
#define xaccAccountInsertSplit(acc, s)   xaccSplitSetAccount((s), (acc))
 The xaccAccountInsertSplit() method will insert the indicated split into the indicated account. More...
 

Account lots

void xaccAccountInsertLot (Account *, GNCLot *)
 The xaccAccountInsertLot() method will register the indicated lot with this account. More...
 
void xaccAccountRemoveLot (Account *, GNCLot *)
 
LotListxaccAccountGetLotList (const Account *account)
 The xaccAccountGetLotList() routine returns a list of all lots in this account. More...
 
gpointer xaccAccountForEachLot (const Account *acc, gpointer(*proc)(GNCLot *lot, gpointer user_data), gpointer user_data)
 The xaccAccountForEachLot() method will apply the function 'proc' to each lot in the account. More...
 
LotListxaccAccountFindOpenLots (const Account *acc, gboolean(*match_func)(GNCLot *lot, gpointer user_data), gpointer user_data, GCompareFunc sort_func)
 Find a list of open lots that match the match_func. More...
 

Account Reconciliation information getters/setters

gboolean xaccAccountGetReconcileLastDate (const Account *account, time64 *last_date)
 DOCUMENT ME!
 
void xaccAccountSetReconcileLastDate (Account *account, time64 last_date)
 DOCUMENT ME!
 
gboolean xaccAccountGetReconcileLastInterval (const Account *account, int *months, int *days)
 DOCUMENT ME!
 
void xaccAccountSetReconcileLastInterval (Account *account, int months, int days)
 DOCUMENT ME!
 
gboolean xaccAccountGetReconcilePostponeDate (const Account *account, time64 *postpone_date)
 DOCUMENT ME!
 
void xaccAccountSetReconcilePostponeDate (Account *account, time64 postpone_date)
 DOCUMENT ME!
 
gboolean xaccAccountGetReconcilePostponeBalance (const Account *account, gnc_numeric *balance)
 DOCUMENT ME!
 
void xaccAccountSetReconcilePostponeBalance (Account *account, gnc_numeric balance)
 DOCUMENT ME!
 
void xaccAccountClearReconcilePostpone (Account *account)
 DOCUMENT ME!
 

Account Placeholder flag

gboolean xaccAccountGetPlaceholder (const Account *account)
 Get the "placeholder" flag for an account. More...
 
void xaccAccountSetPlaceholder (Account *account, gboolean val)
 Set the "placeholder" flag for an account. More...
 
gboolean xaccAccountGetIsOpeningBalance (const Account *account)
 Get the "opening-balance" flag for an account. More...
 
void xaccAccountSetIsOpeningBalance (Account *account, gboolean val)
 Set the "opening-balance" flag for an account. More...
 
GNCPlaceholderType xaccAccountGetDescendantPlaceholder (const Account *account)
 Returns PLACEHOLDER_NONE if account is NULL or neither account nor any descendant of account is a placeholder. More...
 

Account Hidden flag

gboolean xaccAccountGetHidden (const Account *acc)
 Get the "hidden" flag for an account. More...
 
void xaccAccountSetHidden (Account *acc, gboolean val)
 Set the "hidden" flag for an account. More...
 
gboolean xaccAccountIsHidden (const Account *acc)
 Should this account be "hidden". More...
 

Account Auto Interest flag

gboolean xaccAccountGetAutoInterest (const Account *acc)
 Get the "auto interest" flag for an account. More...
 
void xaccAccountSetAutoInterest (Account *acc, gboolean val)
 Set the "auto interest" flag for an account. More...
 

Account Tax related getters/setters

gboolean xaccAccountGetTaxRelated (const Account *account)
 DOCUMENT ME!
 
void xaccAccountSetTaxRelated (Account *account, gboolean tax_related)
 DOCUMENT ME!
 
const char * xaccAccountGetTaxUSCode (const Account *account)
 DOCUMENT ME!
 
void xaccAccountSetTaxUSCode (Account *account, const char *code)
 DOCUMENT ME!
 
const char * xaccAccountGetTaxUSPayerNameSource (const Account *account)
 DOCUMENT ME!
 
void xaccAccountSetTaxUSPayerNameSource (Account *account, const char *source)
 DOCUMENT ME!
 
gint64 xaccAccountGetTaxUSCopyNumber (const Account *account)
 DOCUMENT ME!
 
void xaccAccountSetTaxUSCopyNumber (Account *account, gint64 copy_number)
 DOCUMENT ME!
 

Account type debit/credit string getters

@ { *

const char * gnc_account_get_debit_string (GNCAccountType acct_type)
 Get the debit string associated with this account type.
 
const char * gnc_account_get_credit_string (GNCAccountType acct_type)
 Get the credit string associated with this account type.
 

Account marking

void xaccAccountSetMark (Account *account, short mark)
 Set a mark on the account. More...
 
void xaccClearMark (Account *account, short val)
 Get the mark set by xaccAccountSetMark short xaccAccountGetMark (const Account *account);. More...
 
void xaccClearMarkDown (Account *account, short val)
 The xaccClearMarkDown will clear the mark only in this and in sub-accounts. More...
 

Staged Traversal

The following functions provide support for "staged traversals" over all of the transactions in an account or group.

The idea is to be able to perform a sequence of traversals ("stages"), and perform an operation on each transaction exactly once for that stage.

Only transactions whose current "stage" is less than the stage of the current traversal will be affected, and they will be "brought up" to the current stage when they are processed.

For example, you could perform a stage 1 traversal of all the transactions in an account, and then perform a stage 1 traversal of the transactions in a second account. Presuming the traversal of the first account didn't abort prematurely, any transactions shared by both accounts would be ignored during the traversal of the second account since they had been processed while traversing the first account.

However, if you had traversed the second account using a stage of 2, then all the transactions in the second account would have been processed.

Traversal can be aborted by having the callback function return a non-zero value. The traversal is aborted immediately, and the non-zero value is returned. Note that an aborted traversal can be restarted; no information is lost due to an abort.

The initial impetus for this particular approach came from generalizing a mark/sweep practice that was already being used in FileIO.c.

Note that currently, there is a hard limit of 256 stages, which can be changed by enlarging "marker" in the transaction struct.

void gnc_account_tree_begin_staged_transaction_traversals (Account *acc)
 gnc_account_tree_begin_staged_transaction_traversals() resets the traversal marker inside every transactions of every account in the account tree originating with the specified node. More...
 
void xaccSplitsBeginStagedTransactionTraversals (SplitList *splits)
 xaccSplitsBeginStagedTransactionTraversals() resets the traversal marker for each transaction which is a parent of one of the splits in the list.
 
void xaccAccountBeginStagedTransactionTraversals (const Account *account)
 xaccAccountBeginStagedTransactionTraversals() resets the traversal marker for each transaction which is a parent of one of the splits in the account.
 
gboolean xaccTransactionTraverse (Transaction *trans, int stage)
 xaccTransactionTraverse() checks the stage of the given transaction. More...
 
int xaccAccountStagedTransactionTraversal (const Account *a, unsigned int stage, TransactionCallback thunk, void *data)
 xaccAccountStagedTransactionTraversal() calls thunk on each transaction in account a whose current marker is less than the given stage and updates each transaction's marker to be stage. More...
 
int gnc_account_tree_staged_transaction_traversal (const Account *account, unsigned int stage, TransactionCallback thunk, void *data)
 gnc_account_tree_staged_transaction_traversal() calls thunk on each transaction in the group whose current marker is less than the given stage and updates each transaction's marker to be stage. More...
 
int xaccAccountTreeForEachTransaction (Account *acc, TransactionCallback proc, void *data)
 Traverse all of the transactions in the given account group. More...
 
GncImportMatchMapgnc_account_imap_create_imap (Account *acc)
 Obtain an ImportMatchMap object from an Account or a Book.
 
Accountgnc_account_imap_find_account (GncImportMatchMap *imap, const char *category, const char *key)
 
void gnc_account_imap_add_account (GncImportMatchMap *imap, const char *category, const char *key, Account *acc)
 
void gnc_account_imap_delete_account (GncImportMatchMap *imap, const char *category, const char *key)
 
Accountgnc_account_imap_find_account_bayes (GncImportMatchMap *imap, GList *tokens)
 Look up an Account in the map using Baysian. More...
 
void gnc_account_imap_add_account_bayes (GncImportMatchMap *imap, GList *tokens, Account *acc)
 Updates the imap for a given account using a list of tokens.
 
GList * gnc_account_imap_get_info_bayes (Account *acc)
 Returns a GList of structure imap_info of all Bayesian mappings for required Account.
 
GList * gnc_account_imap_get_info (Account *acc, const char *category)
 Returns a GList of structure imap_info of all Non Bayesian mappings for required Account.
 
gchar * gnc_account_get_map_entry (Account *acc, const char *head, const char *category)
 Returns the text string pointed to by head and category for the Account, free the returned text.
 
void gnc_account_delete_map_entry (Account *acc, char *head, char *category, char *match_string, gboolean empty)
 Delete the entry for Account pointed to by head,category and match_string, if empty is TRUE then use delete if empty.
 
void gnc_account_delete_all_bayes_maps (Account *acc)
 Delete all bayes entries for Account.
 
void gnc_account_reset_convert_bayes_to_flat (void)
 Reset the flag that indicates the function imap_convert_bayes_to_flat has been run.
 

Deprecated Routines.

void DxaccAccountSetCurrency (Account *account, gnc_commodity *currency)
 
gnc_commodity * DxaccAccountGetCurrency (const Account *account)
 
void dxaccAccountSetQuoteTZ (Account *account, const char *tz)
 Set the timezone to be used when interpreting the results from a given Finance::Quote backend. More...
 
const char * dxaccAccountGetQuoteTZ (const Account *account)
 Get the timezone to be used when interpreting the results from a given Finance::Quote backend. More...
 

Account parameter names

#define ACCOUNT_KVP   "kvp"
 
#define ACCOUNT_NAME_   "name"
 
#define ACCOUNT_CODE_   "code"
 
#define ACCOUNT_DESCRIPTION_   "desc"
 
#define ACCOUNT_COLOR_   "color"
 
#define ACCOUNT_FILTER_   "filter"
 
#define ACCOUNT_SORT_ORDER_   "sort-order"
 
#define ACCOUNT_SORT_REVERSED_   "sort-reversed"
 
#define ACCOUNT_NOTES_   "notes"
 
#define ACCOUNT_BALANCE_   "balance"
 
#define ACCOUNT_NOCLOSING_   "noclosing"
 
#define ACCOUNT_OPENING_BALANCE_   "opening-balance"
 
#define ACCOUNT_CLEARED_   "cleared"
 
#define ACCOUNT_RECONCILED_   "reconciled"
 
#define ACCOUNT_PRESENT_   "present"
 
#define ACCOUNT_FUTURE_MINIMUM_   "future-minimum"
 
#define ACCOUNT_TAX_RELATED   "tax-related-p"
 
#define ACCOUNT_TYPE_   "account-type"
 
#define ACCOUNT_SCU   "smallest-commodity-unit"
 
#define ACCOUNT_NSCU   "non-standard-scu"
 
#define ACCOUNT_PARENT   "parent-account"
 

QofLogModule identifiers

#define GNC_MOD_ROOT   "gnc"
 
#define GNC_MOD_ENGINE   "gnc.engine"
 
#define GNC_MOD_ACCOUNT   "gnc.account"
 
#define GNC_MOD_SX   "gnc.engine.sx"
 
#define GNC_MOD_QUERY   "gnc.query"
 
#define GNC_MOD_SCRUB   "gnc.scrub"
 
#define GNC_MOD_LOT   "gnc.lots"
 
#define GNC_MOD_COMMODITY   "gnc.commodity"
 
#define GNC_MOD_BACKEND   "gnc.backend"
 
#define GNC_MOD_PRICE   "gnc.pricedb"
 
#define GNC_MOD_BUSINESS   "gnc.business"
 
#define GNC_MOD_IO   "gnc.io"
 
#define GNC_MOD_BOOK   "gnc.book-period"
 
#define GNC_MOD_GUI   "gnc.gui"
 
#define GNC_MOD_GUI_SX   "gnc.gui.sx"
 
#define GNC_MOD_GUILE   "gnc.guile"
 
#define GNC_MOD_LEDGER   "gnc.ledger"
 
#define GNC_MOD_REGISTER   "gnc.register"
 
#define GNC_MOD_HTML   "gnc.html"
 
#define GNC_MOD_PREFS   "gnc.pref"
 
#define GNC_MOD_IMPORT   "gnc.import"
 
#define GNC_MOD_ASSISTANT   "gnc.assistant"
 
#define GNC_MOD_BUDGET   "gnc.budget"
 

Detailed Description

The GnuCash Engine provides a set of objects and classes that encapsulate typical financial accounting concepts.

The GnuCash GUI is expected to manipulate these objects through the provided engine API.

Macro Definition Documentation

◆ ACCOUNT_MATCH_ALL_TYPE

#define ACCOUNT_MATCH_ALL_TYPE   "account-match-all"

This is the type-override when you want to match all accounts.

Used in the gnome-search parameter list. Be careful when you use this.

Definition at line 1629 of file Account.h.

◆ GNC_ID_NONE

#define GNC_ID_NONE   QOF_ID_NONE

IDENTIFIERS GncGUID Identifiers can be used to reference Accounts, Transactions, Splits and other objects.

These Gnucash types are referred to as Gnucash entities. GncGUID Identifiers are globally-unique and permanent, i.e., once an entity has been assigned an identifier, it retains that same identifier for its lifetime.

  • Identifiers are 'typed' with strings. The ids used in gnucash are defined below. An id with type GNC_ID_NONE does not refer to any entity, although that may change as new ids are created. An id with type GNC_ID_NULL does not refer to any entity, and will never refer to any entity. An identifier with any other type may refer to an actual entity, but that is not guaranteed. If an id does refer to an entity, the type of the entity will match the type of the identifier.

Definition at line 95 of file gnc-engine.h.

◆ xaccAccountInsertSplit

#define xaccAccountInsertSplit (   acc,
 
)    xaccSplitSetAccount((s), (acc))

The xaccAccountInsertSplit() method will insert the indicated split into the indicated account.

If the split already belongs to another account, it will be removed from that account first.

Definition at line 1038 of file Account.h.

Typedef Documentation

◆ gnc_engine_init_hook_t

typedef void(* gnc_engine_init_hook_t) (int, char **)

Function type for init hooks in the engine.

Definition at line 225 of file gnc-engine.h.

Function Documentation

◆ DxaccAccountGetCurrency()

gnc_commodity* DxaccAccountGetCurrency ( const Account account)
Deprecated:
The current API associates only one thing with an account: the 'commodity'.

Use xaccAccountGetCommodity() to fetch it.

Definition at line 3383 of file Account.cpp.

3384 {
3385  GValue v = G_VALUE_INIT;
3386  const char *s = NULL;
3387  gnc_commodity_table *table;
3388  gnc_commodity *retval = NULL;
3389 
3390  if (!acc) return NULL;
3391  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {"old-currency"});
3392  if (G_VALUE_HOLDS_STRING (&v))
3393  s = g_value_get_string (&v);
3394  if (s)
3395  {
3397  retval = gnc_commodity_table_lookup_unique (table, s);
3398  }
3399  g_value_unset (&v);
3400 
3401  return retval;
3402 }
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.

◆ dxaccAccountGetQuoteTZ()

const char* dxaccAccountGetQuoteTZ ( const Account account)

Get the timezone to be used when interpreting the results from a given Finance::Quote backend.

Unfortunately, the upstream sources don't label their output, so the user has to specify this bit. This function uses a static char*.

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

Definition at line 5025 of file Account.cpp.

5026 {
5027  static char *quote_tz = nullptr;
5028  if (!acc) return NULL;
5029  if (!xaccAccountIsPriced(acc)) return NULL;
5030  g_free (quote_tz);
5031  quote_tz = get_kvp_string_tag (acc, "old-quote-tz");
5032  return quote_tz;
5033 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4658

◆ DxaccAccountSetCurrency()

void DxaccAccountSetCurrency ( Account account,
gnc_commodity *  currency 
)
Deprecated:
The current API associates only one thing with an account: the 'commodity'.

Use xaccAccountGetCommodity() to fetch it.

These two funcs take control of their gnc_commodity args. Don't free

Definition at line 2722 of file Account.cpp.

2723 {
2724  QofBook *book;
2725  GValue v = G_VALUE_INIT;
2726  const char *s = gnc_commodity_get_unique_name (currency);
2727  gnc_commodity *commodity;
2728  gnc_commodity_table *table;
2729 
2730  if ((!acc) || (!currency)) return;
2731  g_value_init (&v, G_TYPE_STRING);
2732  g_value_set_string (&v, s);
2733  qof_instance_set_path_kvp (QOF_INSTANCE (acc), &v, {"old-currency"});
2734  mark_account (acc);
2735  xaccAccountCommitEdit(acc);
2736  g_value_unset (&v);
2737 
2739  commodity = gnc_commodity_table_lookup_unique (table, s);
2740 
2741  if (!commodity)
2742  {
2743  book = qof_instance_get_book(acc);
2745  currency);
2746  }
2747 }
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table *table, gnc_commodity *comm)
Add a new commodity to the commodity table.
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the 'unique' name for the specified commodity.
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1471

◆ dxaccAccountSetQuoteTZ()

void dxaccAccountSetQuoteTZ ( Account account,
const char *  tz 
)

Set the timezone to be used when interpreting the results from a given Finance::Quote backend.

Unfortunately, the upstream sources don't label their output, so the user has to specify this bit.

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

Definition at line 5014 of file Account.cpp.

5015 {
5016  if (!acc) return;
5017  if (!xaccAccountIsPriced(acc)) return;
5018  set_kvp_string_tag (acc, "old-quote-tz", tz);
5019 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4658

◆ gnc_account_imap_find_account_bayes()

Account* gnc_account_imap_find_account_bayes ( GncImportMatchMap imap,
GList *  tokens 
)

Look up an Account in the map using Baysian.

Look up an Account in the map using Baysian.

Definition at line 5793 of file Account.cpp.

5794 {
5795  if (!imap)
5796  return nullptr;
5797  check_import_map_data (imap->book);
5798  auto first_pass = get_first_pass_probabilities(imap, tokens);
5799  if (!first_pass.size())
5800  return nullptr;
5801  auto final_probabilities = build_probabilities(first_pass);
5802  if (!final_probabilities.size())
5803  return nullptr;
5804  auto best = highest_probability(final_probabilities);
5805  if (best.account_guid == "")
5806  return nullptr;
5807  if (best.probability < threshold)
5808  return nullptr;
5809  gnc::GUID guid;
5810  try {
5811  guid = gnc::GUID::from_string(best.account_guid);
5812  } catch (gnc::guid_syntax_exception&) {
5813  return nullptr;
5814  }
5815  auto account = xaccAccountLookup (reinterpret_cast<GncGUID*>(&guid), imap->book);
5816  return account;
5817 }
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.cpp:2031

◆ gnc_account_lookup_by_name()

Account* gnc_account_lookup_by_name ( const Account parent,
const char *  name 
)

The gnc_account_lookup_by_name() subroutine fetches the account by name from the descendants of the specified account.

The immediate children are searched first. If there is no match,, then a recursive search of all descendants is performed looking for a match.

Returns
A pointer to the account with the specified name, or NULL if the account was not found.

Definition at line 3040 of file Account.cpp.

3041 {
3042  return (Account*)gnc_account_foreach_descendant_until (parent, is_acct_name, (char*)name);
3043 }
gpointer gnc_account_foreach_descendant_until(const Account *acc, AccountCb2 thunk, gpointer user_data)
This method will traverse all children of this accounts and their descendants, calling &#39;func&#39; on each...
Definition: Account.cpp:3210

◆ gnc_account_lookup_by_opening_balance()

Account* gnc_account_lookup_by_opening_balance ( Account account,
gnc_commodity *  commodity 
)

Find the opening balance account for the currency.

Parameters
accountThe account of which the sought-for account is a descendant.
commodityThe commodity in which the account should be denominated
Returns
The descendant account of EQUITY_TYPE_OPENING_BALANCE or NULL if one doesn't exist.

Definition at line 3068 of file Account.cpp.

3069 {
3070  return (Account *)gnc_account_foreach_descendant_until (account, is_opening_balance_account, commodity);
3071 }
gpointer gnc_account_foreach_descendant_until(const Account *acc, AccountCb2 thunk, gpointer user_data)
This method will traverse all children of this accounts and their descendants, calling &#39;func&#39; on each...
Definition: Account.cpp:3210

◆ gnc_account_lookup_by_type_and_commodity()

GList* gnc_account_lookup_by_type_and_commodity ( Account root,
const char *  name,
GNCAccountType  acctype,
gnc_commodity *  commodity 
)

Find a direct child account matching name, GNCAccountType, and/or commodity.

Name and commodity may be nullptr in which case the accounts in the list may have any value for those properties. Note that commodity matching is by equivalence: If the mnemonic/symbol and namespace are the same, it matches.

Parameters
rootThe account among whose children one expects to find the account.
nameThe name of the account to look for or nullptr.
acctypeThe GNCAccountType to match.
commodityThe commodity in which the account should be denominated or nullptr.
Returns
A GList of children matching the supplied parameters.

Definition at line 3145 of file Account.cpp.

3149 {
3150  GList *retval{};
3151  auto rpriv{GET_PRIVATE(root)};
3152  for (auto node = rpriv->children; node; node = node->next)
3153  {
3154  auto account{static_cast<Account*>(node->data)};
3155  if (xaccAccountGetType (account) == acctype)
3156  {
3157  if (commodity &&
3159  commodity))
3160  continue;
3161 
3162  if (name && strcmp(name, xaccAccountGetName(account)))
3163  continue;
3164 
3165  retval = g_list_prepend(retval, account);
3166  }
3167  }
3168 
3169  if (!retval) // Recurse through the children
3170  for (auto node = rpriv->children; node; node = node->next)
3171  {
3172  auto account{static_cast<Account*>(node->data)};
3173  auto result = gnc_account_lookup_by_type_and_commodity(account,
3174  name,
3175  acctype,
3176  commodity);
3177  if (result)
3178  retval = g_list_concat(result, retval);
3179  }
3180  return retval;
3181 }
GNCAccountType xaccAccountGetType(const Account *acc)
Returns the account&#39;s account type.
Definition: Account.cpp:3236
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account&#39;s commodity.
Definition: Account.cpp:3405
const char * xaccAccountGetName(const Account *acc)
Get the account&#39;s name.
Definition: Account.cpp:3258
gboolean gnc_commodity_equiv(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equivalent.
GList * gnc_account_lookup_by_type_and_commodity(Account *root, const char *name, GNCAccountType acctype, gnc_commodity *commodity)
Find a direct child account matching name, GNCAccountType, and/or commodity.
Definition: Account.cpp:3145

◆ gnc_account_tree_begin_staged_transaction_traversals()

void gnc_account_tree_begin_staged_transaction_traversals ( Account acc)

gnc_account_tree_begin_staged_transaction_traversals() resets the traversal marker inside every transactions of every account in the account tree originating with the specified node.

This is done so that a new sequence of staged traversals can begin.

Definition at line 5297 of file Account.cpp.

5298 {
5299  GList *descendants;
5300 
5301  descendants = gnc_account_get_descendants(account);
5302  g_list_foreach(descendants, (GFunc)do_one_account, NULL);
5303  g_list_free(descendants);
5304 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:3017

◆ gnc_account_tree_staged_transaction_traversal()

int gnc_account_tree_staged_transaction_traversal ( const Account account,
unsigned int  stage,
TransactionCallback  thunk,
void *  data 
)

gnc_account_tree_staged_transaction_traversal() calls thunk on each transaction in the group whose current marker is less than the given stage and updates each transaction's marker to be stage.

The traversal will stop if thunk returns a non-zero value. gnc_account_tree_staged_transaction_traversal() function will return zero or the non-zero value returned by thunk. This API does not handle handle recursive traversals.

Warning
For performance reasons, the transaction callback thunk must never destroy any of the transaction's splits, nor assign any of them to a different account. To do so risks a crash.

Definition at line 5347 of file Account.cpp.

5351 {
5352  const AccountPrivate *priv;
5353  GList *acc_p, *split_p;
5354  Transaction *trans;
5355  Split *s;
5356  int retval;
5357 
5358  if (!acc) return 0;
5359 
5360  /* depth first traversal */
5361  priv = GET_PRIVATE(acc);
5362  for (acc_p = priv->children; acc_p; acc_p = g_list_next(acc_p))
5363  {
5364  retval = gnc_account_tree_staged_transaction_traversal(static_cast <Account*> (acc_p->data),
5365  stage, thunk, cb_data);
5366  if (retval) return retval;
5367  }
5368 
5369  /* Now this account */
5370  for (split_p = priv->splits; split_p; split_p = g_list_next(split_p))
5371  {
5372  s = static_cast <Split*> (split_p->data);
5373  trans = s->parent;
5374  if (trans && (trans->marker < stage))
5375  {
5376  trans->marker = stage;
5377  if (thunk)
5378  {
5379  retval = thunk(trans, cb_data);
5380  if (retval) return retval;
5381  }
5382  }
5383  }
5384 
5385  return 0;
5386 }
int gnc_account_tree_staged_transaction_traversal(const Account *acc, unsigned int stage, TransactionCallback thunk, void *cb_data)
gnc_account_tree_staged_transaction_traversal() calls thunk on each transaction in the group whose cu...
Definition: Account.cpp:5347

◆ gnc_engine_init()

void gnc_engine_init ( int  argc,
char **  argv 
)

PROTOTYPES.

gnc_engine_init should be called before gnc engine functions can be used.

Definition at line 116 of file gnc-engine.c.

117 {
118  if (1 == engine_is_initialized) return;
119 
120  gnc_engine_init_part1();
121  gnc_engine_init_part2();
122  gnc_engine_init_part3(argc, argv);
123 }

◆ gnc_engine_init_static()

void gnc_engine_init_static ( int  argc,
char **  argv 
)

This is the statically linked-in version of gnc_engine_init.

It is identical to that function except that it doesn't load any backend library.

Definition at line 126 of file gnc-engine.c.

127 {
128  if (1 == engine_is_initialized) return;
129 
130  gnc_engine_init_part1();
131  gnc_engine_init_part3(argc, argv);
132 }

◆ gnc_engine_shutdown()

void gnc_engine_shutdown ( void  )

Called to shutdown the engine.

Definition at line 141 of file gnc-engine.c.

142 {
144  qof_close();
145  engine_is_initialized = 0;
146 }
void qof_log_shutdown(void)
Be nice, close the logfile if possible.
Definition: qoflog.cpp:268
void qof_close(void)
Safely close down the Query Object Framework.
Definition: qofutil.cpp:269

◆ xaccAccountCountSplits()

gint64 xaccAccountCountSplits ( const Account acc,
gboolean  include_children 
)

The xaccAccountCountSplits() routine returns the number of all the splits in the account.

xaccAccountCountSplits is O(N). if testing for emptiness, use xaccAccountGetSplitList != NULL.

Parameters
accthe account for which to count the splits
include_childrenalso count splits in descendants (TRUE) or for this account only (FALSE).

Definition at line 3972 of file Account.cpp.

3973 {
3974  gint64 nr, i;
3975 
3976  PWARN ("xaccAccountCountSplits is deprecated and will be removed \
3977 in GnuCash 5.0. If testing for an empty account, use \
3978 xaccAccountGetSplitList(account) == NULL instead. To test descendants \
3979 as well, use gnc_account_and_descendants_empty.");
3980  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), 0);
3981 
3982  nr = g_list_length(xaccAccountGetSplitList(acc));
3983  if (include_children && (gnc_account_n_children(acc) != 0))
3984  {
3985  for (i=0; i < gnc_account_n_children(acc); i++)
3986  {
3987  nr += xaccAccountCountSplits(gnc_account_nth_child(acc, i), TRUE);
3988  }
3989  }
3990  return nr;
3991 }
SplitList * xaccAccountGetSplitList(const Account *acc)
The xaccAccountGetSplitList() routine returns a pointer to a GList of the splits in the account...
Definition: Account.cpp:3964
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
gint gnc_account_n_children(const Account *account)
Return the number of children of the specified account.
Definition: Account.cpp:2933
gint64 xaccAccountCountSplits(const Account *acc, gboolean include_children)
The xaccAccountCountSplits() routine returns the number of all the splits in the account.
Definition: Account.cpp:3972
Account * gnc_account_nth_child(const Account *parent, gint num)
Return the n&#39;th child account of the specified parent account.
Definition: Account.cpp:2948

◆ xaccAccountFindOpenLots()

LotList* xaccAccountFindOpenLots ( const Account acc,
gboolean(*)(GNCLot *lot, gpointer user_data)  match_func,
gpointer  user_data,
GCompareFunc  sort_func 
)

Find a list of open lots that match the match_func.

Sort according to sort_func. If match_func is NULL, then all open lots are returned. If sort_func is NULL, then the returned list has no particular order. The caller must free to returned list.

Definition at line 4015 of file Account.cpp.

4019 {
4020  AccountPrivate *priv;
4021  GList *lot_list;
4022  GList *retval = NULL;
4023 
4024  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
4025 
4026  priv = GET_PRIVATE(acc);
4027  for (lot_list = priv->lots; lot_list; lot_list = lot_list->next)
4028  {
4029  GNCLot *lot = static_cast<GNCLot*>(lot_list->data);
4030 
4031  /* If this lot is closed, then ignore it */
4032  if (gnc_lot_is_closed (lot))
4033  continue;
4034 
4035  if (match_func && !(match_func)(lot, user_data))
4036  continue;
4037 
4038  /* Ok, this is a valid lot. Add it to our list of lots */
4039  retval = g_list_prepend (retval, lot);
4040  }
4041 
4042  if (sort_func)
4043  retval = g_list_sort (retval, sort_func);
4044 
4045  return retval;
4046 }
gboolean gnc_lot_is_closed(GNCLot *lot)
The gnc_lot_is_closed() routine returns a boolean flag: is this lot closed? A lot is closed if its ba...
Definition: gnc-lot.c:382

◆ xaccAccountFindSplitByDesc()

Split* xaccAccountFindSplitByDesc ( const Account account,
const char *  description 
)

Returns a pointer to the split, not a copy.

Definition at line 5119 of file Account.cpp.

5120 {
5121  Split *split;
5122 
5123  /* Get the split which has a transaction matching the description. */
5124  finder_help_function(acc, description, &split, NULL);
5125  return split;
5126 }

◆ xaccAccountFindTransByDesc()

Transaction* xaccAccountFindTransByDesc ( const Account account,
const char *  description 
)

Returns a pointer to the transaction, not a copy.

Definition at line 5134 of file Account.cpp.

5135 {
5136  Transaction *trans;
5137 
5138  /* Get the translation matching the description. */
5139  finder_help_function(acc, description, NULL, &trans);
5140  return trans;
5141 }

◆ xaccAccountForEachLot()

gpointer xaccAccountForEachLot ( const Account acc,
gpointer(*)(GNCLot *lot, gpointer user_data)  proc,
gpointer  user_data 
)

The xaccAccountForEachLot() method will apply the function 'proc' to each lot in the account.

If 'proc' returns a non-NULL value, further application will be stopped, and the resulting value will be returned. There is no guaranteed order over which the Lots will be traversed.

◆ xaccAccountForEachTransaction()

gint xaccAccountForEachTransaction ( const Account account,
TransactionCallback  proc,
void *  data 
)

The xaccAccountForEachTransaction() routine will traverse all of the transactions in account and call the callback function proc on each transaction.

Processing will continue if-and-only-if proc returns 0. The user data pointer data will be passed on to the callback function proc.

This function does not descend recursively to traverse transactions in child accounts.

proc will be called exactly once for each transaction that is pointed to by at least one split in the given account.

The result of this function will be 0 if and only if every relevant transaction was traversed exactly once. Else the return value is the last non-zero value returned by proc.

Warning
For performance reasons, the transaction callback proc must never destroy any of the transaction's splits, nor assign any of them to a different account. To do so risks a crash.
The traversal occurs only over the transactions that are locally cached in the local gnucash engine. If the gnucash engine is attached to a remote database, the database may contain (many) transactions that are not mirrored in the local cache. This routine will not cause an SQL database query to be performed; it will not traverse transactions present only in the remote database.

Definition at line 5404 of file Account.cpp.

5406 {
5407  if (!acc || !proc) return 0;
5409  return xaccAccountStagedTransactionTraversal(acc, 42, proc, data);
5410 }
void xaccAccountBeginStagedTransactionTraversals(const Account *account)
xaccAccountBeginStagedTransactionTraversals() resets the traversal marker for each transaction which ...
Definition: Account.cpp:5259
int xaccAccountStagedTransactionTraversal(const Account *acc, unsigned int stage, TransactionCallback thunk, void *cb_data)
xaccAccountStagedTransactionTraversal() calls thunk on each transaction in account a whose current ma...
Definition: Account.cpp:5307

◆ xaccAccountGetAutoInterest()

gboolean xaccAccountGetAutoInterest ( const Account acc)

Get the "auto interest" flag for an account.

If this flag is set then the account (and any children) will trigger an interest transfer after reconciling.

Parameters
accThe account whose flag should be retrieved.
Returns
The current state of the account's "auto interest" flag.

Definition at line 4282 of file Account.cpp.

4283 {
4284  return boolean_from_key (acc, {KEY_RECONCILE_INFO, "auto-interest-transfer"});
4285 }

◆ xaccAccountGetDescendantPlaceholder()

GNCPlaceholderType xaccAccountGetDescendantPlaceholder ( const Account account)

Returns PLACEHOLDER_NONE if account is NULL or neither account nor any descendant of account is a placeholder.

If account is a placeholder, returns PLACEHOLDER_THIS. Otherwise, if any descendant of account is a placeholder, return PLACEHOLDER_CHILD.

Definition at line 4258 of file Account.cpp.

4259 {
4260  GList *descendants, *node;
4261  GNCPlaceholderType ret = PLACEHOLDER_NONE;
4262 
4263  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), PLACEHOLDER_NONE);
4264  if (xaccAccountGetPlaceholder(acc)) return PLACEHOLDER_THIS;
4265 
4266  descendants = gnc_account_get_descendants(acc);
4267  for (node = descendants; node; node = node->next)
4268  if (xaccAccountGetPlaceholder((Account *) node->data))
4269  {
4270  ret = PLACEHOLDER_CHILD;
4271  break;
4272  }
4273 
4274  g_list_free(descendants);
4275  return ret;
4276 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:3017
GNCPlaceholderType
DOCUMENT ME!
Definition: Account.h:1193
gboolean xaccAccountGetPlaceholder(const Account *acc)
Get the "placeholder" flag for an account.
Definition: Account.cpp:4220

◆ xaccAccountGetHidden()

gboolean xaccAccountGetHidden ( const Account acc)

Get the "hidden" flag for an account.

If this flag is set then the account (and any children) will be hidden from the user unless they explicitly ask to see them.

Parameters
accThe account whose flag should be retrieved.
Returns
The current state of the account's "hidden" flag.

Definition at line 4297 of file Account.cpp.

4298 {
4299  return boolean_from_key (acc, {"hidden"});
4300 }

◆ xaccAccountGetIsOpeningBalance()

gboolean xaccAccountGetIsOpeningBalance ( const Account account)

Get the "opening-balance" flag for an account.

If this flag is set then the account is used for opening balance transactions.

Parameters
accountThe account whose flag should be retrieved.
Returns
The current state of the account's "opening-balance" flag.

Definition at line 4232 of file Account.cpp.

4233 {
4234  if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
4235  return false;
4236  auto priv = GET_PRIVATE(acc);
4237  if (priv->equity_type == TriState::Unset)
4238  {
4239  auto equity_type = get_kvp_string_tag (acc, "equity-type");
4240  priv->equity_type = g_strcmp0 (equity_type, "opening-balance") ?
4241  TriState::False : TriState::True;
4242  g_free (equity_type);
4243  }
4244  return (priv->equity_type == TriState::True);
4245 }
Equity account is used to balance the balance sheet.
Definition: Account.h:149

◆ xaccAccountGetLotList()

LotList* xaccAccountGetLotList ( const Account account)

The xaccAccountGetLotList() routine returns a list of all lots in this account.

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

Definition at line 4008 of file Account.cpp.

4009 {
4010  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
4011  return g_list_copy(GET_PRIVATE(acc)->lots);
4012 }

◆ xaccAccountGetPlaceholder()

gboolean xaccAccountGetPlaceholder ( const Account account)

Get the "placeholder" flag for an account.

If this flag is set then the account may not be modified by the user.

Parameters
accountThe account whose flag should be retrieved.
Returns
The current state of the account's "placeholder" flag.

Definition at line 4220 of file Account.cpp.

4221 {
4222  return boolean_from_key(acc, {"placeholder"});
4223 }

◆ xaccAccountGetSplitList()

SplitList* xaccAccountGetSplitList ( const Account account)

The xaccAccountGetSplitList() routine returns a pointer to a GList of the splits in the account.

Note
This GList is the account's internal data structure: do not delete it when done; treat it as a read-only structure. Note that some routines (such as xaccAccountRemoveSplit()) modify this list directly, and could leave you with a corrupted pointer.
This should be changed so that the returned value is a copy of the list. No other part of the code should have access to the internal data structure used by this object.

Definition at line 3964 of file Account.cpp.

3965 {
3966  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
3967  xaccAccountSortSplits((Account*)acc, FALSE); // normally a noop
3968  return GET_PRIVATE(acc)->splits;
3969 }
void xaccAccountSortSplits(Account *acc, gboolean force)
The xaccAccountSortSplits() routine will resort the account&#39;s splits if the sort is dirty...
Definition: Account.cpp:1985

◆ xaccAccountGetTypeStr()

const char* xaccAccountGetTypeStr ( GNCAccountType  type)

The xaccAccountGetTypeStr() routine returns a string suitable for use in the GUI/Interface.

These strings should be translated to the local language.

Definition at line 4464 of file Account.cpp.

4465 {
4466  if (type < 0 || NUM_ACCOUNT_TYPES <= type ) return "";
4467  return _(account_type_name [type]);
4468 }
stop here; the following types just aren&#39;t ready for prime time
Definition: Account.h:164

◆ xaccAccountInsertLot()

void xaccAccountInsertLot ( Account ,
GNCLot *   
)

The xaccAccountInsertLot() method will register the indicated lot with this account.

Any splits later inserted into this lot must belong to this account. If the lot is already in another account, the lot, and all of the splits in it, will be moved from that account to this account.

Definition at line 2124 of file Account.cpp.

2125 {
2126  AccountPrivate *priv, *opriv;
2127  Account * old_acc = NULL;
2128  Account* lot_account;
2129 
2130  /* errors */
2131  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2132  g_return_if_fail(GNC_IS_LOT(lot));
2133 
2134  /* optimizations */
2135  lot_account = gnc_lot_get_account(lot);
2136  if (lot_account == acc)
2137  return;
2138 
2139  ENTER ("(acc=%p, lot=%p)", acc, lot);
2140 
2141  /* pull it out of the old account */
2142  if (lot_account)
2143  {
2144  old_acc = lot_account;
2145  opriv = GET_PRIVATE(old_acc);
2146  opriv->lots = g_list_remove(opriv->lots, lot);
2147  }
2148 
2149  priv = GET_PRIVATE(acc);
2150  priv->lots = g_list_prepend(priv->lots, lot);
2151  gnc_lot_set_account(lot, acc);
2152 
2153  /* Don't move the splits to the new account. The caller will do this
2154  * if appropriate, and doing it here will not work if we are being
2155  * called from gnc_book_close_period since xaccAccountInsertSplit
2156  * will try to balance capital gains and things aren't ready for that. */
2157 
2158  qof_event_gen (QOF_INSTANCE(lot), QOF_EVENT_ADD, NULL);
2159  qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, NULL);
2160 
2161  LEAVE ("(acc=%p, lot=%p)", acc, lot);
2162 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
Account * gnc_lot_get_account(const GNCLot *lot)
The gnc_lot_get_account() routine returns the account with which this lot is associated.
Definition: gnc-lot.c:392
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

◆ xaccAccountIsAPARType()

gboolean xaccAccountIsAPARType ( GNCAccountType  t)

Convenience function to check if the account is a valid business account type (meaning an Accounts Payable/Accounts Receivable).

Definition at line 4634 of file Account.cpp.

4635 {
4636  switch (t)
4637  {
4638  case ACCT_TYPE_RECEIVABLE:
4639  case ACCT_TYPE_PAYABLE:
4640  return TRUE;
4641  default:
4642  return FALSE;
4643  }
4644 }
A/P account type.
Definition: Account.h:154
A/R account type.
Definition: Account.h:152

◆ xaccAccountIsAssetLiabType()

gboolean xaccAccountIsAssetLiabType ( GNCAccountType  t)

Convenience function to check if the account is a valid Asset or Liability type, but not a business account type (meaning not an Accounts Payable/Accounts Receivable).

Definition at line 4588 of file Account.cpp.

4589 {
4590  switch (t)
4591  {
4592  case ACCT_TYPE_RECEIVABLE:
4593  case ACCT_TYPE_PAYABLE:
4594  return FALSE;
4595  default:
4598  }
4599 }
gboolean xaccAccountTypesCompatible(GNCAccountType parent_type, GNCAccountType child_type)
Return TRUE if accounts of type parent_type can have accounts of type child_type as children...
Definition: Account.cpp:4561
A/P account type.
Definition: Account.h:154
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:122
A/R account type.
Definition: Account.h:152

◆ xaccAccountIsEquityType()

gboolean xaccAccountIsEquityType ( GNCAccountType  t)

Convenience function to check if the account is a valid Equity type.

Definition at line 4646 of file Account.cpp.

4647 {
4648  switch (t)
4649  {
4650  case ACCT_TYPE_EQUITY:
4651  return TRUE;
4652  default:
4653  return FALSE;
4654  }
4655 }
Equity account is used to balance the balance sheet.
Definition: Account.h:149

◆ xaccAccountIsHidden()

gboolean xaccAccountIsHidden ( const Account acc)

Should this account be "hidden".

If this flag is set for this account (or any parent account) then the account should be hidden from the user unless they explicitly ask to see it. This function is different from the xaccAccountGetHidden() function because it checks the flag in parent accounts in addition to this account.

Parameters
accThe account whose flag should be retrieved.
Returns
Whether or not this account should be "hidden".

Definition at line 4309 of file Account.cpp.

4310 {
4311  AccountPrivate *priv;
4312 
4313  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4314 
4315  if (xaccAccountGetHidden(acc))
4316  return TRUE;
4317  priv = GET_PRIVATE(acc);
4318  while ((acc = priv->parent) != NULL)
4319  {
4320  priv = GET_PRIVATE(acc);
4321  if (xaccAccountGetHidden(acc))
4322  return TRUE;
4323  }
4324  return FALSE;
4325 }
gboolean xaccAccountGetHidden(const Account *acc)
Get the "hidden" flag for an account.
Definition: Account.cpp:4297

◆ xaccAccountMoveAllSplits()

void xaccAccountMoveAllSplits ( Account accfrom,
Account accto 
)

The xaccAccountMoveAllSplits() routine reassigns each of the splits in accfrom to accto.

Definition at line 2184 of file Account.cpp.

2185 {
2186  AccountPrivate *from_priv;
2187 
2188  /* errors */
2189  g_return_if_fail(GNC_IS_ACCOUNT(accfrom));
2190  g_return_if_fail(GNC_IS_ACCOUNT(accto));
2191 
2192  /* optimizations */
2193  from_priv = GET_PRIVATE(accfrom);
2194  if (!from_priv->splits || accfrom == accto)
2195  return;
2196 
2197  /* check for book mix-up */
2198  g_return_if_fail (qof_instance_books_equal(accfrom, accto));
2199  ENTER ("(accfrom=%p, accto=%p)", accfrom, accto);
2200 
2201  xaccAccountBeginEdit(accfrom);
2202  xaccAccountBeginEdit(accto);
2203  /* Begin editing both accounts and all transactions in accfrom. */
2204  g_list_foreach(from_priv->splits, (GFunc)xaccPreSplitMove, NULL);
2205 
2206  /* Concatenate accfrom's lists of splits and lots to accto's lists. */
2207  //to_priv->splits = g_list_concat(to_priv->splits, from_priv->splits);
2208  //to_priv->lots = g_list_concat(to_priv->lots, from_priv->lots);
2209 
2210  /* Set appropriate flags. */
2211  //from_priv->balance_dirty = TRUE;
2212  //from_priv->sort_dirty = FALSE;
2213  //to_priv->balance_dirty = TRUE;
2214  //to_priv->sort_dirty = TRUE;
2215 
2216  /*
2217  * Change each split's account back pointer to accto.
2218  * Convert each split's amount to accto's commodity.
2219  * Commit to editing each transaction.
2220  */
2221  g_list_foreach(from_priv->splits, (GFunc)xaccPostSplitMove, (gpointer)accto);
2222 
2223  /* Finally empty accfrom. */
2224  g_assert(from_priv->splits == NULL);
2225  g_assert(from_priv->lots == NULL);
2226  xaccAccountCommitEdit(accfrom);
2227  xaccAccountCommitEdit(accto);
2228 
2229  LEAVE ("(accfrom=%p, accto=%p)", accfrom, accto);
2230 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gboolean qof_instance_books_equal(gconstpointer ptr1, gconstpointer ptr2)
See if two QofInstances share the same book.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1430
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1471

◆ xaccAccountSetAutoInterest()

void xaccAccountSetAutoInterest ( Account acc,
gboolean  val 
)

Set the "auto interest" flag for an account.

If this flag is set then the account (and any children) will trigger an interest transfer after reconciling.

Parameters
accThe account whose flag should be retrieved.
valThe new state for the account's "auto interest" flag.

Definition at line 4288 of file Account.cpp.

4289 {
4290  set_boolean_key (acc, {KEY_RECONCILE_INFO, "auto-interest-transfer"}, val);
4291 }

◆ xaccAccountSetHidden()

void xaccAccountSetHidden ( Account acc,
gboolean  val 
)

Set the "hidden" flag for an account.

If this flag is set then the account (and any children) will be hidden from the user unless they explicitly ask to see them.

Parameters
accThe account whose flag should be retrieved.
valThe new state for the account's "hidden" flag.

Definition at line 4303 of file Account.cpp.

4304 {
4305  set_boolean_key (acc, {"hidden"}, val);
4306 }

◆ xaccAccountSetIsOpeningBalance()

void xaccAccountSetIsOpeningBalance ( Account account,
gboolean  val 
)

Set the "opening-balance" flag for an account.

If this flag is set then the account is used for opening balance transactions.

Parameters
accountThe account whose flag should be set.
valThe new state for the account's "opening-balance" flag.

Definition at line 4248 of file Account.cpp.

4249 {
4250  if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
4251  return;
4252  auto priv = GET_PRIVATE (acc);
4253  priv->equity_type = val ? TriState::True : TriState::False;
4254  set_kvp_string_tag(acc, "equity-type", val ? "opening-balance" : nullptr);
4255 }
Equity account is used to balance the balance sheet.
Definition: Account.h:149

◆ xaccAccountSetMark()

void xaccAccountSetMark ( Account account,
short  mark 
)

Set a mark on the account.

The meaning of this mark is completely undefined. Its presented here as a utility for the programmer, to use as desired. Handy for performing customer traversals over the account tree. The mark is not stored in the database/file format. When accounts are newly created, the mark is set to zero.

Definition at line 2043 of file Account.cpp.

2044 {
2045  AccountPrivate *priv;
2046 
2047  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2048 
2049  priv = GET_PRIVATE(acc);
2050  priv->mark = m;
2051 }

◆ xaccAccountSetPlaceholder()

void xaccAccountSetPlaceholder ( Account account,
gboolean  val 
)

Set the "placeholder" flag for an account.

If this flag is set then the account may not be modified by the user.

Parameters
accountThe account whose flag should be retrieved.
valThe new state for the account's "placeholder" flag.

Definition at line 4226 of file Account.cpp.

4227 {
4228  set_boolean_key(acc, {"placeholder"}, val);
4229 }

◆ xaccAccountStagedTransactionTraversal()

int xaccAccountStagedTransactionTraversal ( const Account a,
unsigned int  stage,
TransactionCallback  thunk,
void *  data 
)

xaccAccountStagedTransactionTraversal() calls thunk on each transaction in account a whose current marker is less than the given stage and updates each transaction's marker to be stage.

The traversal will stop if thunk returns a non-zero value. xaccAccountStagedTransactionTraversal() function will return zero or the non-zero value returned by thunk. This API does not handle handle recursive traversals.

Warning
For performance reasons, the transaction callback thunk must never destroy any of the transaction's splits, nor assign any of them to a different account. To do so risks a crash.

Definition at line 5307 of file Account.cpp.

5311 {
5312  AccountPrivate *priv;
5313  GList *split_p;
5314  GList *next;
5315  Transaction *trans;
5316  Split *s;
5317  int retval;
5318 
5319  if (!acc) return 0;
5320 
5321  priv = GET_PRIVATE(acc);
5322  for (split_p = priv->splits; split_p; split_p = next)
5323  {
5324  /* Get the next element in the split list now, just in case some
5325  * naughty thunk destroys the one we're using. This reduces, but
5326  * does not eliminate, the possibility of undefined results if
5327  * a thunk removes splits from this account. */
5328  next = g_list_next(split_p);
5329 
5330  s = static_cast <Split*> (split_p->data);
5331  trans = s->parent;
5332  if (trans && (trans->marker < stage))
5333  {
5334  trans->marker = stage;
5335  if (thunk)
5336  {
5337  retval = thunk(trans, cb_data);
5338  if (retval) return retval;
5339  }
5340  }
5341  }
5342 
5343  return 0;
5344 }

◆ xaccAccountStringToEnum()

GNCAccountType xaccAccountStringToEnum ( const char *  str)

Conversion routines for the account types to/from strings that are used in persistent storage, communications.

These strings should not be translated to the local language. Typical conversion is "INCOME" -> ACCT_TYPE_INCOME.

Definition at line 4425 of file Account.cpp.

4426 {
4427  GNCAccountType type;
4428  gboolean rc;
4429  rc = xaccAccountStringToType(str, &type);
4430  if (FALSE == rc) return ACCT_TYPE_INVALID;
4431  return type;
4432 }
gboolean xaccAccountStringToType(const char *str, GNCAccountType *type)
Conversion routines for the account types to/from strings that are used in persistent storage...
Definition: Account.cpp:4391
GNCAccountType
The account types are used to determine how the transaction data in the account is displayed...
Definition: Account.h:105
Not a type.
Definition: Account.h:107

◆ xaccAccountStringToType()

gboolean xaccAccountStringToType ( const char *  str,
GNCAccountType type 
)

Conversion routines for the account types to/from strings that are used in persistent storage, communications.

These strings should not be translated to the local language. Typical conversion is "INCOME" -> ACCT_TYPE_INCOME.

Definition at line 4391 of file Account.cpp.

4392 {
4393 
4394  GNC_RETURN_ON_MATCH(NONE);
4395  GNC_RETURN_ON_MATCH(BANK);
4396  GNC_RETURN_ON_MATCH(CASH);
4397  GNC_RETURN_ON_MATCH(CREDIT);
4398  GNC_RETURN_ON_MATCH(ASSET);
4399  GNC_RETURN_ON_MATCH(LIABILITY);
4400  GNC_RETURN_ON_MATCH(STOCK);
4401  GNC_RETURN_ON_MATCH(MUTUAL);
4402  GNC_RETURN_ON_MATCH(CURRENCY);
4403  GNC_RETURN_ON_MATCH(INCOME);
4404  GNC_RETURN_ON_MATCH(EXPENSE);
4405  GNC_RETURN_ON_MATCH(EQUITY);
4406  GNC_RETURN_ON_MATCH(RECEIVABLE);
4407  GNC_RETURN_ON_MATCH(PAYABLE);
4408  GNC_RETURN_ON_MATCH(ROOT);
4409  GNC_RETURN_ON_MATCH(TRADING);
4410  GNC_RETURN_ON_MATCH(CHECKING);
4411  GNC_RETURN_ON_MATCH(SAVINGS);
4412  GNC_RETURN_ON_MATCH(MONEYMRKT);
4413  GNC_RETURN_ON_MATCH(CREDITLINE);
4414 
4415  PERR("asked to translate unknown account type string %s.\n",
4416  str ? str : "(null)");
4417 
4418  return(FALSE);
4419 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244

◆ xaccAccountTreeForEachTransaction()

int xaccAccountTreeForEachTransaction ( Account acc,
TransactionCallback  proc,
void *  data 
)

Traverse all of the transactions in the given account group.

Continue processing IF proc returns 0. This function will descend recursively to traverse transactions in the children of the accounts in the group.

Proc will be called exactly once for each transaction that is pointed to by at least one split in any account in the hierarchy topped by the root Account acc.

The result of this function will be 0 IF every relevant transaction was traversed exactly once; otherwise, the return value is the last non-zero value returned by the callback.

Warning
For performance reasons, the transaction callback proc must never destroy any of the transaction's splits, nor assign any of them to a different account. To do so risks a crash.
The traversal occurs only over the transactions that are locally cached in the local gnucash engine. If the gnucash engine is attached to a remote database, the database may contain (many) transactions that are not mirrored in the local cache. This routine will not cause an SQL database query to be performed; it will not traverse transactions present only in the remote database.

Note that this routine is just a trivial wrapper for

gnc_account_tree_begin_staged_transaction_traversals(g); gnc_account_tree_staged_transaction_traversal(g, 42, proc, data);

◆ xaccAccountTypeEnumAsString()

const char* xaccAccountTypeEnumAsString ( GNCAccountType  type)

Conversion routines for the account types to/from strings that are used in persistent storage, communications.

These strings should not be translated to the local language. Typical conversion is ACCT_TYPE_INCOME -> "INCOME".

Definition at line 4354 of file Account.cpp.

4355 {
4356  switch (type)
4357  {
4358  GNC_RETURN_ENUM_AS_STRING(NONE);
4359  GNC_RETURN_ENUM_AS_STRING(BANK);
4360  GNC_RETURN_ENUM_AS_STRING(CASH);
4361  GNC_RETURN_ENUM_AS_STRING(CREDIT);
4362  GNC_RETURN_ENUM_AS_STRING(ASSET);
4363  GNC_RETURN_ENUM_AS_STRING(LIABILITY);
4364  GNC_RETURN_ENUM_AS_STRING(STOCK);
4365  GNC_RETURN_ENUM_AS_STRING(MUTUAL);
4366  GNC_RETURN_ENUM_AS_STRING(CURRENCY);
4367  GNC_RETURN_ENUM_AS_STRING(INCOME);
4368  GNC_RETURN_ENUM_AS_STRING(EXPENSE);
4369  GNC_RETURN_ENUM_AS_STRING(EQUITY);
4370  GNC_RETURN_ENUM_AS_STRING(RECEIVABLE);
4371  GNC_RETURN_ENUM_AS_STRING(PAYABLE);
4372  GNC_RETURN_ENUM_AS_STRING(ROOT);
4373  GNC_RETURN_ENUM_AS_STRING(TRADING);
4374  GNC_RETURN_ENUM_AS_STRING(CHECKING);
4375  GNC_RETURN_ENUM_AS_STRING(SAVINGS);
4376  GNC_RETURN_ENUM_AS_STRING(MONEYMRKT);
4377  GNC_RETURN_ENUM_AS_STRING(CREDITLINE);
4378  default:
4379  PERR ("asked to translate unknown account type %d.\n", type);
4380  break;
4381  }
4382  return(NULL);
4383 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244

◆ xaccAccountTypeGetFundamental()

GNCAccountType xaccAccountTypeGetFundamental ( GNCAccountType  t)

Convenience function to return the fundamental type asset/liability/income/expense/equity given an account type.

Definition at line 4602 of file Account.cpp.

4603 {
4604  switch (t)
4605  {
4606  case ACCT_TYPE_BANK:
4607  case ACCT_TYPE_STOCK:
4608  case ACCT_TYPE_MONEYMRKT:
4609  case ACCT_TYPE_CHECKING:
4610  case ACCT_TYPE_SAVINGS:
4611  case ACCT_TYPE_MUTUAL:
4612  case ACCT_TYPE_CURRENCY:
4613  case ACCT_TYPE_CASH:
4614  case ACCT_TYPE_ASSET:
4615  case ACCT_TYPE_RECEIVABLE:
4616  return ACCT_TYPE_ASSET;
4617  case ACCT_TYPE_CREDIT:
4618  case ACCT_TYPE_LIABILITY:
4619  case ACCT_TYPE_PAYABLE:
4620  case ACCT_TYPE_CREDITLINE:
4621  return ACCT_TYPE_LIABILITY;
4622  case ACCT_TYPE_INCOME:
4623  return ACCT_TYPE_INCOME;
4624  case ACCT_TYPE_EXPENSE:
4625  return ACCT_TYPE_EXPENSE;
4626  case ACCT_TYPE_EQUITY:
4627  return ACCT_TYPE_EQUITY;
4628  case ACCT_TYPE_TRADING:
4629  default:
4630  return ACCT_TYPE_NONE;
4631  }
4632 }
Expense accounts are used to denote expenses.
Definition: Account.h:146
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:128
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:113
Account used to record multiple commodity transactions.
Definition: Account.h:158
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:125
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:168
Income accounts are used to denote income.
Definition: Account.h:143
line of credit – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:174
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:110
A/P account type.
Definition: Account.h:154
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:170
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:132
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:122
A/R account type.
Definition: Account.h:152
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:172
Equity account is used to balance the balance sheet.
Definition: Account.h:149
Not a type.
Definition: Account.h:108
The Credit card account is used to denote credit (e.g.
Definition: Account.h:116

◆ xaccAccountTypesCompatible()

gboolean xaccAccountTypesCompatible ( GNCAccountType  parent_type,
GNCAccountType  child_type 
)

Return TRUE if accounts of type parent_type can have accounts of type child_type as children.

Definition at line 4561 of file Account.cpp.

4563 {
4564  /* ACCT_TYPE_NONE isn't compatible with anything, even ACCT_TYPE_NONE. */
4565  if (parent_type == ACCT_TYPE_NONE || child_type == ACCT_TYPE_NONE)
4566  return FALSE;
4567 
4568  /* ACCT_TYPE_ROOT can't have a parent account, and asking will raise
4569  * an error. */
4570  if (child_type == ACCT_TYPE_ROOT)
4571  return FALSE;
4572 
4573  return ((xaccParentAccountTypesCompatibleWith (child_type) &
4574  (1 << parent_type))
4575  != 0);
4576 }
guint32 xaccParentAccountTypesCompatibleWith(GNCAccountType type)
Return the bitmask of parent account types compatible with a given type.
Definition: Account.cpp:4514
Not a type.
Definition: Account.h:108
The hidden root account of an account tree.
Definition: Account.h:156

◆ xaccAccountTypesCompatibleWith()

guint32 xaccAccountTypesCompatibleWith ( GNCAccountType  type)

Return the bitmask of account types compatible with a given type.

That is, you could switch to any of the account types in the compatible list without unwanted side-effects.

Definition at line 4474 of file Account.cpp.

4475 {
4476  switch (type)
4477  {
4478  case ACCT_TYPE_BANK:
4479  case ACCT_TYPE_CASH:
4480  case ACCT_TYPE_ASSET:
4481  case ACCT_TYPE_CREDIT:
4482  case ACCT_TYPE_LIABILITY:
4483  case ACCT_TYPE_INCOME:
4484  case ACCT_TYPE_EXPENSE:
4485  case ACCT_TYPE_EQUITY:
4486  return
4487  (1 << ACCT_TYPE_BANK) |
4488  (1 << ACCT_TYPE_CASH) |
4489  (1 << ACCT_TYPE_ASSET) |
4490  (1 << ACCT_TYPE_CREDIT) |
4491  (1 << ACCT_TYPE_LIABILITY) |
4492  (1 << ACCT_TYPE_INCOME) |
4493  (1 << ACCT_TYPE_EXPENSE) |
4494  (1 << ACCT_TYPE_EQUITY);
4495  case ACCT_TYPE_STOCK:
4496  case ACCT_TYPE_MUTUAL:
4497  case ACCT_TYPE_CURRENCY:
4498  return
4499  (1 << ACCT_TYPE_STOCK) |
4500  (1 << ACCT_TYPE_MUTUAL) |
4501  (1 << ACCT_TYPE_CURRENCY);
4502  case ACCT_TYPE_RECEIVABLE:
4503  return (1 << ACCT_TYPE_RECEIVABLE);
4504  case ACCT_TYPE_PAYABLE:
4505  return (1 << ACCT_TYPE_PAYABLE);
4506  case ACCT_TYPE_TRADING:
4507  return (1 << ACCT_TYPE_TRADING);
4508  default:
4509  PERR("bad account type: %d", type);
4510  return 0;
4511  }
4512 }
Expense accounts are used to denote expenses.
Definition: Account.h:146
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:128
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:113
Account used to record multiple commodity transactions.
Definition: Account.h:158
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:125
Income accounts are used to denote income.
Definition: Account.h:143
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:110
A/P account type.
Definition: Account.h:154
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:132
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:122
A/R account type.
Definition: Account.h:152
Equity account is used to balance the balance sheet.
Definition: Account.h:149
The Credit card account is used to denote credit (e.g.
Definition: Account.h:116

◆ xaccAccountTypesValid()

guint32 xaccAccountTypesValid ( void  )

Returns the bitmask of the account type enums that are valid.

Deprecated and root account types are stripped.

Definition at line 4579 of file Account.cpp.

4580 {
4581  guint32 mask = (1 << NUM_ACCOUNT_TYPES) - 1;
4582  mask &= ~((1 << ACCT_TYPE_CURRENCY) | /* DEPRECATED */
4583  (1 << ACCT_TYPE_ROOT)); /* ROOT */
4584 
4585  return mask;
4586 }
stop here; the following types just aren&#39;t ready for prime time
Definition: Account.h:164
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:132
The hidden root account of an account tree.
Definition: Account.h:156

◆ xaccClearMark()

void xaccClearMark ( Account account,
short  val 
)

Get the mark set by xaccAccountSetMark short xaccAccountGetMark (const Account *account);.

The xaccClearMark will find the root account, and clear the mark in the entire account tree.

Definition at line 2054 of file Account.cpp.

2055 {
2056  Account *root;
2057 
2058  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2059 
2060  root = gnc_account_get_root(acc);
2061  xaccClearMarkDown(root ? root : acc, val);
2062 }
void xaccClearMarkDown(Account *acc, short val)
The xaccClearMarkDown will clear the mark only in this and in sub-accounts.
Definition: Account.cpp:2065
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:2887

◆ xaccClearMarkDown()

void xaccClearMarkDown ( Account account,
short  val 
)

The xaccClearMarkDown will clear the mark only in this and in sub-accounts.

Definition at line 2065 of file Account.cpp.

2066 {
2067  AccountPrivate *priv;
2068  GList *node;
2069 
2070  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2071 
2072  priv = GET_PRIVATE(acc);
2073  priv->mark = val;
2074  for (node = priv->children; node; node = node->next)
2075  {
2076  xaccClearMarkDown(static_cast<Account*>(node->data), val);
2077  }
2078 }
void xaccClearMarkDown(Account *acc, short val)
The xaccClearMarkDown will clear the mark only in this and in sub-accounts.
Definition: Account.cpp:2065

◆ xaccParentAccountTypesCompatibleWith()

guint32 xaccParentAccountTypesCompatibleWith ( GNCAccountType  type)

Return the bitmask of parent account types compatible with a given type.

Definition at line 4514 of file Account.cpp.

4515 {
4516  switch (type)
4517  {
4518  case ACCT_TYPE_BANK:
4519  case ACCT_TYPE_CASH:
4520  case ACCT_TYPE_ASSET:
4521  case ACCT_TYPE_STOCK:
4522  case ACCT_TYPE_MUTUAL:
4523  case ACCT_TYPE_CURRENCY:
4524  case ACCT_TYPE_CREDIT:
4525  case ACCT_TYPE_LIABILITY:
4526  case ACCT_TYPE_RECEIVABLE:
4527  case ACCT_TYPE_PAYABLE:
4528  return
4529  (1 << ACCT_TYPE_BANK) |
4530  (1 << ACCT_TYPE_CASH) |
4531  (1 << ACCT_TYPE_ASSET) |
4532  (1 << ACCT_TYPE_STOCK) |
4533  (1 << ACCT_TYPE_MUTUAL) |
4534  (1 << ACCT_TYPE_CURRENCY) |
4535  (1 << ACCT_TYPE_CREDIT) |
4536  (1 << ACCT_TYPE_LIABILITY) |
4537  (1 << ACCT_TYPE_RECEIVABLE) |
4538  (1 << ACCT_TYPE_PAYABLE) |
4539  (1 << ACCT_TYPE_ROOT);
4540  case ACCT_TYPE_INCOME:
4541  case ACCT_TYPE_EXPENSE:
4542  return
4543  (1 << ACCT_TYPE_INCOME) |
4544  (1 << ACCT_TYPE_EXPENSE) |
4545  (1 << ACCT_TYPE_ROOT);
4546  case ACCT_TYPE_EQUITY:
4547  return
4548  (1 << ACCT_TYPE_EQUITY) |
4549  (1 << ACCT_TYPE_ROOT);
4550  case ACCT_TYPE_TRADING:
4551  return
4552  (1 << ACCT_TYPE_TRADING) |
4553  (1 << ACCT_TYPE_ROOT);
4554  default:
4555  PERR("bad account type: %d", type);
4556  return 0;
4557  }
4558 }
Expense accounts are used to denote expenses.
Definition: Account.h:146
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:128
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:113
Account used to record multiple commodity transactions.
Definition: Account.h:158
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:125
Income accounts are used to denote income.
Definition: Account.h:143
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:110
A/P account type.
Definition: Account.h:154
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:132
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:122
A/R account type.
Definition: Account.h:152
Equity account is used to balance the balance sheet.
Definition: Account.h:149
The hidden root account of an account tree.
Definition: Account.h:156
The Credit card account is used to denote credit (e.g.
Definition: Account.h:116

◆ xaccTransactionTraverse()

gboolean xaccTransactionTraverse ( Transaction *  trans,
int  stage 
)

xaccTransactionTraverse() checks the stage of the given transaction.

If the transaction hasn't reached the given stage, the transaction is updated to that stage and the function returns TRUE. Otherwise no change is made and the function returns FALSE.

Definition at line 5270 of file Account.cpp.

5271 {
5272  if (trans == NULL) return FALSE;
5273 
5274  if (trans->marker < stage)
5275  {
5276  trans->marker = stage;
5277  return TRUE;
5278  }
5279 
5280  return FALSE;
5281 }