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.

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

	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.

	Options
	GnuCash Options System for Book, Report, and Stylesheet Options.

	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
GList *	gnc_accounts_and_all_descendants (GList *accounts)

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)

	GncOptionValue< ValueType >::GncOptionValue (const char section, const char name, const char key, const char doc_string, ValueType value, GncOptionUIType ui_type=GncOptionUIType::INTERNAL)

	GncOptionValue< ValueType >::GncOptionValue (const GncOptionValue &)=default

	GncOptionValue< ValueType >::GncOptionValue (GncOptionValue &&)=default

GncOptionValue &	GncOptionValue< ValueType >::operator= (const GncOptionValue &)=default

GncOptionValue &	GncOptionValue< ValueType >::operator= (GncOptionValue &&)=default

ValueType	GncOptionValue< ValueType >::get_value () const

ValueType	GncOptionValue< ValueType >::get_default_value () const

void	GncOptionValue< ValueType >::set_value (ValueType new_value)

void	GncOptionValue< ValueType >::set_default_value (ValueType new_value)

void	GncOptionValue< ValueType >::reset_default_value ()

void	GncOptionValue< ValueType >::mark_saved () noexcept

bool	GncOptionValue< ValueType >::is_dirty () const noexcept

bool	GncOptionValue< ValueType >::is_changed () const noexcept

GncOptionUIType	GncOptionValue< ValueType >::get_ui_type () const noexcept

void	GncOptionValue< ValueType >::make_internal ()

bool	GncOptionValue< ValueType >::is_internal ()

std::string	GncOptionValue< ValueType >::serialize () const noexcept

bool	GncOptionValue< ValueType >::deserialize (const std::string &str) noexcept

void	GncOwnerDeleter::operator() (GncOwner *o)

	GncOptionGncOwnerValue::GncOptionGncOwnerValue (const char section, const char name, const char key, const char doc_string, const GncOwner *value, GncOptionUIType ui_type=GncOptionUIType::INTERNAL)

	GncOptionGncOwnerValue::GncOptionGncOwnerValue (const GncOptionGncOwnerValue &from)

	GncOptionGncOwnerValue::GncOptionGncOwnerValue (GncOptionGncOwnerValue &&)=default

const GncOwner *	GncOptionGncOwnerValue::get_value () const

const GncOwner *	GncOptionGncOwnerValue::get_default_value () const

void	GncOptionGncOwnerValue::set_value (const GncOwner *new_value)

void	GncOptionGncOwnerValue::set_default_value (const GncOwner *new_value)

void	GncOptionGncOwnerValue::reset_default_value ()

void	GncOptionGncOwnerValue::mark_saved () noexcept

bool	GncOptionGncOwnerValue::is_dirty () const noexcept

bool	GncOptionGncOwnerValue::is_changed () const noexcept

GncOptionUIType	GncOptionGncOwnerValue::get_ui_type () const noexcept

void	GncOptionGncOwnerValue::make_internal ()

bool	GncOptionGncOwnerValue::is_internal ()

std::string	GncOptionGncOwnerValue::serialize () const noexcept

bool	GncOptionGncOwnerValue::deserialize (const std::string &str) noexcept

	GncOptionQofInstanceValue::GncOptionQofInstanceValue (const char section, const char name, const char key, const char doc_string, const QofInstance *value, GncOptionUIType ui_type=GncOptionUIType::INTERNAL)

	GncOptionQofInstanceValue::GncOptionQofInstanceValue (const GncOptionQofInstanceValue &from)

	GncOptionQofInstanceValue::GncOptionQofInstanceValue (GncOptionQofInstanceValue &&)=default

GncOptionQofInstanceValue &	GncOptionQofInstanceValue::operator= (GncOptionQofInstanceValue &&)=default

const QofInstance *	GncOptionQofInstanceValue::get_value () const

const QofInstance *	GncOptionQofInstanceValue::get_default_value () const

GncItem	GncOptionQofInstanceValue::get_item () const

GncItem	GncOptionQofInstanceValue::get_default_item () const

void	GncOptionQofInstanceValue::set_value (const QofInstance *new_value)

void	GncOptionQofInstanceValue::set_default_value (const QofInstance *new_value)

void	GncOptionQofInstanceValue::reset_default_value ()

void	GncOptionQofInstanceValue::mark_saved () noexcept

bool	GncOptionQofInstanceValue::is_dirty () const noexcept

bool	GncOptionQofInstanceValue::is_changed () const noexcept

GncOptionUIType	GncOptionQofInstanceValue::get_ui_type () const noexcept

void	GncOptionQofInstanceValue::make_internal ()

bool	GncOptionQofInstanceValue::is_internal ()

std::string	GncOptionQofInstanceValue::serialize () const noexcept

bool	GncOptionQofInstanceValue::deserialize (const std::string &str) noexcept

	GncOptionCommodityValue::GncOptionCommodityValue (const char section, const char name, const char key, const char doc_string, gnc_commodity *value, GncOptionUIType ui_type=GncOptionUIType::COMMODITY)

	GncOptionCommodityValue::GncOptionCommodityValue (const GncOptionCommodityValue &)=default

	GncOptionCommodityValue::GncOptionCommodityValue (GncOptionCommodityValue &&)=default

GncOptionCommodityValue &	GncOptionCommodityValue::operator= (const GncOptionCommodityValue &)=default

GncOptionCommodityValue &	GncOptionCommodityValue::operator= (GncOptionCommodityValue &&)=default

gnc_commodity *	GncOptionCommodityValue::get_value () const

gnc_commodity *	GncOptionCommodityValue::get_default_value () const

bool	GncOptionCommodityValue::validate (gnc_commodity *) const noexcept

void	GncOptionCommodityValue::set_value (gnc_commodity *value)

void	GncOptionCommodityValue::set_default_value (gnc_commodity *value)

void	GncOptionCommodityValue::reset_default_value ()

void	GncOptionCommodityValue::mark_saved () noexcept

bool	GncOptionCommodityValue::is_dirty () const noexcept

bool	GncOptionCommodityValue::is_changed () const noexcept

GncOptionUIType	GncOptionCommodityValue::get_ui_type () const noexcept

void	GncOptionCommodityValue::make_internal ()

bool	GncOptionCommodityValue::is_internal ()

std::string	GncOptionCommodityValue::serialize () const noexcept

bool	GncOptionCommodityValue::deserialize (const std::string &str) noexcept

	GncOptionRangeValue< ValueType >::GncOptionRangeValue (const char section, const char name, const char key, const char doc_string, ValueType value, ValueType min, ValueType max, ValueType step)

	GncOptionRangeValue< ValueType >::GncOptionRangeValue (const char section, const char name, const char key, const char doc_string, ValueType value, ValueType min, ValueType max, ValueType step, GncOptionUIType ui)

	GncOptionRangeValue< ValueType >::GncOptionRangeValue (const GncOptionRangeValue< ValueType > &)=default

	GncOptionRangeValue< ValueType >::GncOptionRangeValue (GncOptionRangeValue< ValueType > &&)=default

GncOptionRangeValue< ValueType > &	GncOptionRangeValue< ValueType >::operator= (const GncOptionRangeValue< ValueType > &)=default

GncOptionRangeValue< ValueType > &	GncOptionRangeValue< ValueType >::operator= (GncOptionRangeValue< ValueType > &&)=default

ValueType	GncOptionRangeValue< ValueType >::get_value () const

ValueType	GncOptionRangeValue< ValueType >::get_default_value () const

bool	GncOptionRangeValue< ValueType >::validate (ValueType value)

void	GncOptionRangeValue< ValueType >::set_value (ValueType value)

void	GncOptionRangeValue< ValueType >::set_default_value (ValueType value)

void	GncOptionRangeValue< ValueType >::get_limits (ValueType &upper, ValueType &lower, ValueType &step) const noexcept

void	GncOptionRangeValue< ValueType >::reset_default_value ()

void	GncOptionRangeValue< ValueType >::mark_saved () noexcept

bool	GncOptionRangeValue< ValueType >::is_dirty () const noexcept

bool	GncOptionRangeValue< ValueType >::is_changed () const noexcept

GncOptionUIType	GncOptionRangeValue< ValueType >::get_ui_type () const noexcept

void	GncOptionRangeValue< ValueType >::make_internal ()

bool	GncOptionRangeValue< ValueType >::is_internal ()

bool	GncOptionRangeValue< ValueType >::is_alternate () const noexcept

void	GncOptionRangeValue< ValueType >::set_alternate (bool value) noexcept

std::string	GncOptionRangeValue< ValueType >::serialize () const noexcept

bool	GncOptionRangeValue< ValueType >::deserialize (const std::string &str) noexcept

	GncOptionMultichoiceValue::GncOptionMultichoiceValue (const char section, const char name, const char key, const char doc_string, const char *value, GncMultichoiceOptionChoices &&choices, GncOptionUIType ui_type=GncOptionUIType::MULTICHOICE)

	GncOptionMultichoiceValue::GncOptionMultichoiceValue (const char section, const char name, const char key, const char doc_string, uint16_t index, GncMultichoiceOptionChoices &&choices, GncOptionUIType ui_type=GncOptionUIType::MULTICHOICE)

	GncOptionMultichoiceValue::GncOptionMultichoiceValue (const char section, const char name, const char key, const char doc_string, GncMultichoiceOptionIndexVec &&indices, GncMultichoiceOptionChoices &&choices, GncOptionUIType ui_type=GncOptionUIType::LIST)

	GncOptionMultichoiceValue::GncOptionMultichoiceValue (const GncOptionMultichoiceValue &)=default

	GncOptionMultichoiceValue::GncOptionMultichoiceValue (GncOptionMultichoiceValue &&)=default

GncOptionMultichoiceValue &	GncOptionMultichoiceValue::operator= (const GncOptionMultichoiceValue &)=default

GncOptionMultichoiceValue &	GncOptionMultichoiceValue::operator= (GncOptionMultichoiceValue &&)=default

const std::string &	GncOptionMultichoiceValue::get_value () const

const std::string &	GncOptionMultichoiceValue::get_default_value () const

uint16_t	GncOptionMultichoiceValue::get_index () const

const GncMultichoiceOptionIndexVec &	GncOptionMultichoiceValue::get_multiple () const noexcept

const GncMultichoiceOptionIndexVec &	GncOptionMultichoiceValue::get_default_multiple () const noexcept

bool	GncOptionMultichoiceValue::validate (const std::string &value) const noexcept

bool	GncOptionMultichoiceValue::validate (const GncMultichoiceOptionIndexVec &indexes) const noexcept

void	GncOptionMultichoiceValue::set_value (const std::string &value)

void	GncOptionMultichoiceValue::set_value (uint16_t index)

void	GncOptionMultichoiceValue::set_default_value (const std::string &value)

void	GncOptionMultichoiceValue::set_default_value (uint16_t index)

void	GncOptionMultichoiceValue::set_multiple (const GncMultichoiceOptionIndexVec &indexes)

void	GncOptionMultichoiceValue::set_default_multiple (const GncMultichoiceOptionIndexVec &indexes)

uint16_t	GncOptionMultichoiceValue::num_permissible_values () const noexcept

uint16_t	GncOptionMultichoiceValue::permissible_value_index (const char *key) const noexcept

const char *	GncOptionMultichoiceValue::permissible_value (uint16_t index) const

const char *	GncOptionMultichoiceValue::permissible_value_name (uint16_t index) const

void	GncOptionMultichoiceValue::reset_default_value ()

void	GncOptionMultichoiceValue::mark_saved () noexcept

bool	GncOptionMultichoiceValue::is_dirty () const noexcept

bool	GncOptionMultichoiceValue::is_changed () const noexcept

GncOptionUIType	GncOptionMultichoiceValue::get_ui_type () const noexcept

void	GncOptionMultichoiceValue::make_internal ()

bool	GncOptionMultichoiceValue::is_internal ()

GncOptionMultichoiceKeyType	GncOptionMultichoiceValue::get_keytype (unsigned i) const

std::string	GncOptionMultichoiceValue::serialize () const noexcept

bool	GncOptionMultichoiceValue::deserialize (const std::string &str) noexcept

	GncOptionAccountListValue::GncOptionAccountListValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, bool multi=true)

	GncOptionAccountListValue::GncOptionAccountListValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, const GncOptionAccountList &value, bool multi=true)

	GncOptionAccountListValue::GncOptionAccountListValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, GncOptionAccountTypeList &&allowed, bool multi=true)

	GncOptionAccountListValue::GncOptionAccountListValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, const GncOptionAccountList &value, GncOptionAccountTypeList &&allowed, bool multi=true)

GncOptionAccountList	GncOptionAccountListValue::get_value () const

GncOptionAccountList	GncOptionAccountListValue::get_default_value () const

bool	GncOptionAccountListValue::validate (const GncOptionAccountList &values) const

void	GncOptionAccountListValue::set_value (GncOptionAccountList values)

void	GncOptionAccountListValue::set_default_value (GncOptionAccountList values)

GList *	GncOptionAccountListValue::account_type_list () const noexcept
	Create a GList of account types to pass to gnc_account_sel_set_acct_filters. More...

void	GncOptionAccountListValue::reset_default_value ()

void	GncOptionAccountListValue::mark_saved () noexcept

bool	GncOptionAccountListValue::is_dirty () const noexcept

bool	GncOptionAccountListValue::is_changed () const noexcept

GncOptionUIType	GncOptionAccountListValue::get_ui_type () const noexcept

void	GncOptionAccountListValue::make_internal ()

bool	GncOptionAccountListValue::is_internal ()

bool	GncOptionAccountListValue::is_multiselect () const noexcept

std::string	GncOptionAccountListValue::serialize () const noexcept

bool	GncOptionAccountListValue::deserialize (const std::string &str) noexcept

	GncOptionAccountSelValue::GncOptionAccountSelValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type)

	GncOptionAccountSelValue::GncOptionAccountSelValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, const Account *value)

	GncOptionAccountSelValue::GncOptionAccountSelValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, GncOptionAccountTypeList &&allowed)

	GncOptionAccountSelValue::GncOptionAccountSelValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, const Account *value, GncOptionAccountTypeList &&allowed)

const Account *	GncOptionAccountSelValue::get_value () const

const Account *	GncOptionAccountSelValue::get_default_value () const

bool	GncOptionAccountSelValue::validate (const Account *value) const

void	GncOptionAccountSelValue::set_value (const Account *value)

void	GncOptionAccountSelValue::set_default_value (const Account *value)

GList *	GncOptionAccountSelValue::account_type_list () const noexcept
	Create a GList of account types to pass to gnc_account_sel_set_acct_filters. More...

void	GncOptionAccountSelValue::reset_default_value ()

void	GncOptionAccountSelValue::mark_saved () noexcept

bool	GncOptionAccountSelValue::is_dirty () const noexcept

bool	GncOptionAccountSelValue::is_changed () const noexcept

GncOptionUIType	GncOptionAccountSelValue::get_ui_type () const noexcept

void	GncOptionAccountSelValue::make_internal ()

bool	GncOptionAccountSelValue::is_internal ()

std::string	GncOptionAccountSelValue::serialize () const noexcept

bool	GncOptionAccountSelValue::deserialize (const std::string &str) noexcept

	GncOptionDateValue::GncOptionDateValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type)

	GncOptionDateValue::GncOptionDateValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, time64 time)

	GncOptionDateValue::GncOptionDateValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, RelativeDatePeriod period)

	GncOptionDateValue::GncOptionDateValue (const char section, const char name, const char key, const char doc_string, GncOptionUIType ui_type, const RelativeDatePeriodVec &period_set)

	GncOptionDateValue::GncOptionDateValue (const GncOptionDateValue &)=default

	GncOptionDateValue::GncOptionDateValue (GncOptionDateValue &&)=default

GncOptionDateValue &	GncOptionDateValue::operator= (const GncOptionDateValue &)=default

GncOptionDateValue &	GncOptionDateValue::operator= (GncOptionDateValue &&)=default

time64	GncOptionDateValue::get_value () const noexcept

time64	GncOptionDateValue::get_default_value () const noexcept

RelativeDatePeriod	GncOptionDateValue::get_period () const noexcept

RelativeDatePeriod	GncOptionDateValue::get_default_period () const noexcept

uint16_t	GncOptionDateValue::get_period_index () const noexcept

uint16_t	GncOptionDateValue::get_default_period_index () const noexcept

std::ostream &	GncOptionDateValue::out_stream (std::ostream &oss) const noexcept

std::istream &	GncOptionDateValue::in_stream (std::istream &iss)

bool	GncOptionDateValue::validate (RelativeDatePeriod value)

bool	GncOptionDateValue::validate (time64 time)

void	GncOptionDateValue::set_value (RelativeDatePeriod value)

void	GncOptionDateValue::set_value (time64 time)

void	GncOptionDateValue::set_value (uint16_t index) noexcept

void	GncOptionDateValue::set_default_value (RelativeDatePeriod value)

void	GncOptionDateValue::set_default_value (time64 time)

uint16_t	GncOptionDateValue::num_permissible_values () const noexcept

uint16_t	GncOptionDateValue::permissible_value_index (const char *key) const noexcept

const char *	GncOptionDateValue::permissible_value (uint16_t index) const

const char *	GncOptionDateValue::permissible_value_name (uint16_t index) const

void	GncOptionDateValue::reset_default_value ()

void	GncOptionDateValue::mark_saved () noexcept

bool	GncOptionDateValue::is_dirty () const noexcept

bool	GncOptionDateValue::is_changed () const noexcept

GncOptionUIType	GncOptionDateValue::get_ui_type () const noexcept

void	GncOptionDateValue::make_internal ()

bool	GncOptionDateValue::is_internal ()

const RelativeDatePeriodVec &	GncOptionDateValue::get_period_set () const

std::string	GncOptionDateValue::serialize () const noexcept

bool	GncOptionDateValue::deserialize (const std::string &str) noexcept

template<typename OptionType , typename std::enable_if_t< is_OptionClassifier_v< OptionType >, int > = 0>
	GncOption::GncOption (OptionType option)

template<typename ValueType , typename std::enable_if_t<!is_OptionClassifier_v< ValueType >, int > = 0>
	GncOption::GncOption (const char section, const char name, const char key, const char doc_string, ValueType value, GncOptionUIType ui_type=GncOptionUIType::INTERNAL)

template<typename ValueType >
void	GncOption::set_value (ValueType value)

template<typename ValueType >
void	GncOption::set_default_value (ValueType value)

template<typename ValueType >
ValueType	GncOption::get_default_value () const

template<typename ValueType >
ValueType	GncOption::get_value () const

void	GncOption::reset_default_value ()

const std::string &	GncOption::get_section () const

const std::string &	GncOption::get_name () const

const std::string &	GncOption::get_key () const

const std::string &	GncOption::get_docstring () const

void	GncOption::set_ui_item (GncOptionUIItemPtr &&ui_elem)

const GncOptionUIType	GncOption::get_ui_type () const

void	GncOption::set_ui_item_selectable (bool) const noexcept

GncOptionUIItem *const	GncOption::get_ui_item () const

void	GncOption::set_ui_item_from_option ()

void	GncOption::set_option_from_ui_item ()

void	GncOption::make_internal ()

bool	GncOption::is_internal ()

void	GncOption::mark_saved () noexcept
	Mark the option as needing to be saved. More...

bool	GncOption::is_dirty () const noexcept

bool	GncOption::is_changed () const noexcept

bool	GncOption::is_multiselect () const noexcept

template<typename ValueType >
void	GncOption::get_limits (ValueType &, ValueType &, ValueType &) const noexcept
	Implemented only for GncOptionNumericRange.

template<typename ValueType >
bool	GncOption::validate (ValueType value) const
	Not implemented for GncOptionValue. More...

uint16_t	GncOption::num_permissible_values () const
	Implemented only for GncOptionMultiselectValue. More...

uint16_t	GncOption::permissible_value_index (const char *value) const
	Implemented only for GncOptionMultiselectValue. More...

const char *	GncOption::permissible_value (uint16_t index) const
	Implemented only for GncOptionMultiselectValue. More...

const char *	GncOption::permissible_value_name (uint16_t index) const
	Implemented only for GncOptionMultiselectValue. More...

GList *	GncOption::account_type_list () const noexcept
	Implemented only for GncOptionAccountListValue. More...

bool	GncOption::is_alternate () const noexcept

void	GncOption::set_alternate (bool) noexcept

std::string	GncOption::serialize () const
	Get a string suitable for storage representing the option's value. More...

bool	GncOption::deserialize (const std::string &str)
	Set the option's value from a character sequence. More...

std::istream &	GncOption::in_stream (std::istream &iss)
	Set the option's value from an input stream. More...

void	GncOption::set_widget_changed (std::any cb)

std::any &	GncOption::get_widget_changed ()

	GncOptionSection::GncOptionSection (const char *name)

void	GncOptionSection::foreach_option (std::function< void(GncOption &)> func)

void	GncOptionSection::foreach_option (std::function< void(const GncOption &)> func) const

const std::string &	GncOptionSection::get_name () const noexcept

size_t	GncOptionSection::get_num_options () const noexcept

void	GncOptionSection::add_option (GncOption &&option)

void	GncOptionSection::remove_option (const char *name)

const GncOption *	GncOptionSection::find_option (const char *name) const

	GncOptionDBCallback::GncOptionDBCallback (size_t id, GncOptionDBChangeCallback func, void *data)

	GncOptionDBCallback::GncOptionDBCallback (const GncOptionDBCallback &)=delete

	GncOptionDBCallback::GncOptionDBCallback (GncOptionDBCallback &&)=default

GncOptionDBCallback &	GncOptionDBCallback::operator= (const GncOptionDBCallback &)=default

GncOptionDBCallback &	GncOptionDBCallback::operator= (GncOptionDBCallback &&)=default

	GncOptionDB::GncOptionDB (QofBook *book)

void	GncOptionDB::foreach_section (std::function< void(GncOptionSectionPtr &)> func)

void	GncOptionDB::foreach_section (std::function< void(const GncOptionSectionPtr &)> func) const

size_t	GncOptionDB::num_sections () const noexcept

bool	GncOptionDB::get_changed () const noexcept

void	GncOptionDB::register_option (const char *section, GncOption &&option)

void	GncOptionDB::register_option (const char section, GncOption option)

void	GncOptionDB::unregister_option (const char section, const char name)

void	GncOptionDB::set_default_section (const char *section)

const GncOptionSection *const	GncOptionDB::get_default_section () const noexcept

std::string	GncOptionDB::lookup_string_option (const char section, const char name)

bool	GncOptionDB::set_string_option (const char section, const char name, const std::string &value)

template<typename ValueType >
bool	GncOptionDB::set_option (const char section, const char name, ValueType value)

void	GncOptionDB::make_internal (const char section, const char name)

void	GncOptionDB::commit ()

GncOptionSection *	GncOptionDB::find_section (const std::string &sectname)

const GncOptionSection *	GncOptionDB::find_section (const std::string &sectname) const

GncOption *	GncOptionDB::find_option (const std::string &section, const char *name)

const GncOption *	GncOptionDB::find_option (const std::string &section, const char *name) const

std::ostream &	GncOptionDB::save_to_key_value (std::ostream &oss) const noexcept

std::istream &	GncOptionDB::load_from_key_value (std::istream &iss)

void	GncOptionDB::save_to_kvp (QofBook *book, bool clear_book) const noexcept

void	GncOptionDB::load_from_kvp (QofBook *book) noexcept

std::ostream &	GncOptionDB::save_option_key_value (std::ostream &oss, const std::string &section, const std::string &name) const noexcept

std::istream &	GncOptionDB::load_option_key_value (std::istream &iss)

size_t	GncOptionDB::register_callback (GncOptionDBChangeCallback, void *)

void	GncOptionDB::unregister_callback (size_t)

void	GncOptionDB::run_callbacks ()

Variables
std::string	OptionClassifier::m_section

std::string	OptionClassifier::m_name

std::string	OptionClassifier::m_sort_tag

std::string	OptionClassifier::m_doc_string

static constexpr bool	is_GncOwnerValue< T >::value

static constexpr bool	is_QofInstanceValue< T >::value

static constexpr bool	is_QofQueryValue< T >::value

static constexpr bool	is_OptionClassifier< T >::value

static constexpr bool	is_same_decayed< T, U >::value

static constexpr bool	is_RangeValue< T >::value

size_t	GncOptionDBCallback::m_id

GncOptionDBChangeCallback	GncOptionDBCallback::m_func

void *	GncOptionDBCallback::m_data

Friends
GncOptionVariant &	GncOption::swig_get_option (GncOption *)

Lookup Accounts and Subaccounts by name or code
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. More...

Account *	gnc_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.

Account *	gnc_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.

Account *	gnc_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
SplitList *	xaccAccountGetSplitList (const Account *account)
	The xaccAccountGetSplitList() routine returns a pointer to a GList of the splits in the account. More...

size_t	xaccAccountGetSplitsSize (const Account *account)

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 )

LotList *	xaccAccountGetLotList (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...

LotList *	xaccAccountFindOpenLots (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 Balance Limits
gboolean	xaccAccountGetHigherBalanceLimit (const Account account, gnc_numeric balance)
	Get the higher balance limit for the account. More...

void	xaccAccountSetHigherBalanceLimit (Account *account, gnc_numeric balance)
	Set the higher balance limit for the account. More...

void	xaccAccountClearHigherBalanceLimit (Account *account)
	Clear the higher balance limit for the account. More...

gboolean	xaccAccountGetLowerBalanceLimit (const Account account, gnc_numeric balance)
	Get the lower balance limit for the account. More...

void	xaccAccountSetLowerBalanceLimit (Account *account, gnc_numeric balance)
	Set the lower balance limit for the account. More...

void	xaccAccountClearLowerBalanceLimit (Account *account)
	Clear the lower balance limit for the account. More...

gboolean	xaccAccountGetIncludeSubAccountBalances (const Account *account)
	Get whether to include balances of sub accounts. More...

void	xaccAccountSetIncludeSubAccountBalances (Account *account, gboolean include)
	Set whether to include balances of sub accounts. More...

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

Account Append Text flag
gboolean	xaccAccountGetAppendText (const Account *account)
	Get the "import-append-text" flag for an account. More...

void	xaccAccountSetAppendText (Account *account, gboolean val)
	Set the "import-append-text" 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	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...

Account *	gnc_account_imap_find_account (Account acc, const char category, const char *key)

Account *	gnc_account_imap_find_any (QofBook book, const char category, const char *key)

void	gnc_account_imap_add_account (Account acc, const char category, const char key, Account added_acc)

void	gnc_account_imap_delete_account (Account acc, const char category, const char *key)

Account *	gnc_account_imap_find_account_bayes (Account acc, GList tokens)
	Look up an Account in the map using Baysian. More...

void	gnc_account_imap_add_account_bayes (Account acc, GList tokens, Account *added_acc)
	Updates the imap for a given account using a list of tokens.

void	gnc_account_imap_info_destroy (GncImapInfo *)
	Clean destructor for the imap_info structure of Bayesian mappings.

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 1721 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 91 of file gnc-engine.h.

◆ xaccAccountInsertSplit

#define xaccAccountInsertSplit	(	acc,
		s
	)	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 1048 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 221 of file gnc-engine.h.

Function Documentation

◆ account_type_list() [1/3]

GList * GncOption::account_type_list ( ) const

noexcept

Implemented only for GncOptionAccountListValue.

Definition at line 414 of file gnc-option.cpp.

 {
     return std::visit([] (const auto& option) -> GList* {
                           if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
                                         GncOptionAccountListValue>)
                               return option.account_type_list();
                           else
                               return nullptr;
                       }, *m_option);
 }

◆ account_type_list() [2/3]

GList * GncOptionAccountListValue::account_type_list ( ) const

noexcept

Create a GList of account types to pass to gnc_account_sel_set_acct_filters.

gnc_account_sel_set_acct_filters copies the list so the intermediary caller is responsible for freeing the list.

Returns: an allocated GList* or nullptr if the list is empty.

Definition at line 462 of file gnc-option-impl.cpp.

 {
     if (m_allowed.empty())
         return nullptr;
     GList* retval{nullptr};
     for (auto type : m_allowed)
         retval = g_list_prepend(retval, GINT_TO_POINTER(type));
     return g_list_reverse(retval);
 }

◆ account_type_list() [3/3]

GList * GncOptionAccountSelValue::account_type_list ( ) const

noexcept

Create a GList of account types to pass to gnc_account_sel_set_acct_filters.

gnc_account_sel_set_acct_filters copies the list so the intermediary caller is responsible for freeing the list.

Returns: an allocated GList* or nullptr if the list is empty.

Definition at line 533 of file gnc-option-impl.cpp.

 {
     if (m_allowed.empty())
         return nullptr;
     GList* retval{nullptr};
     for (auto type : m_allowed)
         retval = g_list_prepend(retval, GINT_TO_POINTER(type));
     return g_list_reverse(retval);
 }

◆ deserialize()

bool GncOption::deserialize ( const std::string & str )

Set the option's value from a character sequence.

Parameters

str	The character sequence representing the value

Returns: true if the value was set, false otherwise.

Definition at line 455 of file gnc-option.cpp.

 {
     return std::visit([&str](auto& option) -> bool {
                           return option.deserialize(str);
                       }, *m_option);
 }

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

 {
     GValue v = G_VALUE_INIT;
     const char *s = nullptr;
     gnc_commodity_table *table;
     gnc_commodity *retval = nullptr;
 
     if (!acc) return nullptr;
     qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {"old-currency"});
     if (G_VALUE_HOLDS_STRING (&v))
         s = g_value_get_string (&v);
     if (s)
     {
         table = gnc_commodity_table_get_table (qof_instance_get_book(acc));
         retval = gnc_commodity_table_lookup_unique (table, s);
     }
     g_value_unset (&v);
 
     return retval;
 }

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

 {
     if (!acc) return nullptr;
     if (!xaccAccountIsPriced(acc)) return nullptr;
     GValue v = G_VALUE_INIT;
     auto rv = get_kvp_string_tag (acc, "old-quote-tz", &v);
     g_value_unset (&v);
     return rv;
 }

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

 {
     QofBook *book;
     GValue v = G_VALUE_INIT;
     const char *s = gnc_commodity_get_unique_name (currency);
     gnc_commodity *commodity;
     gnc_commodity_table *table;
 
     if ((!acc) || (!currency)) return;
     g_value_init (&v, G_TYPE_STRING);
     g_value_set_static_string (&v, s);
     qof_instance_set_path_kvp (QOF_INSTANCE (acc), &v, {"old-currency"});
     mark_account (acc);
     xaccAccountCommitEdit(acc);
     g_value_unset (&v);
 
     table = gnc_commodity_table_get_table (qof_instance_get_book(acc));
     commodity = gnc_commodity_table_lookup_unique (table, s);
 
     if (!commodity)
     {
         book = qof_instance_get_book(acc);
         gnc_commodity_table_insert (gnc_commodity_table_get_table (book),
                     currency);
     }
 }

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

 {
     if (!acc) return;
     if (!xaccAccountIsPriced(acc)) return;
     set_kvp_string_tag (acc, "old-quote-tz", tz);
 }

◆ gnc_account_imap_find_account_bayes()

Account* gnc_account_imap_find_account_bayes	(	Account *	acc,
		GList *	tokens
	)

Look up an Account in the map using Baysian.

Definition at line 5996 of file Account.cpp.

 {
     if (!acc)
         return nullptr;
     auto book = gnc_account_get_book(acc);
     check_import_map_data (book);
     auto first_pass = get_first_pass_probabilities(acc, tokens);
     if (!first_pass.size())
         return nullptr;
     auto final_probabilities = build_probabilities(first_pass);
     if (!final_probabilities.size())
         return nullptr;
     auto best = highest_probability(final_probabilities);
     if (best.account_guid == "")
         return nullptr;
     if (best.probability < threshold)
         return nullptr;
     gnc::GUID guid;
     try {
         guid = gnc::GUID::from_string(best.account_guid);
     } catch (gnc::guid_syntax_exception&) {
         return nullptr;
     }
     auto account = xaccAccountLookup (reinterpret_cast<GncGUID*>(&guid), book);
     return account;
 }

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

 {
     return (Account*)account_foreach_descendant_breadthfirst_until (parent, is_acct_name, (char*)name);
 }

◆ 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

account	The account of which the sought-for account is a descendant.
commodity	The 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 3096 of file Account.cpp.

 {
     return (Account *)gnc_account_foreach_descendant_until (account, is_opening_balance_account, commodity);
 }

◆ 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

root	The account among whose children one expects to find the account.
name	The name of the account to look for or nullptr.
acctype	The GNCAccountType to match.
commodity	The commodity in which the account should be denominated or nullptr.

Returns: A GList of children matching the supplied parameters.

Definition at line 3173 of file Account.cpp.

 {
     GList *retval{};
     auto rpriv{GET_PRIVATE(root)};
     for (auto node = rpriv->children; node; node = node->next)
     {
         auto account{static_cast<Account*>(node->data)};
         if (xaccAccountGetType (account) == acctype)
         {
             if (commodity &&
                 !gnc_commodity_equiv(xaccAccountGetCommodity (account),
                                      commodity))
                 continue;
 
             if (name && strcmp(name, xaccAccountGetName(account)))
                 continue;
 
             retval = g_list_prepend(retval, account);
         }
     }
 
     if (!retval) // Recurse through the children
         for (auto node = rpriv->children; node; node = node->next)
         {
             auto account{static_cast<Account*>(node->data)};
             auto result = gnc_account_lookup_by_type_and_commodity(account,
                                                                    name,
                                                                    acctype,
                                                                    commodity);
             if (result)
                 retval = g_list_concat(result, retval);
         }
     return retval;
 }

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

 {
     GList *descendants;
 
     descendants = gnc_account_get_descendants(account);
     g_list_foreach(descendants, (GFunc)do_one_account, nullptr);
     g_list_free(descendants);
 }

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

 {
     const AccountPrivate *priv;
     Transaction *trans;
     int retval;
 
     if (!acc) return 0;
 
     /* depth first traversal */
     priv = GET_PRIVATE(acc);
     for (auto acc_p = priv->children; acc_p; acc_p = g_list_next(acc_p))
     {
         retval = gnc_account_tree_staged_transaction_traversal(static_cast <Account*> (acc_p->data),
                 stage, thunk, cb_data);
         if (retval) return retval;
     }
 
     /* Now this account */
     for (auto s : priv->splits)
     {
         trans = s->parent;
         if (trans && (trans->marker < stage))
         {
             trans->marker = stage;
             if (thunk)
             {
                 retval = thunk(trans, cb_data);
                 if (retval) return retval;
             }
         }
     }
 
     return 0;
 }

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

 {
     if (1 == engine_is_initialized) return;
 
     gnc_engine_init_part1();
     gnc_engine_init_part2();
     gnc_engine_init_part3(argc, argv);
 }

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

 {
     if (1 == engine_is_initialized) return;
 
     gnc_engine_init_part1();
     gnc_engine_init_part3(argc, argv);
 }

◆ gnc_engine_shutdown()

void gnc_engine_shutdown ( void )

Called to shutdown the engine.

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

 {
     qof_log_shutdown();
     qof_close();
     engine_is_initialized = 0;
 }

◆ in_stream()

std::istream & GncOption::in_stream ( std::istream & iss )

Set the option's value from an input stream.

Parameters

iss	An input stream reference.

Returns: the stream reference for chaining.

Definition at line 463 of file gnc-option.cpp.

 {
     return std::visit([&iss](auto& option) -> std::istream& {
                           iss >> option;
                           return iss;
                       }, *m_option);
 }

◆ is_changed()

bool GncOption::is_changed ( ) const

noexcept

Returns: true if the option value differs from its default value.

Definition at line 314 of file gnc-option.cpp.

 {
     return std::visit([](const auto& option)->bool {
                           return option.is_changed();
                       }, *m_option);
 }

◆ is_dirty()

bool GncOption::is_dirty ( ) const

noexcept

Returns: true if the option has been marked as needing to be saved.

Definition at line 306 of file gnc-option.cpp.

 {
     return std::visit([](const auto& option)->bool {
                           return option.is_dirty();
                       }, *m_option);
 }

◆ is_multiselect()

bool GncOption::is_multiselect ( ) const

noexcept

Returns: false unless m_option contains a GncOptionMultiselectValue or GncOptionAccountListValue for which multiple selections have been enabled.

Definition at line 322 of file gnc-option.cpp.

 {
     return std::visit(
         [](const auto& option)->bool {
             if constexpr (is_same_decayed_v<decltype(option),
                           GncOptionAccountListValue>)
                 return option.is_multiselect();
             else
                 return false;
         }, *m_option);
 }

◆ mark_saved()

void GncOption::mark_saved ( )

noexcept

Mark the option as needing to be saved.

Definition at line 298 of file gnc-option.cpp.

 {
     std::visit([](auto& option)->void {
                           option.mark_saved();
                       }, *m_option);
 }

◆ num_permissible_values()

std::uint16_t GncOption::num_permissible_values ( ) const

Implemented only for GncOptionMultiselectValue.

Definition at line 356 of file gnc-option.cpp.

 {
     return std::visit(
         [] (const auto& option) -> uint16_t {
             if constexpr (is_same_decayed_v<decltype(option),
                           GncOptionMultichoiceValue>  ||
                           is_same_decayed_v<decltype(option),
                           GncOptionDateValue>)
                 return option.num_permissible_values();
             else
                 return uint16_t_max;
         }, *m_option);
 }

◆ permissible_value()

const char * GncOption::permissible_value ( uint16_t index ) const

Implemented only for GncOptionMultiselectValue.

Definition at line 386 of file gnc-option.cpp.

 {
     return std::visit([index] (const auto& option) -> const char* {
                           if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
                                         GncOptionMultichoiceValue>  ||
                                         std::is_same_v<std::decay_t<decltype(option)>,
                                         GncOptionDateValue>)
                                            return option.permissible_value(index);
                           else
                               return "";
                       }, *m_option);
 }

◆ permissible_value_index()

std::uint16_t GncOption::permissible_value_index ( const char * value ) const

Implemented only for GncOptionMultiselectValue.

Definition at line 371 of file gnc-option.cpp.

 {
     return std::visit(
         [&value] (const auto& option) -> uint16_t {
             if constexpr (is_same_decayed_v<decltype(option),
                                             GncOptionMultichoiceValue> ||
                           is_same_decayed_v<decltype(option),
                                             GncOptionDateValue>)
                 return option.permissible_value_index(value);
             else
                 return uint16_t_max;
         }, *m_option);
 }

◆ permissible_value_name()

const char * GncOption::permissible_value_name ( uint16_t index ) const

Implemented only for GncOptionMultiselectValue.

Definition at line 400 of file gnc-option.cpp.

 {
     return std::visit([index] (const auto& option) -> const char* {
                           if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
                                         GncOptionMultichoiceValue>  ||
                                         std::is_same_v<std::decay_t<decltype(option)>,
                                         GncOptionDateValue>)
                                            return option.permissible_value_name(index);
                           else
                               return "";
                       }, *m_option);
 }

◆ serialize()

std::string GncOption::serialize ( ) const

Get a string suitable for storage representing the option's value.

Returns: a std::string

Definition at line 445 of file gnc-option.cpp.

 {
     if (m_option->valueless_by_exception())
         return "Valueless Option";
     return std::visit([&](auto& option) -> std::string {
                           return option.serialize();
                       }, *m_option);
 }

◆ validate()

template<typename ValueType >

template bool GncOption::validate ( ValueType value ) const

Not implemented for GncOptionValue.

Definition at line 335 of file gnc-option.cpp.

 {
     return std::visit(
         [value] (const auto& option) -> bool {
             if constexpr ((is_same_decayed_v<decltype(option),
                                              GncOptionMultichoiceValue> &&
                            is_same_decayed_v<ValueType, std::string>) ||
                           (is_same_decayed_v<decltype(option),
                                              GncOptionMultichoiceValue> &&
                            is_same_decayed_v<ValueType,
                                              GncMultichoiceOptionIndexVec>) ||
                           (is_same_decayed_v<decltype(option),
                                              GncOptionCommodityValue> &&
                            is_same_decayed_v<ValueType, gnc_commodity*>))
                 return option.validate(value);
             else
                 return false;
         }, *m_option);
 }

◆ xaccAccountClearHigherBalanceLimit()

void xaccAccountClearHigherBalanceLimit ( Account * account )

Clear the higher balance limit for the account.

Parameters

account The account to clear the limit on

Definition at line 5107 of file Account.cpp.

 {
     g_return_if_fail (GNC_IS_ACCOUNT(acc));
 
     clear_balance_limits (acc, true);
 }

◆ xaccAccountClearLowerBalanceLimit()

void xaccAccountClearLowerBalanceLimit ( Account * account )

Clear the lower balance limit for the account.

Parameters

account The account to clear the limit on

Definition at line 5115 of file Account.cpp.

 {
     g_return_if_fail (GNC_IS_ACCOUNT(acc));
 
     clear_balance_limits (acc, false);
 }

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

 {
     AccountPrivate *priv;
     GList *lot_list;
     GList *retval = nullptr;
 
     g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
 
     priv = GET_PRIVATE(acc);
     for (lot_list = priv->lots; lot_list; lot_list = lot_list->next)
     {
         GNCLot *lot = static_cast<GNCLot*>(lot_list->data);
 
         /* If this lot is closed, then ignore it */
         if (gnc_lot_is_closed (lot))
             continue;
 
         if (match_func && !(match_func)(lot, user_data))
             continue;
 
         /* Ok, this is a valid lot.  Add it to our list of lots */
         retval = g_list_prepend (retval, lot);
     }
 
     if (sort_func)
         retval = g_list_sort (retval, sort_func);
 
     return retval;
 }

◆ xaccAccountFindSplitByDesc()

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

Returns a pointer to the split, not a copy.

Definition at line 5349 of file Account.cpp.

 {
     auto has_description = [description](const Split* s) -> bool
     { return !g_strcmp0 (description, xaccTransGetDescription (xaccSplitGetParent (s))); };
     return gnc_account_find_split (acc, has_description, true);
 }

◆ xaccAccountFindTransByDesc()

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

Returns a pointer to the transaction, not a copy.

Definition at line 5362 of file Account.cpp.

 {
     auto split = xaccAccountFindSplitByDesc (acc, description);
     return split ? xaccSplitGetParent (split) : nullptr;
 }

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

 {
     if (!acc || !proc) return 0;
     xaccAccountBeginStagedTransactionTraversals (acc);
     return xaccAccountStagedTransactionTraversal(acc, 42, proc, data);
 }

◆ xaccAccountGetAppendText()

gboolean xaccAccountGetAppendText ( const Account * account )

Get the "import-append-text" flag for an account.

This is the saved state of the Append checkbox in the "Generic import transaction matcher" used to set the initial state of the Append checkbox next time this account is imported.

Parameters

account The account whose flag should be retrieved.

Returns: The current state of the account's "import-append-text" flag.

Definition at line 4247 of file Account.cpp.

 {
     return boolean_from_key(acc, {"import-append-text"});
 }

◆ 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

acc	The account whose flag should be retrieved.

Returns: The current state of the account's "auto interest" flag.

Definition at line 4304 of file Account.cpp.

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

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

 {
     GList *descendants, *node;
     GNCPlaceholderType ret = PLACEHOLDER_NONE;
 
     g_return_val_if_fail(GNC_IS_ACCOUNT(acc), PLACEHOLDER_NONE);
     if (xaccAccountGetPlaceholder(acc)) return PLACEHOLDER_THIS;
 
     descendants = gnc_account_get_descendants(acc);
     for (node = descendants; node; node = node->next)
         if (xaccAccountGetPlaceholder((Account *) node->data))
         {
             ret = PLACEHOLDER_CHILD;
             break;
         }
 
     g_list_free(descendants);
     return ret;
 }

◆ 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

acc	The account whose flag should be retrieved.

Returns: The current state of the account's "hidden" flag.

Definition at line 4319 of file Account.cpp.

 {
     return boolean_from_key (acc, {"hidden"});
 }

◆ xaccAccountGetHigherBalanceLimit()

gboolean xaccAccountGetHigherBalanceLimit	(	const Account *	account,
		gnc_numeric *	balance
	)

Get the higher balance limit for the account.

Parameters

account	The account whose higher limit is to be retrieved
balance	The placeholder to store the retrieved balance

Returns: True if the limit is valid.

Definition at line 4931 of file Account.cpp.

 {
     g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
 
     if (GET_PRIVATE(acc)->higher_balance_limit.has_value())
     {
         *balance = GET_PRIVATE(acc)->higher_balance_limit.value();
 
         if (gnc_numeric_check (*balance) == 0)
             return true;
         else
             return false;
     }
     else
     {
         gnc_numeric bal = gnc_numeric_create (1,0);
         GValue v = G_VALUE_INIT;
         gboolean retval = false;
 
         qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {KEY_BALANCE_LIMIT,
                                                            KEY_BALANCE_HIGHER_LIMIT_VALUE});
         if (G_VALUE_HOLDS_BOXED(&v))
         {
             bal = *(gnc_numeric*)g_value_get_boxed (&v);
             if (bal.denom)
             {
                 if (balance)
                    *balance = bal;
                 retval = true;
             }
         }
         g_value_unset (&v);
 
         GET_PRIVATE(acc)->higher_balance_limit = bal;
         return retval;
     }
 }

◆ xaccAccountGetIncludeSubAccountBalances()

gboolean xaccAccountGetIncludeSubAccountBalances ( const Account * account )

Get whether to include balances of sub accounts.

Parameters

account The account to get setting on

Returns: TRUE to include, default is FALSE

Definition at line 5123 of file Account.cpp.

 {
     g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
 
     if (!GET_PRIVATE(acc)->include_sub_account_balances.has_value())
     {
         gboolean inc_sub = boolean_from_key (acc, {KEY_BALANCE_LIMIT,
                                                    KEY_BALANCE_INCLUDE_SUB_ACCTS});
 
         GET_PRIVATE(acc)->include_sub_account_balances = inc_sub;
     }
     return GET_PRIVATE(acc)->include_sub_account_balances.value();
 }

◆ 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

account The account whose flag should be retrieved.

Returns: The current state of the account's "opening-balance" flag.

Definition at line 4259 of file Account.cpp.

 {
     if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
         return false;
 
     GValue v = G_VALUE_INIT;
     auto rv = !g_strcmp0 (get_kvp_string_tag (acc, "equity-type", &v),
                           "opening-balance");
     g_value_unset (&v);
     return rv;
 }

◆ xaccAccountGetLotList()

LotList* xaccAccountGetLotList ( const Account * account )

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

Parameters

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

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

◆ xaccAccountGetLowerBalanceLimit()

gboolean xaccAccountGetLowerBalanceLimit	(	const Account *	account,
		gnc_numeric *	balance
	)

Get the lower balance limit for the account.

Parameters

account	The account whose lower limit is to be retrieved
balance	The placeholder to store the retrieved balance

Returns: True if the limit is valid.

Definition at line 4971 of file Account.cpp.

 {
     g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
 
     if (GET_PRIVATE(acc)->lower_balance_limit.has_value())
     {
         *balance = GET_PRIVATE(acc)->lower_balance_limit.value();
 
         if (gnc_numeric_check (*balance) == 0)
             return true;
         else
             return false;
     }
     else
     {
         gnc_numeric bal = gnc_numeric_create (1,0);
         GValue v = G_VALUE_INIT;
         gboolean retval = false;
 
         qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {KEY_BALANCE_LIMIT,
                                                            KEY_BALANCE_LOWER_LIMIT_VALUE});
         if (G_VALUE_HOLDS_BOXED(&v))
         {
             bal = *(gnc_numeric*)g_value_get_boxed (&v);
             if (bal.denom)
             {
                 if (balance)
                    *balance = bal;
                 retval = true;
             }
         }
         g_value_unset (&v);
 
         GET_PRIVATE(acc)->lower_balance_limit = bal;
         return retval;
     }
 }

◆ 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

account The account whose flag should be retrieved.

Returns: The current state of the account's "placeholder" flag.

Definition at line 4235 of file Account.cpp.

 {
     return boolean_from_key(acc, {"placeholder"});
 }

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

 {
     g_return_val_if_fail(GNC_IS_ACCOUNT(acc), nullptr);
     auto priv{GET_PRIVATE(acc)};
     return std::accumulate (priv->splits.rbegin(), priv->splits.rend(),
                             static_cast<GList*>(nullptr), g_list_prepend);
 }

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

 {
     if (type < 0 || NUM_ACCOUNT_TYPES <= type ) return "";
     return _(account_type_name [type]);
 }

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

 {
     AccountPrivate *priv, *opriv;
     Account * old_acc = nullptr;
     Account* lot_account;
 
     /* errors */
     g_return_if_fail(GNC_IS_ACCOUNT(acc));
     g_return_if_fail(GNC_IS_LOT(lot));
 
     /* optimizations */
     lot_account = gnc_lot_get_account(lot);
     if (lot_account == acc)
         return;
 
     ENTER ("(acc=%p, lot=%p)", acc, lot);
 
     /* pull it out of the old account */
     if (lot_account)
     {
         old_acc = lot_account;
         opriv = GET_PRIVATE(old_acc);
         opriv->lots = g_list_remove(opriv->lots, lot);
     }
 
     priv = GET_PRIVATE(acc);
     priv->lots = g_list_prepend(priv->lots, lot);
     gnc_lot_set_account(lot, acc);
 
     /* Don't move the splits to the new account.  The caller will do this
      * if appropriate, and doing it here will not work if we are being
      * called from gnc_book_close_period since xaccAccountInsertSplit
      * will try to balance capital gains and things aren't ready for that. */
 
     qof_event_gen (QOF_INSTANCE(lot), QOF_EVENT_ADD, nullptr);
     qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, nullptr);
 
     LEAVE ("(acc=%p, lot=%p)", acc, lot);
 }

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

 {
     switch (t)
     {
     case ACCT_TYPE_RECEIVABLE:
     case ACCT_TYPE_PAYABLE:
         return TRUE;
     default:
         return FALSE;
     }
 }

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

 {
     switch (t)
     {
     case ACCT_TYPE_RECEIVABLE:
     case ACCT_TYPE_PAYABLE:
         return FALSE;
     default:
         return (xaccAccountTypesCompatible(ACCT_TYPE_ASSET, t)
                 || xaccAccountTypesCompatible(ACCT_TYPE_LIABILITY, t));
     }
 }

◆ xaccAccountIsEquityType()

gboolean xaccAccountIsEquityType ( GNCAccountType t )

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

Definition at line 4668 of file Account.cpp.

 {
     switch (t)
     {
     case ACCT_TYPE_EQUITY:
         return TRUE;
     default:
         return FALSE;
     }
 }

◆ 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

acc	The account whose flag should be retrieved.

Returns: Whether or not this account should be "hidden".

Definition at line 4331 of file Account.cpp.

 {
     AccountPrivate *priv;
 
     g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
 
     if (xaccAccountGetHidden(acc))
         return TRUE;
     priv = GET_PRIVATE(acc);
     while ((acc = priv->parent) != nullptr)
     {
         priv = GET_PRIVATE(acc);
         if (xaccAccountGetHidden(acc))
             return TRUE;
     }
     return FALSE;
 }

◆ xaccAccountMoveAllSplits()

void xaccAccountMoveAllSplits	(	Account *	accfrom,
		Account *	accto
	)

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

Definition at line 2199 of file Account.cpp.

 {
     AccountPrivate *from_priv;
 
     /* errors */
     g_return_if_fail(GNC_IS_ACCOUNT(accfrom));
     g_return_if_fail(GNC_IS_ACCOUNT(accto));
 
     /* optimizations */
     from_priv = GET_PRIVATE(accfrom);
     if (from_priv->splits.empty() || accfrom == accto)
         return;
 
     /* check for book mix-up */
     g_return_if_fail (qof_instance_books_equal(accfrom, accto));
     ENTER ("(accfrom=%p, accto=%p)", accfrom, accto);
 
     xaccAccountBeginEdit(accfrom);
     xaccAccountBeginEdit(accto);
     /* Begin editing both accounts and all transactions in accfrom. */
     std::for_each (from_priv->splits.begin(), from_priv->splits.end(), xaccPreSplitMove);
 
     /* Concatenate accfrom's lists of splits and lots to accto's lists. */
     //to_priv->splits = g_list_concat(to_priv->splits, from_priv->splits);
     //to_priv->lots = g_list_concat(to_priv->lots, from_priv->lots);
 
     /* Set appropriate flags. */
     //from_priv->balance_dirty = TRUE;
     //from_priv->sort_dirty = FALSE;
     //to_priv->balance_dirty = TRUE;
     //to_priv->sort_dirty = TRUE;
 
     /*
      * Change each split's account back pointer to accto.
      * Convert each split's amount to accto's commodity.
      * Commit to editing each transaction.
      */
     std::for_each (from_priv->splits.begin(), from_priv->splits.end(),
                    [accto](Split *s){ xaccPostSplitMove (s, accto); });
 
     /* Finally empty accfrom. */
     g_assert(from_priv->splits.empty());
     g_assert(from_priv->lots == nullptr);
     xaccAccountCommitEdit(accfrom);
     xaccAccountCommitEdit(accto);
 
     LEAVE ("(accfrom=%p, accto=%p)", accfrom, accto);
 }

◆ xaccAccountSetAppendText()

void xaccAccountSetAppendText	(	Account *	account,
		gboolean	val
	)

Set the "import-append-text" flag for an account.

This is the saved state of the Append checkbox in the "Generic import transaction matcher" used to set the initial state of the Append checkbox next time this account is imported.

Parameters

account	The account whose flag should be retrieved.
val	The new state for the account's "import-append-text" flag.

Definition at line 4253 of file Account.cpp.

 {
     set_boolean_key(acc, {"import-append-text"}, val);
 }

◆ 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

acc	The account whose flag should be retrieved.
val	The new state for the account's "auto interest" flag.

Definition at line 4310 of file Account.cpp.

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

◆ 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

acc	The account whose flag should be retrieved.
val	The new state for the account's "hidden" flag.

Definition at line 4325 of file Account.cpp.

 {
     set_boolean_key (acc, {"hidden"}, val);
 }

◆ xaccAccountSetHigherBalanceLimit()

void xaccAccountSetHigherBalanceLimit	(	Account *	account,
		gnc_numeric	balance
	)

Set the higher balance limit for the account.

Parameters

account	The account whose higher limit is to be saved
balance	The balance to be saved

Definition at line 5052 of file Account.cpp.

 {
     g_return_if_fail (GNC_IS_ACCOUNT(acc));
 
     if (gnc_numeric_check (balance) != 0)
         return;
 
     set_balance_limits (acc, balance, true);
 }

◆ xaccAccountSetIncludeSubAccountBalances()

void xaccAccountSetIncludeSubAccountBalances	(	Account *	account,
		gboolean	include
	)

Set whether to include balances of sub accounts.

Parameters

account	The account to set the setting on
include	Set to TRUE for including sub account balances

Definition at line 5138 of file Account.cpp.

 {
     g_return_if_fail (GNC_IS_ACCOUNT(acc));
 
     if (inc_sub != xaccAccountGetIncludeSubAccountBalances (acc))
     {
         GValue v = G_VALUE_INIT;
         g_value_init (&v, G_TYPE_BOOLEAN);
         g_value_set_boolean (&v, inc_sub);
         std::vector<std::string> path {KEY_BALANCE_LIMIT,
                                        KEY_BALANCE_INCLUDE_SUB_ACCTS};
         xaccAccountBeginEdit (acc);
         if (inc_sub)
             qof_instance_set_path_kvp (QOF_INSTANCE(acc), &v, path);
         else
             qof_instance_set_path_kvp (QOF_INSTANCE(acc), nullptr, path);
         GET_PRIVATE(acc)->include_sub_account_balances = inc_sub;
         mark_account (acc);
         xaccAccountCommitEdit (acc);
         g_value_unset (&v);
     }
 }

◆ 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

account	The account whose flag should be set.
val	The new state for the account's "opening-balance" flag.

Definition at line 4272 of file Account.cpp.

 {
     if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
         return;
     set_kvp_string_tag(acc, "equity-type", val ? "opening-balance" : nullptr);
 }

◆ xaccAccountSetLowerBalanceLimit()

void xaccAccountSetLowerBalanceLimit	(	Account *	account,
		gnc_numeric	balance
	)

Set the lower balance limit for the account.

Parameters

account	The account whose lower limit is to be saved
balance	The balance to be saved

Definition at line 5063 of file Account.cpp.

 {
     g_return_if_fail (GNC_IS_ACCOUNT(acc));
 
     if (gnc_numeric_check (balance) != 0)
         return;
 
     set_balance_limits (acc, balance, false);
 }

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

 {
     AccountPrivate *priv;
 
     g_return_if_fail(GNC_IS_ACCOUNT(acc));
 
     priv = GET_PRIVATE(acc);
     priv->mark = m;
 }

◆ 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

account	The account whose flag should be retrieved.
val	The new state for the account's "placeholder" flag.

Definition at line 4241 of file Account.cpp.

 {
     set_boolean_key(acc, {"placeholder"}, val);
 }

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

 {
     if (!acc) return 0;
 
     auto splits = GET_PRIVATE(acc)->splits;
     for (auto s : splits)
     {
         auto trans = s->parent;
         if (trans && (trans->marker < stage))
         {
             trans->marker = stage;
             if (thunk)
             {
                 auto retval = thunk(trans, cb_data);
                 if (retval) return retval;
             }
         }
     }
 
     return 0;
 }

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

 {
     GNCAccountType type;
     gboolean rc;
     rc = xaccAccountStringToType(str, &type);
     if (FALSE == rc) return ACCT_TYPE_INVALID;
     return type;
 }

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

 {
 
     GNC_RETURN_ON_MATCH(NONE);
     GNC_RETURN_ON_MATCH(BANK);
     GNC_RETURN_ON_MATCH(CASH);
     GNC_RETURN_ON_MATCH(CREDIT);
     GNC_RETURN_ON_MATCH(ASSET);
     GNC_RETURN_ON_MATCH(LIABILITY);
     GNC_RETURN_ON_MATCH(STOCK);
     GNC_RETURN_ON_MATCH(MUTUAL);
     GNC_RETURN_ON_MATCH(CURRENCY);
     GNC_RETURN_ON_MATCH(INCOME);
     GNC_RETURN_ON_MATCH(EXPENSE);
     GNC_RETURN_ON_MATCH(EQUITY);
     GNC_RETURN_ON_MATCH(RECEIVABLE);
     GNC_RETURN_ON_MATCH(PAYABLE);
     GNC_RETURN_ON_MATCH(ROOT);
     GNC_RETURN_ON_MATCH(TRADING);
     GNC_RETURN_ON_MATCH(CHECKING);
     GNC_RETURN_ON_MATCH(SAVINGS);
     GNC_RETURN_ON_MATCH(MONEYMRKT);
     GNC_RETURN_ON_MATCH(CREDITLINE);
 
     PERR("asked to translate unknown account type string %s.\n",
          str ? str : "(null)");
 
     return(FALSE);
 }

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

 {
     switch (type)
     {
         GNC_RETURN_ENUM_AS_STRING(NONE);
         GNC_RETURN_ENUM_AS_STRING(BANK);
         GNC_RETURN_ENUM_AS_STRING(CASH);
         GNC_RETURN_ENUM_AS_STRING(CREDIT);
         GNC_RETURN_ENUM_AS_STRING(ASSET);
         GNC_RETURN_ENUM_AS_STRING(LIABILITY);
         GNC_RETURN_ENUM_AS_STRING(STOCK);
         GNC_RETURN_ENUM_AS_STRING(MUTUAL);
         GNC_RETURN_ENUM_AS_STRING(CURRENCY);
         GNC_RETURN_ENUM_AS_STRING(INCOME);
         GNC_RETURN_ENUM_AS_STRING(EXPENSE);
         GNC_RETURN_ENUM_AS_STRING(EQUITY);
         GNC_RETURN_ENUM_AS_STRING(RECEIVABLE);
         GNC_RETURN_ENUM_AS_STRING(PAYABLE);
         GNC_RETURN_ENUM_AS_STRING(ROOT);
         GNC_RETURN_ENUM_AS_STRING(TRADING);
         GNC_RETURN_ENUM_AS_STRING(CHECKING);
         GNC_RETURN_ENUM_AS_STRING(SAVINGS);
         GNC_RETURN_ENUM_AS_STRING(MONEYMRKT);
         GNC_RETURN_ENUM_AS_STRING(CREDITLINE);
     default:
         PERR ("asked to translate unknown account type %d.\n", type);
         break;
     }
     return(nullptr);
 }

◆ xaccAccountTypeGetFundamental()

GNCAccountType xaccAccountTypeGetFundamental ( GNCAccountType t )

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

Definition at line 4624 of file Account.cpp.

 {
     switch (t)
     {
         case ACCT_TYPE_BANK:
         case ACCT_TYPE_STOCK:
         case ACCT_TYPE_MONEYMRKT:
         case ACCT_TYPE_CHECKING:
         case ACCT_TYPE_SAVINGS:
         case ACCT_TYPE_MUTUAL:
         case ACCT_TYPE_CURRENCY:
         case ACCT_TYPE_CASH:
         case ACCT_TYPE_ASSET:
         case ACCT_TYPE_RECEIVABLE:
             return ACCT_TYPE_ASSET;
         case ACCT_TYPE_CREDIT:
         case ACCT_TYPE_LIABILITY:
         case ACCT_TYPE_PAYABLE:
         case ACCT_TYPE_CREDITLINE:
             return ACCT_TYPE_LIABILITY;
         case ACCT_TYPE_INCOME:
             return ACCT_TYPE_INCOME;
         case ACCT_TYPE_EXPENSE:
             return ACCT_TYPE_EXPENSE;
         case ACCT_TYPE_EQUITY:
             return ACCT_TYPE_EQUITY;
         case ACCT_TYPE_TRADING:
         default:
             return ACCT_TYPE_NONE;
     }
 }

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

 {
     /* ACCT_TYPE_NONE isn't compatible with anything, even ACCT_TYPE_NONE. */
     if (parent_type == ACCT_TYPE_NONE || child_type == ACCT_TYPE_NONE)
         return FALSE;
 
     /* ACCT_TYPE_ROOT can't have a parent account, and asking will raise
      * an error. */
     if (child_type == ACCT_TYPE_ROOT)
         return FALSE;
 
     return ((xaccParentAccountTypesCompatibleWith (child_type) &
              (1 << parent_type))
             != 0);
 }

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

 {
     switch (type)
     {
         case ACCT_TYPE_BANK:
         case ACCT_TYPE_CASH:
         case ACCT_TYPE_ASSET:
         case ACCT_TYPE_CREDIT:
         case ACCT_TYPE_LIABILITY:
         case ACCT_TYPE_INCOME:
         case ACCT_TYPE_EXPENSE:
         case ACCT_TYPE_EQUITY:
             return
             (1 << ACCT_TYPE_BANK)       |
             (1 << ACCT_TYPE_CASH)       |
             (1 << ACCT_TYPE_ASSET)      |
             (1 << ACCT_TYPE_CREDIT)     |
             (1 << ACCT_TYPE_LIABILITY)  |
             (1 << ACCT_TYPE_INCOME)     |
             (1 << ACCT_TYPE_EXPENSE)    |
             (1 << ACCT_TYPE_EQUITY);
         case ACCT_TYPE_STOCK:
         case ACCT_TYPE_MUTUAL:
         case ACCT_TYPE_CURRENCY:
             return
             (1 << ACCT_TYPE_STOCK)      |
             (1 << ACCT_TYPE_MUTUAL)     |
             (1 << ACCT_TYPE_CURRENCY);
         case ACCT_TYPE_RECEIVABLE:
             return (1 << ACCT_TYPE_RECEIVABLE);
         case ACCT_TYPE_PAYABLE:
             return (1 << ACCT_TYPE_PAYABLE);
         case ACCT_TYPE_TRADING:
             return (1 << ACCT_TYPE_TRADING);
         default:
             PERR("bad account type: %d", type);
             return 0;
     }
 }

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

 {
     guint32 mask = (1 << NUM_ACCOUNT_TYPES) - 1;
     mask &= ~((1 << ACCT_TYPE_CURRENCY) |  /* DEPRECATED */
               (1 << ACCT_TYPE_ROOT));      /* ROOT */
 
     return mask;
 }

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

 {
     Account *root;
 
     g_return_if_fail(GNC_IS_ACCOUNT(acc));
 
     root = gnc_account_get_root(acc);
     xaccClearMarkDown(root ? root : acc, val);
 }

◆ xaccClearMarkDown()

void xaccClearMarkDown	(	Account *	account,
		short	val
	)

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

Definition at line 2080 of file Account.cpp.

 {
     AccountPrivate *priv;
     GList *node;
 
     g_return_if_fail(GNC_IS_ACCOUNT(acc));
 
     priv = GET_PRIVATE(acc);
     priv->mark = val;
     for (node = priv->children; node; node = node->next)
     {
         xaccClearMarkDown(static_cast<Account*>(node->data), val);
     }
 }

◆ xaccParentAccountTypesCompatibleWith()

guint32 xaccParentAccountTypesCompatibleWith ( GNCAccountType type )

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

Definition at line 4536 of file Account.cpp.

 {
     switch (type)
     {
     case ACCT_TYPE_BANK:
     case ACCT_TYPE_CASH:
     case ACCT_TYPE_ASSET:
     case ACCT_TYPE_STOCK:
     case ACCT_TYPE_MUTUAL:
     case ACCT_TYPE_CURRENCY:
     case ACCT_TYPE_CREDIT:
     case ACCT_TYPE_LIABILITY:
     case ACCT_TYPE_RECEIVABLE:
     case ACCT_TYPE_PAYABLE:
         return
             (1 << ACCT_TYPE_BANK)       |
             (1 << ACCT_TYPE_CASH)       |
             (1 << ACCT_TYPE_ASSET)      |
             (1 << ACCT_TYPE_STOCK)      |
             (1 << ACCT_TYPE_MUTUAL)     |
             (1 << ACCT_TYPE_CURRENCY)   |
             (1 << ACCT_TYPE_CREDIT)     |
             (1 << ACCT_TYPE_LIABILITY)  |
             (1 << ACCT_TYPE_RECEIVABLE) |
             (1 << ACCT_TYPE_PAYABLE)    |
             (1 << ACCT_TYPE_ROOT);
     case ACCT_TYPE_INCOME:
     case ACCT_TYPE_EXPENSE:
         return
             (1 << ACCT_TYPE_INCOME)     |
             (1 << ACCT_TYPE_EXPENSE)    |
             (1 << ACCT_TYPE_ROOT);
     case ACCT_TYPE_EQUITY:
         return
             (1 << ACCT_TYPE_EQUITY)     |
             (1 << ACCT_TYPE_ROOT);
     case ACCT_TYPE_TRADING:
         return
             (1 << ACCT_TYPE_TRADING)    |
             (1 << ACCT_TYPE_ROOT);
     default:
         PERR("bad account type: %d", type);
         return 0;
     }
 }

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

 {
     if (trans == nullptr) return FALSE;
 
     if (trans->marker < stage)
     {
         trans->marker = stage;
         return TRUE;
     }
 
     return FALSE;
 }

Variable Documentation

◆ value [1/6]

template<typename T >

constexpr bool is_OptionClassifier< T >::value

static

Initial value:

=

std::is_base_of_v<OptionClassifier, std::decay_t<T>>

Definition at line 75 of file gnc-option.hpp.

◆ value [2/6]

template<typename T , typename U >

constexpr bool is_same_decayed< T, U >::value

static

Initial value:

= std::is_same_v<std::decay_t<T>,

std::decay_t<U>>

Definition at line 85 of file gnc-option.hpp.

◆ value [3/6]

template<typename T >

constexpr bool is_RangeValue< T >::value

static

Initial value:

=
         (is_same_decayed_v<T, GncOptionRangeValue<int>> ||
          is_same_decayed_v<T, GncOptionRangeValue<double>>)

Definition at line 95 of file gnc-option.hpp.

◆ value [4/6]

template<typename T >

constexpr bool is_GncOwnerValue< T >::value

static

Initial value:

=

std::is_same_v<std::decay_t<T>, GncOptionGncOwnerValue>

Definition at line 268 of file gnc-option-impl.hpp.

◆ value [5/6]

template<typename T >

constexpr bool is_QofInstanceValue< T >::value

static

Initial value:

=

std::is_same_v<std::decay_t<T>, GncOptionQofInstanceValue>

Definition at line 278 of file gnc-option-impl.hpp.

◆ value [6/6]

template<typename T >

constexpr bool is_QofQueryValue< T >::value

static

Initial value:

=

std::is_same_v<std::decay_t<T>, GncOptionValue<const QofQuery*>>

Definition at line 288 of file gnc-option-impl.hpp.

Modules

Files

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Friends

Lookup Accounts and Subaccounts by name or code

GNCAccountType conversion/checking

Account split/transaction list management

Account lots

Account Reconciliation information getters/setters

Account Balance Limits

Account Placeholder flag

Account Append Text flag

Account Hidden flag

Account Auto Interest flag

Account Tax related getters/setters

Account type debit/credit string getters

Account marking

Staged Traversal

Deprecated Routines.

Account parameter names

QofLogModule identifiers

Detailed Description

Macro Definition Documentation

◆ ACCOUNT_MATCH_ALL_TYPE

◆ GNC_ID_NONE

◆ xaccAccountInsertSplit

Typedef Documentation

◆ gnc_engine_init_hook_t

Function Documentation

◆ account_type_list() [1/3]

◆ account_type_list() [2/3]

◆ account_type_list() [3/3]

◆ deserialize()

◆ DxaccAccountGetCurrency()

◆ dxaccAccountGetQuoteTZ()

◆ DxaccAccountSetCurrency()

◆ dxaccAccountSetQuoteTZ()

◆ gnc_account_imap_find_account_bayes()

◆ gnc_account_lookup_by_name()

◆ gnc_account_lookup_by_opening_balance()

◆ gnc_account_lookup_by_type_and_commodity()

◆ gnc_account_tree_begin_staged_transaction_traversals()

◆ gnc_account_tree_staged_transaction_traversal()

◆ gnc_engine_init()

◆ gnc_engine_init_static()

◆ gnc_engine_shutdown()

◆ in_stream()

◆ is_changed()

◆ is_dirty()

◆ is_multiselect()

◆ mark_saved()

◆ num_permissible_values()

◆ permissible_value()

◆ permissible_value_index()

◆ permissible_value_name()

◆ serialize()

◆ validate()

◆ xaccAccountClearHigherBalanceLimit()

◆ xaccAccountClearLowerBalanceLimit()

◆ xaccAccountFindOpenLots()

◆ xaccAccountFindSplitByDesc()

◆ xaccAccountFindTransByDesc()

◆ xaccAccountForEachLot()

◆ xaccAccountForEachTransaction()

◆ xaccAccountGetAppendText()

◆ xaccAccountGetAutoInterest()

◆ xaccAccountGetDescendantPlaceholder()

◆ xaccAccountGetHidden()

◆ xaccAccountGetHigherBalanceLimit()

◆ xaccAccountGetIncludeSubAccountBalances()

◆ xaccAccountGetIsOpeningBalance()

◆ xaccAccountGetLotList()

◆ xaccAccountGetLowerBalanceLimit()

◆ xaccAccountGetPlaceholder()

◆ xaccAccountGetSplitList()