GnuCash  4.901
Modules | Files | Data Structures | Macros | Typedefs | Enumerations | Functions | Variables | Friends
GnuCash Engine: Core, Non-GUI Accounting Functions

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

Modules

 Environment
 The API in this file is used to read the environment configuration file and set up a number of environment variables based on the values found in it.
 
 Generic Preference Utilities
 The only function in this file is meant to initialize the preferences system early in the load process.
 
 
 Cap Gains
 This file implements the various routines to automatically compute and handle Cap Gains/Losses resulting from trading activities.
 
 Commodities
 A commodity is something of value that is easily tradeable or sellable; for example, currencies, stocks, bonds, grain, copper, and oil are all commodities.
 
 Lots: Core Function for AR/AP, Inventory, Stock Lots, Cap Gains
 One often needs to know that the item 'bought' in one transaction is the same one as the item 'sold' in a different transaction.
 
 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< ValueType > &from)
 
 GncOptionValue< ValueType >::GncOptionValue (GncOptionValue< ValueType > &&)=default
 
GncOptionValue< ValueType > & GncOptionValue< ValueType >::operator= (const GncOptionValue< ValueType > &)=default
 
GncOptionValue< ValueType > & GncOptionValue< ValueType >::operator= (GncOptionValue< ValueType > &&)=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 ()
 
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
 
 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
 
GncOptionQofInstanceValueGncOptionQofInstanceValue::operator= (GncOptionQofInstanceValue &&)=default
 
const QofInstanceGncOptionQofInstanceValue::get_value () const
 
const QofInstanceGncOptionQofInstanceValue::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 ()
 
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
 
GncOptionCommodityValueGncOptionCommodityValue::operator= (const GncOptionCommodityValue &)=default
 
GncOptionCommodityValueGncOptionCommodityValue::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 ()
 
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 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 ()
 
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
 
GncOptionMultichoiceValueGncOptionMultichoiceValue::operator= (const GncOptionMultichoiceValue &)=default
 
GncOptionMultichoiceValueGncOptionMultichoiceValue::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 ()
 
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 ()
 
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 AccountGncOptionAccountSelValue::get_value () const
 
const AccountGncOptionAccountSelValue::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 ()
 
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
 
GncOptionDateValueGncOptionDateValue::operator= (const GncOptionDateValue &)=default
 
GncOptionDateValueGncOptionDateValue::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 ()
 
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 ()
 
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 (void *cb)
 
void * 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 GncOptionGncOptionSection::find_option (const char *name) const
 
 GncOptionDBCallback::GncOptionDBCallback (size_t id, GncOptionDBChangeCallback func, void *data)
 
 GncOptionDBCallback::GncOptionDBCallback (const GncOptionDBCallback &)=delete
 
 GncOptionDBCallback::GncOptionDBCallback (GncOptionDBCallback &&)=default
 
GncOptionDBCallbackGncOptionDBCallback::operator= (const GncOptionDBCallback &)=default
 
GncOptionDBCallbackGncOptionDBCallback::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)
 
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 ()
 
GncOptionSectionGncOptionDB::find_section (const std::string &sectname)
 
const GncOptionSectionGncOptionDB::find_section (const std::string &sectname) const
 
GncOptionGncOptionDB::find_option (const std::string &section, const char *name)
 
const GncOptionGncOptionDB::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_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

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

GNCAccountType conversion/checking

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

Account split/transaction list management

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

Account lots

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

Account Reconciliation information getters/setters

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

Account 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 xaccSplitsBeginStagedTransactionTraversals (SplitList *splits)
 xaccSplitsBeginStagedTransactionTraversals() resets the traversal marker for each transaction which is a parent of one of the splits in the list.
 
void xaccAccountBeginStagedTransactionTraversals (const Account *account)
 xaccAccountBeginStagedTransactionTraversals() resets the traversal marker for each transaction which is a parent of one of the splits in the account.
 
gboolean xaccTransactionTraverse (Transaction *trans, int stage)
 xaccTransactionTraverse() checks the stage of the given transaction. More...
 
int xaccAccountStagedTransactionTraversal (const Account *a, unsigned int stage, TransactionCallback thunk, void *data)
 xaccAccountStagedTransactionTraversal() calls thunk on each transaction in account a whose current marker is less than the given stage and updates each transaction's marker to be stage. More...
 
int gnc_account_tree_staged_transaction_traversal (const Account *account, unsigned int stage, TransactionCallback thunk, void *data)
 gnc_account_tree_staged_transaction_traversal() calls thunk on each transaction in the group whose current marker is less than the given stage and updates each transaction's marker to be stage. More...
 
int xaccAccountTreeForEachTransaction (Account *acc, TransactionCallback proc, void *data)
 Traverse all of the transactions in the given account group. More...
 
Accountgnc_account_imap_find_account (Account *acc, 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)
 
Accountgnc_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.
 
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 1705 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,
 
)    xaccSplitSetAccount((s), (acc))

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

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

Definition at line 1038 of file Account.h.

Typedef Documentation

◆ gnc_engine_init_hook_t

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

Function type for init hooks in the engine.

Definition at line 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 390 of file gnc-option.cpp.

391 {
392  return std::visit([] (const auto& option) -> GList* {
393  if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
395  return option.account_type_list();
396  else
397  return nullptr;
398  }, *m_option);
399 }
Set one or more accounts on which to report, optionally restricted to certain account types...
GList * account_type_list() const noexcept
Implemented only for GncOptionAccountListValue.
Definition: gnc-option.cpp:390

◆ 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 367 of file gnc-option-impl.cpp.

368 {
369  if (m_allowed.empty())
370  return nullptr;
371  GList* retval{nullptr};
372  for (auto type : m_allowed)
373  retval = g_list_prepend(retval, GINT_TO_POINTER(type));
374  return g_list_reverse(retval);
375 }

◆ 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 438 of file gnc-option-impl.cpp.

439 {
440  if (m_allowed.empty())
441  return nullptr;
442  GList* retval{nullptr};
443  for (auto type : m_allowed)
444  retval = g_list_prepend(retval, GINT_TO_POINTER(type));
445  return g_list_reverse(retval);
446 }

◆ deserialize()

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

Set the option's value from a character sequence.

Parameters
strThe character sequence representing the value
Returns
true if the value was set, false otherwise.

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

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

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

3436 {
3437  GValue v = G_VALUE_INIT;
3438  const char *s = NULL;
3439  gnc_commodity_table *table;
3440  gnc_commodity *retval = NULL;
3441 
3442  if (!acc) return NULL;
3443  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {"old-currency"});
3444  if (G_VALUE_HOLDS_STRING (&v))
3445  s = g_value_get_string (&v);
3446  if (s)
3447  {
3449  retval = gnc_commodity_table_lookup_unique (table, s);
3450  }
3451  g_value_unset (&v);
3452 
3453  return retval;
3454 }
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.

◆ dxaccAccountGetQuoteTZ()

const char* dxaccAccountGetQuoteTZ ( const Account account)

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

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

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

Definition at line 5313 of file Account.cpp.

5314 {
5315  static char *quote_tz = nullptr;
5316  if (!acc) return NULL;
5317  if (!xaccAccountIsPriced(acc)) return NULL;
5318  g_free (quote_tz);
5319  quote_tz = get_kvp_string_tag (acc, "old-quote-tz");
5320  return quote_tz;
5321 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4700

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

2751 {
2752  QofBook *book;
2753  GValue v = G_VALUE_INIT;
2754  const char *s = gnc_commodity_get_unique_name (currency);
2755  gnc_commodity *commodity;
2756  gnc_commodity_table *table;
2757 
2758  if ((!acc) || (!currency)) return;
2759  g_value_init (&v, G_TYPE_STRING);
2760  g_value_set_string (&v, s);
2761  qof_instance_set_path_kvp (QOF_INSTANCE (acc), &v, {"old-currency"});
2762  mark_account (acc);
2763  xaccAccountCommitEdit(acc);
2764  g_value_unset (&v);
2765 
2767  commodity = gnc_commodity_table_lookup_unique (table, s);
2768 
2769  if (!commodity)
2770  {
2771  book = qof_instance_get_book(acc);
2773  currency);
2774  }
2775 }
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table *table, gnc_commodity *comm)
Add a new commodity to the commodity table.
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the &#39;unique&#39; name for the specified commodity.
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

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

5303 {
5304  if (!acc) return;
5305  if (!xaccAccountIsPriced(acc)) return;
5306  set_kvp_string_tag (acc, "old-quote-tz", tz);
5307 }
gboolean xaccAccountIsPriced(const Account *acc)
Returns true if the account is a stock, mutual fund or currency, otherwise false. ...
Definition: Account.cpp:4700

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

Look up an Account in the map using Baysian.

Definition at line 6062 of file Account.cpp.

6063 {
6064  if (!acc)
6065  return nullptr;
6066  auto book = gnc_account_get_book(acc);
6067  check_import_map_data (book);
6068  auto first_pass = get_first_pass_probabilities(acc, tokens);
6069  if (!first_pass.size())
6070  return nullptr;
6071  auto final_probabilities = build_probabilities(first_pass);
6072  if (!final_probabilities.size())
6073  return nullptr;
6074  auto best = highest_probability(final_probabilities);
6075  if (best.account_guid == "")
6076  return nullptr;
6077  if (best.probability < threshold)
6078  return nullptr;
6079  gnc::GUID guid;
6080  try {
6081  guid = gnc::GUID::from_string(best.account_guid);
6082  } catch (gnc::guid_syntax_exception&) {
6083  return nullptr;
6084  }
6085  auto account = xaccAccountLookup (reinterpret_cast<GncGUID*>(&guid), book);
6086  return account;
6087 }
Account * xaccAccountLookup(const GncGUID *guid, QofBook *book)
The xaccAccountLookup() subroutine will return the account associated with the given id...
Definition: Account.cpp:2059

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

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

◆ gnc_account_lookup_by_opening_balance()

Account* gnc_account_lookup_by_opening_balance ( Account account,
gnc_commodity *  commodity 
)

Find the opening balance account for the currency.

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

Definition at line 3120 of file Account.cpp.

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

◆ gnc_account_lookup_by_type_and_commodity()

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

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

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

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

Definition at line 3197 of file Account.cpp.

3201 {
3202  GList *retval{};
3203  auto rpriv{GET_PRIVATE(root)};
3204  for (auto node = rpriv->children; node; node = node->next)
3205  {
3206  auto account{static_cast<Account*>(node->data)};
3207  if (xaccAccountGetType (account) == acctype)
3208  {
3209  if (commodity &&
3211  commodity))
3212  continue;
3213 
3214  if (name && strcmp(name, xaccAccountGetName(account)))
3215  continue;
3216 
3217  retval = g_list_prepend(retval, account);
3218  }
3219  }
3220 
3221  if (!retval) // Recurse through the children
3222  for (auto node = rpriv->children; node; node = node->next)
3223  {
3224  auto account{static_cast<Account*>(node->data)};
3225  auto result = gnc_account_lookup_by_type_and_commodity(account,
3226  name,
3227  acctype,
3228  commodity);
3229  if (result)
3230  retval = g_list_concat(result, retval);
3231  }
3232  return retval;
3233 }
GNCAccountType xaccAccountGetType(const Account *acc)
Returns the account&#39;s account type.
Definition: Account.cpp:3288
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account&#39;s commodity.
Definition: Account.cpp:3457
const char * xaccAccountGetName(const Account *acc)
Get the account&#39;s name.
Definition: Account.cpp:3310
gboolean gnc_commodity_equiv(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equivalent.
GList * gnc_account_lookup_by_type_and_commodity(Account *root, const char *name, GNCAccountType acctype, gnc_commodity *commodity)
Find a direct child account matching name, GNCAccountType, and/or commodity.
Definition: Account.cpp:3197

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

5586 {
5587  GList *descendants;
5588 
5589  descendants = gnc_account_get_descendants(account);
5590  g_list_foreach(descendants, (GFunc)do_one_account, NULL);
5591  g_list_free(descendants);
5592 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:3045

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

5639 {
5640  const AccountPrivate *priv;
5641  GList *acc_p, *split_p;
5642  Transaction *trans;
5643  Split *s;
5644  int retval;
5645 
5646  if (!acc) return 0;
5647 
5648  /* depth first traversal */
5649  priv = GET_PRIVATE(acc);
5650  for (acc_p = priv->children; acc_p; acc_p = g_list_next(acc_p))
5651  {
5652  retval = gnc_account_tree_staged_transaction_traversal(static_cast <Account*> (acc_p->data),
5653  stage, thunk, cb_data);
5654  if (retval) return retval;
5655  }
5656 
5657  /* Now this account */
5658  for (split_p = priv->splits; split_p; split_p = g_list_next(split_p))
5659  {
5660  s = static_cast <Split*> (split_p->data);
5661  trans = s->parent;
5662  if (trans && (trans->marker < stage))
5663  {
5664  trans->marker = stage;
5665  if (thunk)
5666  {
5667  retval = thunk(trans, cb_data);
5668  if (retval) return retval;
5669  }
5670  }
5671  }
5672 
5673  return 0;
5674 }
int gnc_account_tree_staged_transaction_traversal(const Account *acc, unsigned int stage, TransactionCallback thunk, void *cb_data)
gnc_account_tree_staged_transaction_traversal() calls thunk on each transaction in the group whose cu...
Definition: Account.cpp:5635

◆ gnc_engine_init()

void gnc_engine_init ( int  argc,
char **  argv 
)

PROTOTYPES.

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

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

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

◆ gnc_engine_init_static()

void gnc_engine_init_static ( int  argc,
char **  argv 
)

This is the statically linked-in version of gnc_engine_init.

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

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

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

◆ gnc_engine_shutdown()

void gnc_engine_shutdown ( void  )

Called to shutdown the engine.

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

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

◆ in_stream()

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

Set the option's value from an input stream.

Parameters
issAn input stream reference.
Returns
the stream reference for chaining.

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

440 {
441  return std::visit([&iss](auto& option) -> std::istream& {
442  iss >> option;
443  return iss;
444  }, *m_option);
445 }

◆ 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 298 of file gnc-option.cpp.

299 {
300  return std::visit(
301  [](const auto& option)->bool {
302  if constexpr (is_same_decayed_v<decltype(option),
304  return option.is_multiselect();
305  else
306  return false;
307  }, *m_option);
308 }
bool is_multiselect() const noexcept
Definition: gnc-option.cpp:298
Set one or more accounts on which to report, optionally restricted to certain account types...

◆ num_permissible_values()

std::uint16_t GncOption::num_permissible_values ( ) const

Implemented only for GncOptionMultiselectValue.

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

333 {
334  return std::visit(
335  [] (const auto& option) -> uint16_t {
336  if constexpr (is_same_decayed_v<decltype(option),
338  is_same_decayed_v<decltype(option),
340  return option.num_permissible_values();
341  else
342  return uint16_t_max;
343  }, *m_option);
344 }
A legal date value is a pair of either a RelativeDatePeriod, the absolute flag and a time64...
Multichoice options have a vector of valid options (GncMultichoiceOptionChoices) and validate the sel...
uint16_t num_permissible_values() const
Implemented only for GncOptionMultiselectValue.
Definition: gnc-option.cpp:332

◆ permissible_value()

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

Implemented only for GncOptionMultiselectValue.

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

363 {
364  return std::visit([index] (const auto& option) -> const char* {
365  if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
367  std::is_same_v<std::decay_t<decltype(option)>,
369  return option.permissible_value(index);
370  else
371  return "";
372  }, *m_option);
373 }
A legal date value is a pair of either a RelativeDatePeriod, the absolute flag and a time64...
Multichoice options have a vector of valid options (GncMultichoiceOptionChoices) and validate the sel...
const char * permissible_value(uint16_t index) const
Implemented only for GncOptionMultiselectValue.
Definition: gnc-option.cpp:362

◆ permissible_value_index()

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

Implemented only for GncOptionMultiselectValue.

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

348 {
349  return std::visit(
350  [&value] (const auto& option) -> uint16_t {
351  if constexpr (is_same_decayed_v<decltype(option),
353  is_same_decayed_v<decltype(option),
355  return option.permissible_value_index(value);
356  else
357  return uint16_t_max;
358  }, *m_option);
359 }
uint16_t permissible_value_index(const char *value) const
Implemented only for GncOptionMultiselectValue.
Definition: gnc-option.cpp:347
A legal date value is a pair of either a RelativeDatePeriod, the absolute flag and a time64...
Multichoice options have a vector of valid options (GncMultichoiceOptionChoices) and validate the sel...

◆ permissible_value_name()

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

Implemented only for GncOptionMultiselectValue.

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

377 {
378  return std::visit([index] (const auto& option) -> const char* {
379  if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
381  std::is_same_v<std::decay_t<decltype(option)>,
383  return option.permissible_value_name(index);
384  else
385  return "";
386  }, *m_option);
387 }
A legal date value is a pair of either a RelativeDatePeriod, the absolute flag and a time64...
Multichoice options have a vector of valid options (GncMultichoiceOptionChoices) and validate the sel...
const char * permissible_value_name(uint16_t index) const
Implemented only for GncOptionMultiselectValue.
Definition: gnc-option.cpp:376

◆ serialize()

std::string GncOption::serialize ( ) const

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

Returns
a std::string

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

422 {
423  if (m_option->valueless_by_exception())
424  return "Valueless Option";
425  return std::visit([&](auto& option) -> std::string {
426  return option.serialize();
427  }, *m_option);
428 }

◆ validate()

template<typename ValueType >
template bool GncOption::validate ( ValueType  value) const

Not implemented for GncOptionValue.

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

312 {
313  return std::visit(
314  [value] (const auto& option) -> bool {
315  if constexpr ((is_same_decayed_v<decltype(option),
317  is_same_decayed_v<ValueType, std::string>) ||
318  (is_same_decayed_v<decltype(option),
320  is_same_decayed_v<ValueType,
321  GncMultichoiceOptionIndexVec>) ||
322  (is_same_decayed_v<decltype(option),
324  is_same_decayed_v<ValueType, gnc_commodity*>))
325  return option.validate(value);
326  else
327  return false;
328  }, *m_option);
329 }
Multichoice options have a vector of valid options (GncMultichoiceOptionChoices) and validate the sel...
class GncOptionCommodityValue Commodities are stored with their namespace and mnemonic instead of the...

◆ xaccAccountClearHigherBalanceLimit()

void xaccAccountClearHigherBalanceLimit ( Account account)

Clear the higher balance limit for the account.

Parameters
accountThe account to clear the limit on

Definition at line 5129 of file Account.cpp.

5130 {
5131  g_return_if_fail (GNC_IS_ACCOUNT(acc));
5132 
5133  clear_balance_limits (acc, true);
5134 }

◆ xaccAccountClearLowerBalanceLimit()

void xaccAccountClearLowerBalanceLimit ( Account account)

Clear the lower balance limit for the account.

Parameters
accountThe account to clear the limit on

Definition at line 5137 of file Account.cpp.

5138 {
5139  g_return_if_fail (GNC_IS_ACCOUNT(acc));
5140 
5141  clear_balance_limits (acc, false);
5142 }

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

4049 {
4050  AccountPrivate *priv;
4051  GList *lot_list;
4052  GList *retval = NULL;
4053 
4054  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
4055 
4056  priv = GET_PRIVATE(acc);
4057  for (lot_list = priv->lots; lot_list; lot_list = lot_list->next)
4058  {
4059  GNCLot *lot = static_cast<GNCLot*>(lot_list->data);
4060 
4061  /* If this lot is closed, then ignore it */
4062  if (gnc_lot_is_closed (lot))
4063  continue;
4064 
4065  if (match_func && !(match_func)(lot, user_data))
4066  continue;
4067 
4068  /* Ok, this is a valid lot. Add it to our list of lots */
4069  retval = g_list_prepend (retval, lot);
4070  }
4071 
4072  if (sort_func)
4073  retval = g_list_sort (retval, sort_func);
4074 
4075  return retval;
4076 }
gboolean gnc_lot_is_closed(GNCLot *lot)
The gnc_lot_is_closed() routine returns a boolean flag: is this lot closed? A lot is closed if its ba...
Definition: gnc-lot.c:382

◆ xaccAccountFindSplitByDesc()

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

Returns a pointer to the split, not a copy.

Definition at line 5407 of file Account.cpp.

5408 {
5409  Split *split;
5410 
5411  /* Get the split which has a transaction matching the description. */
5412  finder_help_function(acc, description, &split, NULL);
5413  return split;
5414 }

◆ xaccAccountFindTransByDesc()

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

Returns a pointer to the transaction, not a copy.

Definition at line 5422 of file Account.cpp.

5423 {
5424  Transaction *trans;
5425 
5426  /* Get the translation matching the description. */
5427  finder_help_function(acc, description, NULL, &trans);
5428  return trans;
5429 }

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

5694 {
5695  if (!acc || !proc) return 0;
5697  return xaccAccountStagedTransactionTraversal(acc, 42, proc, data);
5698 }
void xaccAccountBeginStagedTransactionTraversals(const Account *account)
xaccAccountBeginStagedTransactionTraversals() resets the traversal marker for each transaction which ...
Definition: Account.cpp:5547
int xaccAccountStagedTransactionTraversal(const Account *acc, unsigned int stage, TransactionCallback thunk, void *cb_data)
xaccAccountStagedTransactionTraversal() calls thunk on each transaction in account a whose current ma...
Definition: Account.cpp:5595

◆ 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
accountThe account whose flag should be retrieved.
Returns
The current state of the account's "import-append-text" flag.

Definition at line 4262 of file Account.cpp.

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

◆ xaccAccountGetAutoInterest()

gboolean xaccAccountGetAutoInterest ( const Account acc)

Get the "auto interest" flag for an account.

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

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

Definition at line 4324 of file Account.cpp.

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

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

4301 {
4302  GList *descendants, *node;
4303  GNCPlaceholderType ret = PLACEHOLDER_NONE;
4304 
4305  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), PLACEHOLDER_NONE);
4306  if (xaccAccountGetPlaceholder(acc)) return PLACEHOLDER_THIS;
4307 
4308  descendants = gnc_account_get_descendants(acc);
4309  for (node = descendants; node; node = node->next)
4310  if (xaccAccountGetPlaceholder((Account *) node->data))
4311  {
4312  ret = PLACEHOLDER_CHILD;
4313  break;
4314  }
4315 
4316  g_list_free(descendants);
4317  return ret;
4318 }
GList * gnc_account_get_descendants(const Account *account)
This routine returns a flat list of all of the accounts that are descendants of the specified account...
Definition: Account.cpp:3045
GNCPlaceholderType
DOCUMENT ME!
Definition: Account.h:1249
gboolean xaccAccountGetPlaceholder(const Account *acc)
Get the "placeholder" flag for an account.
Definition: Account.cpp:4250

◆ xaccAccountGetHidden()

gboolean xaccAccountGetHidden ( const Account acc)

Get the "hidden" flag for an account.

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

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

Definition at line 4339 of file Account.cpp.

4340 {
4341  return boolean_from_key (acc, {"hidden"});
4342 }

◆ xaccAccountGetHigherBalanceLimit()

gboolean xaccAccountGetHigherBalanceLimit ( const Account account,
gnc_numeric *  balance 
)

Get the higher balance limit for the account.

Parameters
accountThe account whose higher limit is to be retrieved
balanceThe placeholder to store the retrieved balance
Returns
True if the limit is valid.

Definition at line 4947 of file Account.cpp.

4949 {
4950  g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
4951 
4952  if (GET_PRIVATE(acc)->higher_balance_cached)
4953  {
4954  *balance = GET_PRIVATE(acc)->higher_balance_limit;
4955 
4956  if (gnc_numeric_check (*balance) == 0)
4957  return true;
4958  else
4959  return false;
4960  }
4961  else
4962  {
4963  gnc_numeric bal = gnc_numeric_create (1,0);
4964  GValue v = G_VALUE_INIT;
4965  gboolean retval = false;
4966 
4967  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {KEY_BALANCE_LIMIT,
4968  KEY_BALANCE_HIGHER_LIMIT_VALUE});
4969  if (G_VALUE_HOLDS_BOXED(&v))
4970  {
4971  bal = *(gnc_numeric*)g_value_get_boxed (&v);
4972  if (bal.denom)
4973  {
4974  if (balance)
4975  *balance = bal;
4976  retval = true;
4977  }
4978  }
4979  g_value_unset (&v);
4980 
4981  GET_PRIVATE(acc)->higher_balance_limit = bal;
4982  GET_PRIVATE(acc)->higher_balance_cached = true;
4983  return retval;
4984  }
4985 }
GNCNumericErrorCode gnc_numeric_check(gnc_numeric in)
Check for error signal in value.

◆ xaccAccountGetIncludeSubAccountBalances()

gboolean xaccAccountGetIncludeSubAccountBalances ( const Account account)

Get whether to include balances of sub accounts.

Parameters
accountThe account to get setting on
Returns
TRUE to include, default is FALSE

Definition at line 5145 of file Account.cpp.

5146 {
5147  g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
5148 
5149  if (GET_PRIVATE(acc)->include_sub_account_balances == TriState::Unset)
5150  {
5151  gboolean inc_sub = boolean_from_key (acc, {KEY_BALANCE_LIMIT,
5152  KEY_BALANCE_INCLUDE_SUB_ACCTS});
5153 
5154  GET_PRIVATE(acc)->include_sub_account_balances = inc_sub ? TriState::True
5155  : TriState::False;
5156  }
5157  return GET_PRIVATE(acc)->include_sub_account_balances == TriState::True;
5158 }

◆ xaccAccountGetIsOpeningBalance()

gboolean xaccAccountGetIsOpeningBalance ( const Account account)

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

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

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

Definition at line 4274 of file Account.cpp.

4275 {
4276  if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
4277  return false;
4278  auto priv = GET_PRIVATE(acc);
4279  if (priv->equity_type == TriState::Unset)
4280  {
4281  auto equity_type = get_kvp_string_tag (acc, "equity-type");
4282  priv->equity_type = g_strcmp0 (equity_type, "opening-balance") ?
4283  TriState::False : TriState::True;
4284  g_free (equity_type);
4285  }
4286  return (priv->equity_type == TriState::True);
4287 }
Equity account is used to balance the balance sheet.
Definition: Account.h:146

◆ xaccAccountGetLotList()

LotList* xaccAccountGetLotList ( const Account account)

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

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

Definition at line 4038 of file Account.cpp.

4039 {
4040  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
4041  return g_list_copy(GET_PRIVATE(acc)->lots);
4042 }

◆ xaccAccountGetLowerBalanceLimit()

gboolean xaccAccountGetLowerBalanceLimit ( const Account account,
gnc_numeric *  balance 
)

Get the lower balance limit for the account.

Parameters
accountThe account whose lower limit is to be retrieved
balanceThe placeholder to store the retrieved balance
Returns
True if the limit is valid.

Definition at line 4988 of file Account.cpp.

4990 {
4991  g_return_val_if_fail (GNC_IS_ACCOUNT(acc), false);
4992 
4993  if (GET_PRIVATE(acc)->lower_balance_cached)
4994  {
4995  *balance = GET_PRIVATE(acc)->lower_balance_limit;
4996 
4997  if (gnc_numeric_check (*balance) == 0)
4998  return true;
4999  else
5000  return false;
5001  }
5002  else
5003  {
5004  gnc_numeric bal = gnc_numeric_create (1,0);
5005  GValue v = G_VALUE_INIT;
5006  gboolean retval = false;
5007 
5008  qof_instance_get_path_kvp (QOF_INSTANCE(acc), &v, {KEY_BALANCE_LIMIT,
5009  KEY_BALANCE_LOWER_LIMIT_VALUE});
5010  if (G_VALUE_HOLDS_BOXED(&v))
5011  {
5012  bal = *(gnc_numeric*)g_value_get_boxed (&v);
5013  if (bal.denom)
5014  {
5015  if (balance)
5016  *balance = bal;
5017  retval = true;
5018  }
5019  }
5020  g_value_unset (&v);
5021 
5022  GET_PRIVATE(acc)->lower_balance_limit = bal;
5023  GET_PRIVATE(acc)->lower_balance_cached = true;
5024  return retval;
5025  }
5026 }
GNCNumericErrorCode gnc_numeric_check(gnc_numeric in)
Check for error signal in value.

◆ xaccAccountGetPlaceholder()

gboolean xaccAccountGetPlaceholder ( const Account account)

Get the "placeholder" flag for an account.

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

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

Definition at line 4250 of file Account.cpp.

4251 {
4252  return boolean_from_key(acc, {"placeholder"});
4253 }

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

4017 {
4018  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), NULL);
4019  xaccAccountSortSplits((Account*)acc, FALSE); // normally a noop
4020  return GET_PRIVATE(acc)->splits;
4021 }
void xaccAccountSortSplits(Account *acc, gboolean force)
The xaccAccountSortSplits() routine will resort the account&#39;s splits if the sort is dirty...
Definition: Account.cpp:2013

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

4507 {
4508  if (type < 0 || NUM_ACCOUNT_TYPES <= type ) return "";
4509  return _(account_type_name [type]);
4510 }
stop here; the following types just aren&#39;t ready for prime time
Definition: Account.h:161

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

2153 {
2154  AccountPrivate *priv, *opriv;
2155  Account * old_acc = NULL;
2156  Account* lot_account;
2157 
2158  /* errors */
2159  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2160  g_return_if_fail(GNC_IS_LOT(lot));
2161 
2162  /* optimizations */
2163  lot_account = gnc_lot_get_account(lot);
2164  if (lot_account == acc)
2165  return;
2166 
2167  ENTER ("(acc=%p, lot=%p)", acc, lot);
2168 
2169  /* pull it out of the old account */
2170  if (lot_account)
2171  {
2172  old_acc = lot_account;
2173  opriv = GET_PRIVATE(old_acc);
2174  opriv->lots = g_list_remove(opriv->lots, lot);
2175  }
2176 
2177  priv = GET_PRIVATE(acc);
2178  priv->lots = g_list_prepend(priv->lots, lot);
2179  gnc_lot_set_account(lot, acc);
2180 
2181  /* Don't move the splits to the new account. The caller will do this
2182  * if appropriate, and doing it here will not work if we are being
2183  * called from gnc_book_close_period since xaccAccountInsertSplit
2184  * will try to balance capital gains and things aren't ready for that. */
2185 
2186  qof_event_gen (QOF_INSTANCE(lot), QOF_EVENT_ADD, NULL);
2187  qof_event_gen (&acc->inst, QOF_EVENT_MODIFY, NULL);
2188 
2189  LEAVE ("(acc=%p, lot=%p)", acc, lot);
2190 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
Account * gnc_lot_get_account(const GNCLot *lot)
The gnc_lot_get_account() routine returns the account with which this lot is associated.
Definition: gnc-lot.c:392
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ xaccAccountIsAPARType()

gboolean xaccAccountIsAPARType ( GNCAccountType  t)

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

Definition at line 4676 of file Account.cpp.

4677 {
4678  switch (t)
4679  {
4680  case ACCT_TYPE_RECEIVABLE:
4681  case ACCT_TYPE_PAYABLE:
4682  return TRUE;
4683  default:
4684  return FALSE;
4685  }
4686 }
A/P account type.
Definition: Account.h:151
A/R account type.
Definition: Account.h:149

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

4631 {
4632  switch (t)
4633  {
4634  case ACCT_TYPE_RECEIVABLE:
4635  case ACCT_TYPE_PAYABLE:
4636  return FALSE;
4637  default:
4640  }
4641 }
gboolean xaccAccountTypesCompatible(GNCAccountType parent_type, GNCAccountType child_type)
Return TRUE if accounts of type parent_type can have accounts of type child_type as children...
Definition: Account.cpp:4603
A/P account type.
Definition: Account.h:151
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:116
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
A/R account type.
Definition: Account.h:149

◆ xaccAccountIsEquityType()

gboolean xaccAccountIsEquityType ( GNCAccountType  t)

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

Definition at line 4688 of file Account.cpp.

4689 {
4690  switch (t)
4691  {
4692  case ACCT_TYPE_EQUITY:
4693  return TRUE;
4694  default:
4695  return FALSE;
4696  }
4697 }
Equity account is used to balance the balance sheet.
Definition: Account.h:146

◆ xaccAccountIsHidden()

gboolean xaccAccountIsHidden ( const Account acc)

Should this account be "hidden".

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

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

Definition at line 4351 of file Account.cpp.

4352 {
4353  AccountPrivate *priv;
4354 
4355  g_return_val_if_fail(GNC_IS_ACCOUNT(acc), FALSE);
4356 
4357  if (xaccAccountGetHidden(acc))
4358  return TRUE;
4359  priv = GET_PRIVATE(acc);
4360  while ((acc = priv->parent) != NULL)
4361  {
4362  priv = GET_PRIVATE(acc);
4363  if (xaccAccountGetHidden(acc))
4364  return TRUE;
4365  }
4366  return FALSE;
4367 }
gboolean xaccAccountGetHidden(const Account *acc)
Get the "hidden" flag for an account.
Definition: Account.cpp:4339

◆ xaccAccountMoveAllSplits()

void xaccAccountMoveAllSplits ( Account accfrom,
Account accto 
)

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

Definition at line 2212 of file Account.cpp.

2213 {
2214  AccountPrivate *from_priv;
2215 
2216  /* errors */
2217  g_return_if_fail(GNC_IS_ACCOUNT(accfrom));
2218  g_return_if_fail(GNC_IS_ACCOUNT(accto));
2219 
2220  /* optimizations */
2221  from_priv = GET_PRIVATE(accfrom);
2222  if (!from_priv->splits || accfrom == accto)
2223  return;
2224 
2225  /* check for book mix-up */
2226  g_return_if_fail (qof_instance_books_equal(accfrom, accto));
2227  ENTER ("(accfrom=%p, accto=%p)", accfrom, accto);
2228 
2229  xaccAccountBeginEdit(accfrom);
2230  xaccAccountBeginEdit(accto);
2231  /* Begin editing both accounts and all transactions in accfrom. */
2232  g_list_foreach(from_priv->splits, (GFunc)xaccPreSplitMove, NULL);
2233 
2234  /* Concatenate accfrom's lists of splits and lots to accto's lists. */
2235  //to_priv->splits = g_list_concat(to_priv->splits, from_priv->splits);
2236  //to_priv->lots = g_list_concat(to_priv->lots, from_priv->lots);
2237 
2238  /* Set appropriate flags. */
2239  //from_priv->balance_dirty = TRUE;
2240  //from_priv->sort_dirty = FALSE;
2241  //to_priv->balance_dirty = TRUE;
2242  //to_priv->sort_dirty = TRUE;
2243 
2244  /*
2245  * Change each split's account back pointer to accto.
2246  * Convert each split's amount to accto's commodity.
2247  * Commit to editing each transaction.
2248  */
2249  g_list_foreach(from_priv->splits, (GFunc)xaccPostSplitMove, (gpointer)accto);
2250 
2251  /* Finally empty accfrom. */
2252  g_assert(from_priv->splits == NULL);
2253  g_assert(from_priv->lots == NULL);
2254  xaccAccountCommitEdit(accfrom);
2255  xaccAccountCommitEdit(accto);
2256 
2257  LEAVE ("(accfrom=%p, accto=%p)", accfrom, accto);
2258 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gboolean qof_instance_books_equal(gconstpointer ptr1, gconstpointer ptr2)
See if two QofInstances share the same book.
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1458
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ 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
accountThe account whose flag should be retrieved.
valThe new state for the account's "import-append-text" flag.

Definition at line 4268 of file Account.cpp.

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

◆ xaccAccountSetAutoInterest()

void xaccAccountSetAutoInterest ( Account acc,
gboolean  val 
)

Set the "auto interest" flag for an account.

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

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

Definition at line 4330 of file Account.cpp.

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

◆ xaccAccountSetHidden()

void xaccAccountSetHidden ( Account acc,
gboolean  val 
)

Set the "hidden" flag for an account.

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

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

Definition at line 4345 of file Account.cpp.

4346 {
4347  set_boolean_key (acc, {"hidden"}, val);
4348 }

◆ xaccAccountSetHigherBalanceLimit()

void xaccAccountSetHigherBalanceLimit ( Account account,
gnc_numeric  balance 
)

Set the higher balance limit for the account.

Parameters
accountThe account whose higher limit is to be saved
balanceThe balance to be saved

Definition at line 5074 of file Account.cpp.

5075 {
5076  g_return_if_fail (GNC_IS_ACCOUNT(acc));
5077 
5078  if (gnc_numeric_check (balance) != 0)
5079  return;
5080 
5081  set_balance_limits (acc, balance, true);
5082 }
GNCNumericErrorCode gnc_numeric_check(gnc_numeric in)
Check for error signal in value.

◆ xaccAccountSetIncludeSubAccountBalances()

void xaccAccountSetIncludeSubAccountBalances ( Account account,
gboolean  include 
)

Set whether to include balances of sub accounts.

Parameters
accountThe account to set the setting on
includeSet to TRUE for including sub account balances

Definition at line 5161 of file Account.cpp.

5162 {
5163  g_return_if_fail (GNC_IS_ACCOUNT(acc));
5164 
5165  if (inc_sub != xaccAccountGetIncludeSubAccountBalances (acc))
5166  {
5167  GValue v = G_VALUE_INIT;
5168  g_value_init (&v, G_TYPE_BOOLEAN);
5169  g_value_set_boolean (&v, inc_sub);
5170  std::vector<std::string> path {KEY_BALANCE_LIMIT,
5171  KEY_BALANCE_INCLUDE_SUB_ACCTS};
5172  xaccAccountBeginEdit (acc);
5173  if (inc_sub)
5174  qof_instance_set_path_kvp (QOF_INSTANCE(acc), &v, path);
5175  else
5176  qof_instance_set_path_kvp (QOF_INSTANCE(acc), nullptr, path);
5177  GET_PRIVATE(acc)->include_sub_account_balances =
5178  inc_sub ? TriState::True : TriState::False;
5179  mark_account (acc);
5180  xaccAccountCommitEdit (acc);
5181  g_value_unset (&v);
5182  }
5183 }
gboolean xaccAccountGetIncludeSubAccountBalances(const Account *acc)
Get whether to include balances of sub accounts.
Definition: Account.cpp:5145
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1458
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1499

◆ xaccAccountSetIsOpeningBalance()

void xaccAccountSetIsOpeningBalance ( Account account,
gboolean  val 
)

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

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

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

Definition at line 4290 of file Account.cpp.

4291 {
4292  if (GET_PRIVATE(acc)->type != ACCT_TYPE_EQUITY)
4293  return;
4294  auto priv = GET_PRIVATE (acc);
4295  priv->equity_type = val ? TriState::True : TriState::False;
4296  set_kvp_string_tag(acc, "equity-type", val ? "opening-balance" : nullptr);
4297 }
Equity account is used to balance the balance sheet.
Definition: Account.h:146

◆ xaccAccountSetLowerBalanceLimit()

void xaccAccountSetLowerBalanceLimit ( Account account,
gnc_numeric  balance 
)

Set the lower balance limit for the account.

Parameters
accountThe account whose lower limit is to be saved
balanceThe balance to be saved

Definition at line 5085 of file Account.cpp.

5086 {
5087  g_return_if_fail (GNC_IS_ACCOUNT(acc));
5088 
5089  if (gnc_numeric_check (balance) != 0)
5090  return;
5091 
5092  set_balance_limits (acc, balance, false);
5093 }
GNCNumericErrorCode gnc_numeric_check(gnc_numeric in)
Check for error signal in value.

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

2072 {
2073  AccountPrivate *priv;
2074 
2075  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2076 
2077  priv = GET_PRIVATE(acc);
2078  priv->mark = m;
2079 }

◆ xaccAccountSetPlaceholder()

void xaccAccountSetPlaceholder ( Account account,
gboolean  val 
)

Set the "placeholder" flag for an account.

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

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

Definition at line 4256 of file Account.cpp.

4257 {
4258  set_boolean_key(acc, {"placeholder"}, val);
4259 }

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

5599 {
5600  AccountPrivate *priv;
5601  GList *split_p;
5602  GList *next;
5603  Transaction *trans;
5604  Split *s;
5605  int retval;
5606 
5607  if (!acc) return 0;
5608 
5609  priv = GET_PRIVATE(acc);
5610  for (split_p = priv->splits; split_p; split_p = next)
5611  {
5612  /* Get the next element in the split list now, just in case some
5613  * naughty thunk destroys the one we're using. This reduces, but
5614  * does not eliminate, the possibility of undefined results if
5615  * a thunk removes splits from this account. */
5616  next = g_list_next(split_p);
5617 
5618  s = static_cast <Split*> (split_p->data);
5619  trans = s->parent;
5620  if (trans && (trans->marker < stage))
5621  {
5622  trans->marker = stage;
5623  if (thunk)
5624  {
5625  retval = thunk(trans, cb_data);
5626  if (retval) return retval;
5627  }
5628  }
5629  }
5630 
5631  return 0;
5632 }

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

4468 {
4469  GNCAccountType type;
4470  gboolean rc;
4471  rc = xaccAccountStringToType(str, &type);
4472  if (FALSE == rc) return ACCT_TYPE_INVALID;
4473  return type;
4474 }
gboolean xaccAccountStringToType(const char *str, GNCAccountType *type)
Conversion routines for the account types to/from strings that are used in persistent storage...
Definition: Account.cpp:4433
GNCAccountType
The account types are used to determine how the transaction data in the account is displayed...
Definition: Account.h:101
Not a type.
Definition: Account.h:104

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

4434 {
4435 
4436  GNC_RETURN_ON_MATCH(NONE);
4437  GNC_RETURN_ON_MATCH(BANK);
4438  GNC_RETURN_ON_MATCH(CASH);
4439  GNC_RETURN_ON_MATCH(CREDIT);
4440  GNC_RETURN_ON_MATCH(ASSET);
4441  GNC_RETURN_ON_MATCH(LIABILITY);
4442  GNC_RETURN_ON_MATCH(STOCK);
4443  GNC_RETURN_ON_MATCH(MUTUAL);
4444  GNC_RETURN_ON_MATCH(CURRENCY);
4445  GNC_RETURN_ON_MATCH(INCOME);
4446  GNC_RETURN_ON_MATCH(EXPENSE);
4447  GNC_RETURN_ON_MATCH(EQUITY);
4448  GNC_RETURN_ON_MATCH(RECEIVABLE);
4449  GNC_RETURN_ON_MATCH(PAYABLE);
4450  GNC_RETURN_ON_MATCH(ROOT);
4451  GNC_RETURN_ON_MATCH(TRADING);
4452  GNC_RETURN_ON_MATCH(CHECKING);
4453  GNC_RETURN_ON_MATCH(SAVINGS);
4454  GNC_RETURN_ON_MATCH(MONEYMRKT);
4455  GNC_RETURN_ON_MATCH(CREDITLINE);
4456 
4457  PERR("asked to translate unknown account type string %s.\n",
4458  str ? str : "(null)");
4459 
4460  return(FALSE);
4461 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244

◆ xaccAccountTreeForEachTransaction()

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

Traverse all of the transactions in the given account group.

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

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

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

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

Note that this routine is just a trivial wrapper for

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

◆ xaccAccountTypeEnumAsString()

const char* xaccAccountTypeEnumAsString ( GNCAccountType  type)

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

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

Definition at line 4396 of file Account.cpp.

4397 {
4398  switch (type)
4399  {
4400  GNC_RETURN_ENUM_AS_STRING(NONE);
4401  GNC_RETURN_ENUM_AS_STRING(BANK);
4402  GNC_RETURN_ENUM_AS_STRING(CASH);
4403  GNC_RETURN_ENUM_AS_STRING(CREDIT);
4404  GNC_RETURN_ENUM_AS_STRING(ASSET);
4405  GNC_RETURN_ENUM_AS_STRING(LIABILITY);
4406  GNC_RETURN_ENUM_AS_STRING(STOCK);
4407  GNC_RETURN_ENUM_AS_STRING(MUTUAL);
4408  GNC_RETURN_ENUM_AS_STRING(CURRENCY);
4409  GNC_RETURN_ENUM_AS_STRING(INCOME);
4410  GNC_RETURN_ENUM_AS_STRING(EXPENSE);
4411  GNC_RETURN_ENUM_AS_STRING(EQUITY);
4412  GNC_RETURN_ENUM_AS_STRING(RECEIVABLE);
4413  GNC_RETURN_ENUM_AS_STRING(PAYABLE);
4414  GNC_RETURN_ENUM_AS_STRING(ROOT);
4415  GNC_RETURN_ENUM_AS_STRING(TRADING);
4416  GNC_RETURN_ENUM_AS_STRING(CHECKING);
4417  GNC_RETURN_ENUM_AS_STRING(SAVINGS);
4418  GNC_RETURN_ENUM_AS_STRING(MONEYMRKT);
4419  GNC_RETURN_ENUM_AS_STRING(CREDITLINE);
4420  default:
4421  PERR ("asked to translate unknown account type %d.\n", type);
4422  break;
4423  }
4424  return(NULL);
4425 }
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244

◆ xaccAccountTypeGetFundamental()

GNCAccountType xaccAccountTypeGetFundamental ( GNCAccountType  t)

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

Definition at line 4644 of file Account.cpp.

4645 {
4646  switch (t)
4647  {
4648  case ACCT_TYPE_BANK:
4649  case ACCT_TYPE_STOCK:
4650  case ACCT_TYPE_MONEYMRKT:
4651  case ACCT_TYPE_CHECKING:
4652  case ACCT_TYPE_SAVINGS:
4653  case ACCT_TYPE_MUTUAL:
4654  case ACCT_TYPE_CURRENCY:
4655  case ACCT_TYPE_CASH:
4656  case ACCT_TYPE_ASSET:
4657  case ACCT_TYPE_RECEIVABLE:
4658  return ACCT_TYPE_ASSET;
4659  case ACCT_TYPE_CREDIT:
4660  case ACCT_TYPE_LIABILITY:
4661  case ACCT_TYPE_PAYABLE:
4662  case ACCT_TYPE_CREDITLINE:
4663  return ACCT_TYPE_LIABILITY;
4664  case ACCT_TYPE_INCOME:
4665  return ACCT_TYPE_INCOME;
4666  case ACCT_TYPE_EXPENSE:
4667  return ACCT_TYPE_EXPENSE;
4668  case ACCT_TYPE_EQUITY:
4669  return ACCT_TYPE_EQUITY;
4670  case ACCT_TYPE_TRADING:
4671  default:
4672  return ACCT_TYPE_NONE;
4673  }
4674 }
Expense accounts are used to denote expenses.
Definition: Account.h:143
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:125
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:110
Account used to record multiple commodity transactions.
Definition: Account.h:155
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:122
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:165
Income accounts are used to denote income.
Definition: Account.h:140
line of credit – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:171
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:107
A/P account type.
Definition: Account.h:151
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:167
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:116
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:129
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
A/R account type.
Definition: Account.h:149
bank account type – don&#39;t use this for now, see NUM_ACCOUNT_TYPES
Definition: Account.h:169
Equity account is used to balance the balance sheet.
Definition: Account.h:146
Not a type.
Definition: Account.h:105
The Credit card account is used to denote credit (e.g.
Definition: Account.h:113

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

4605 {
4606  /* ACCT_TYPE_NONE isn't compatible with anything, even ACCT_TYPE_NONE. */
4607  if (parent_type == ACCT_TYPE_NONE || child_type == ACCT_TYPE_NONE)
4608  return FALSE;
4609 
4610  /* ACCT_TYPE_ROOT can't have a parent account, and asking will raise
4611  * an error. */
4612  if (child_type == ACCT_TYPE_ROOT)
4613  return FALSE;
4614 
4615  return ((xaccParentAccountTypesCompatibleWith (child_type) &
4616  (1 << parent_type))
4617  != 0);
4618 }
guint32 xaccParentAccountTypesCompatibleWith(GNCAccountType type)
Return the bitmask of parent account types compatible with a given type.
Definition: Account.cpp:4556
Not a type.
Definition: Account.h:105
The hidden root account of an account tree.
Definition: Account.h:153

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

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

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

4622 {
4623  guint32 mask = (1 << NUM_ACCOUNT_TYPES) - 1;
4624  mask &= ~((1 << ACCT_TYPE_CURRENCY) | /* DEPRECATED */
4625  (1 << ACCT_TYPE_ROOT)); /* ROOT */
4626 
4627  return mask;
4628 }
stop here; the following types just aren&#39;t ready for prime time
Definition: Account.h:161
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:129
The hidden root account of an account tree.
Definition: Account.h:153

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

2083 {
2084  Account *root;
2085 
2086  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2087 
2088  root = gnc_account_get_root(acc);
2089  xaccClearMarkDown(root ? root : acc, val);
2090 }
void xaccClearMarkDown(Account *acc, short val)
The xaccClearMarkDown will clear the mark only in this and in sub-accounts.
Definition: Account.cpp:2093
Account * gnc_account_get_root(Account *acc)
This routine returns the root account of the account tree that the specified account belongs to...
Definition: Account.cpp:2915

◆ xaccClearMarkDown()

void xaccClearMarkDown ( Account account,
short  val 
)

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

Definition at line 2093 of file Account.cpp.

2094 {
2095  AccountPrivate *priv;
2096  GList *node;
2097 
2098  g_return_if_fail(GNC_IS_ACCOUNT(acc));
2099 
2100  priv = GET_PRIVATE(acc);
2101  priv->mark = val;
2102  for (node = priv->children; node; node = node->next)
2103  {
2104  xaccClearMarkDown(static_cast<Account*>(node->data), val);
2105  }
2106 }
void xaccClearMarkDown(Account *acc, short val)
The xaccClearMarkDown will clear the mark only in this and in sub-accounts.
Definition: Account.cpp:2093

◆ xaccParentAccountTypesCompatibleWith()

guint32 xaccParentAccountTypesCompatibleWith ( GNCAccountType  type)

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

Definition at line 4556 of file Account.cpp.

4557 {
4558  switch (type)
4559  {
4560  case ACCT_TYPE_BANK:
4561  case ACCT_TYPE_CASH:
4562  case ACCT_TYPE_ASSET:
4563  case ACCT_TYPE_STOCK:
4564  case ACCT_TYPE_MUTUAL:
4565  case ACCT_TYPE_CURRENCY:
4566  case ACCT_TYPE_CREDIT:
4567  case ACCT_TYPE_LIABILITY:
4568  case ACCT_TYPE_RECEIVABLE:
4569  case ACCT_TYPE_PAYABLE:
4570  return
4571  (1 << ACCT_TYPE_BANK) |
4572  (1 << ACCT_TYPE_CASH) |
4573  (1 << ACCT_TYPE_ASSET) |
4574  (1 << ACCT_TYPE_STOCK) |
4575  (1 << ACCT_TYPE_MUTUAL) |
4576  (1 << ACCT_TYPE_CURRENCY) |
4577  (1 << ACCT_TYPE_CREDIT) |
4578  (1 << ACCT_TYPE_LIABILITY) |
4579  (1 << ACCT_TYPE_RECEIVABLE) |
4580  (1 << ACCT_TYPE_PAYABLE) |
4581  (1 << ACCT_TYPE_ROOT);
4582  case ACCT_TYPE_INCOME:
4583  case ACCT_TYPE_EXPENSE:
4584  return
4585  (1 << ACCT_TYPE_INCOME) |
4586  (1 << ACCT_TYPE_EXPENSE) |
4587  (1 << ACCT_TYPE_ROOT);
4588  case ACCT_TYPE_EQUITY:
4589  return
4590  (1 << ACCT_TYPE_EQUITY) |
4591  (1 << ACCT_TYPE_ROOT);
4592  case ACCT_TYPE_TRADING:
4593  return
4594  (1 << ACCT_TYPE_TRADING) |
4595  (1 << ACCT_TYPE_ROOT);
4596  default:
4597  PERR("bad account type: %d", type);
4598  return 0;
4599  }
4600 }
Expense accounts are used to denote expenses.
Definition: Account.h:143
Mutual Fund accounts will typically be shown in registers which show three columns: price...
Definition: Account.h:125
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
The cash account type is used to denote a shoe-box or pillowcase stuffed with * cash.
Definition: Account.h:110
Account used to record multiple commodity transactions.
Definition: Account.h:155
Stock accounts will typically be shown in registers which show three columns: price, number of shares, and value.
Definition: Account.h:122
Income accounts are used to denote income.
Definition: Account.h:140
The bank account type denotes a savings or checking account held at a bank.
Definition: Account.h:107
A/P account type.
Definition: Account.h:151
asset (and liability) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:116
The currency account type indicates that the account is a currency trading account.
Definition: Account.h:129
liability (and asset) accounts indicate generic, generalized accounts that are none of the above...
Definition: Account.h:119
A/R account type.
Definition: Account.h:149
Equity account is used to balance the balance sheet.
Definition: Account.h:146
The hidden root account of an account tree.
Definition: Account.h:153
The Credit card account is used to denote credit (e.g.
Definition: Account.h:113

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

5559 {
5560  if (trans == NULL) return FALSE;
5561 
5562  if (trans->marker < stage)
5563  {
5564  trans->marker = stage;
5565  return TRUE;
5566  }
5567 
5568  return FALSE;
5569 }

Variable Documentation

◆ value [1/5]

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 71 of file gnc-option.hpp.

◆ value [2/5]

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 81 of file gnc-option.hpp.

◆ value [3/5]

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 91 of file gnc-option.hpp.

◆ value [4/5]

template<typename T >
constexpr bool is_QofInstanceValue< T >::value
static
Initial value:
=
std::is_same_v<std::decay_t<T>, GncOptionQofInstanceValue>

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

◆ value [5/5]

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 221 of file gnc-option-impl.hpp.