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

Files
file	gnc-commodity.h
	Commodity handling public routines.
file	gnc-commodity.hpp
	Commodity handling public routines (C++ api)

Data Structures
struct	gnc_monetary

Macros
#define	GNC_TYPE_COMMODITY   (gnc_commodity_get_type ())
#define	GNC_COMMODITY(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_COMMODITY, gnc_commodity))
#define	GNC_COMMODITY_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_COMMODITY, gnc_commodityClass))
#define	GNC_IS_COMMODITY(o)    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_COMMODITY))
#define	GNC_IS_COMMODITY_CLASS(k)    (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_COMMODITY))
#define	GNC_COMMODITY_GET_CLASS(o)    (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_COMMODITY, gnc_commodityClass))
#define	GNC_TYPE_COMMODITY_NAMESPACE   (gnc_commodity_namespace_get_type ())
#define	GNC_COMMODITY_NAMESPACE(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespace))
#define	GNC_COMMODITY_NAMESPACE_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespaceClass))
#define	GNC_IS_COMMODITY_NAMESPACE(o)    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_COMMODITY_NAMESPACE))
#define	GNC_IS_COMMODITY_NAMESPACE_CLASS(k)    (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_COMMODITY_NAMESPACE))
#define	GNC_COMMODITY_NAMESPACE_GET_CLASS(o)    (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespaceClass))
#define	GNC_COMMODITY_TABLE   "gnc_commodity_table"
#define	GNC_COMMODITY_NS_LEGACY   "GNC_LEGACY_CURRENCIES"
	The commodity namespace definitions are used to tag a commodity by its type, or a stocks by the exchange where it is traded.
#define	GNC_COMMODITY_NS_TEMPLATE   "template"
#define	GNC_COMMODITY_NS_ISO   "ISO4217"
#define	GNC_COMMODITY_NS_CURRENCY   "CURRENCY"
#define	GNC_COMMODITY_NS_NONCURRENCY   "NONCURRENCY"
#define	GNC_COMMODITY_NS_NONISO_GUI   NC_("Commodity Type", "All non-currency")
#define	GNC_COMMODITY_NS_ISO_GUI   NC_("Commodity Type", "Currencies")
#define	GNC_COMMODITY_MAX_FRACTION   1000000000
	Max fraction is 10^9 because 10^10 would require changing it to an int64_t.

Typedefs
typedef GList	CommodityList
using	CommVec = std::vector< gnc_commodity * >

Functions
GType	gnc_commodity_get_type (void)
GType	gnc_commodity_namespace_get_type (void)
void	gnc_quote_source_set_fq_installed (const char *version_string, const std::vector< std::string > &sources_list)
	Update gnucash internal tables based on what Finance::Quote sources are installed.
bool	gnc_commodity_table_rename_namespace (const gnc_commodity_table *table, const char *namespace_name, const char *new_namespace_name)
	This function renames a namespace.

Commodity Quote Source functions
enum	QuoteSourceType {   SOURCE_SINGLE = 0 , SOURCE_MULTI , SOURCE_UNKNOWN , SOURCE_MAX ,   SOURCE_CURRENCY = SOURCE_MAX }
	The quote source type enum account types are used to determine how the transaction data in the account is displayed. More...
gboolean	gnc_quote_source_fq_installed (void)
	This function indicates whether or not the Finance::Quote module is installed on a user's computer.
const char *	gnc_quote_source_fq_version (void)
	This function returns the version of the Finance::Quote module installed on a user's computer.
gint	gnc_quote_source_num_entries (QuoteSourceType type)
	Return the number of entries for a given type of quote source.
gnc_quote_source *	gnc_quote_source_add_new (const char *name, gboolean supported)
	Create a new quote source.
gnc_quote_source *	gnc_quote_source_lookup_by_internal (const char *internal_name)
	Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by this name.
gnc_quote_source *	gnc_quote_source_lookup_by_ti (QuoteSourceType type, gint index)
	Given the type/index of a quote source, find the data structure identified by this pair.
gboolean	gnc_quote_source_get_supported (const gnc_quote_source *source)
	Given a gnc_quote_source data structure, return the flag that indicates whether this particular quote source is supported by the user's F::Q installation.
QuoteSourceType	gnc_quote_source_get_type (const gnc_quote_source *source)
	Given a gnc_quote_source data structure, return the type of this particular quote source.
gint	gnc_quote_source_get_index (const gnc_quote_source *source)
	Given a gnc_quote_source data structure, return the index of this particular quote source within its type.
const char *	gnc_quote_source_get_user_name (const gnc_quote_source *source)
	Given a gnc_quote_source data structure, return the user friendly name of this quote source.
const char *	gnc_quote_source_get_internal_name (const gnc_quote_source *source)
	Given a gnc_quote_source data structure, return the internal name of this quote source.

Monetary value, commodity identity and numeric value
typedef GList	MonetaryList

Commodity Creation
gnc_commodity *	gnc_commodity_new (QofBook *book, const char *fullname, const char *commodity_namespace, const char *mnemonic, const char *cusip, int fraction)
	Create a new commodity.
void	gnc_commodity_destroy (gnc_commodity *cm)
	Destroy a commodity.
void	gnc_commodity_copy (gnc_commodity *dest, const gnc_commodity *src)
	Copy src into dest.
gnc_commodity *	gnc_commodity_clone (const gnc_commodity *src, QofBook *dest_book)
	allocate and copy

Commodity Accessor Routines - Get
gboolean	gnc_commodity_get_auto_quote_control_flag (const gnc_commodity *cm)
const char *	gnc_commodity_get_mnemonic (const gnc_commodity *cm)
	Retrieve the mnemonic for the specified commodity.
const char *	gnc_commodity_get_namespace (const gnc_commodity *cm)
	Retrieve the namespace for the specified commodity.
gnc_commodity_namespace *	gnc_commodity_get_namespace_ds (const gnc_commodity *cm)
	Retrieve the namespace data structure for the specified commodity.
const char *	gnc_commodity_get_fullname (const gnc_commodity *cm)
	Retrieve the full name for the specified commodity.
const char *	gnc_commodity_get_printname (const gnc_commodity *cm)
	Retrieve the 'print' name for the specified commodity.
const char *	gnc_commodity_get_cusip (const gnc_commodity *cm)
	Retrieve the 'exchange code' for the specified commodity.
const char *	gnc_commodity_get_unique_name (const gnc_commodity *cm)
	Retrieve the 'unique' name for the specified commodity.
int	gnc_commodity_get_fraction (const gnc_commodity *cm)
	Retrieve the fraction for the specified commodity.
gboolean	gnc_commodity_get_quote_flag (const gnc_commodity *cm)
	Retrieve the automatic price quote flag for the specified commodity.
gnc_quote_source *	gnc_commodity_get_quote_source (const gnc_commodity *cm)
	Retrieve the automatic price quote source for the specified commodity.
gnc_quote_source *	gnc_commodity_get_default_quote_source (const gnc_commodity *cm)
const char *	gnc_commodity_get_quote_tz (const gnc_commodity *cm)
	Retrieve the automatic price quote timezone for the specified commodity.
const char *	gnc_commodity_get_user_symbol (const gnc_commodity *cm)
	Retrieve the user-defined symbol for the specified commodity.
const char *	gnc_commodity_get_default_symbol (const gnc_commodity *cm)
	Retrieve the default symbol for the specified commodity.
const char *	gnc_commodity_get_nice_symbol (const gnc_commodity *cm)
	Retrieve a symbol for the specified commodity, suitable for display to the user.

Commodity Accessor Routines - Set
void	gnc_commodity_set_auto_quote_control_flag (gnc_commodity *cm, const gboolean flag)
void	gnc_commodity_set_mnemonic (gnc_commodity *cm, const char *mnemonic)
	Set the mnemonic for the specified commodity.
void	gnc_commodity_set_namespace (gnc_commodity *cm, const char *new_namespace)
	Set the namespace for the specified commodity.
void	gnc_commodity_set_fullname (gnc_commodity *cm, const char *fullname)
	Set the full name for the specified commodity.
void	gnc_commodity_set_cusip (gnc_commodity *cm, const char *cusip)
	Set the 'exchange code' for the specified commodity.
void	gnc_commodity_set_fraction (gnc_commodity *cm, int smallest_fraction)
	Set the fraction for the specified commodity.
void	gnc_commodity_user_set_quote_flag (gnc_commodity *cm, const gboolean flag)
	Set the automatic price quote flag for the specified commodity, based on user input.
void	gnc_commodity_set_quote_flag (gnc_commodity *cm, const gboolean flag)
	Set the automatic price quote flag for the specified commodity.
void	gnc_commodity_set_quote_source (gnc_commodity *cm, gnc_quote_source *src)
	Set the automatic price quote source for the specified commodity.
void	gnc_commodity_set_quote_tz (gnc_commodity *cm, const char *tz)
	Set the automatic price quote timezone for the specified commodity.
void	gnc_commodity_set_user_symbol (gnc_commodity *cm, const char *user_symbol)
	Set a user-defined symbol for the specified commodity.

Commodity Usage Count Adjustment Routines
void	gnc_commodity_increment_usage_count (gnc_commodity *cm)
	Increment a commodity's internal counter that tracks how many accounts are using that commodity.
void	gnc_commodity_decrement_usage_count (gnc_commodity *cm)
	Decrement a commodity's internal counter that tracks how many accounts are using that commodity.

Commodity Comparison
gboolean	gnc_commodity_equiv (const gnc_commodity *a, const gnc_commodity *b)
	This routine returns TRUE if the two commodities are equivalent.
gboolean	gnc_commodity_equal (const gnc_commodity *a, const gnc_commodity *b)
	This routine returns TRUE if the two commodities are equal.
int	gnc_commodity_compare (const gnc_commodity *a, const gnc_commodity *b)
	This routine returns 0 if the two commodities are equal, 1 otherwise.
int	gnc_commodity_compare_void (const void *a, const void *b)
	A wrapper around gnc_commodity_compare() which offers the function declaration that is needed for g_list_find_custom(), which needs void pointers instead of gnc_commodity ones.

Currency Checks
gboolean	gnc_commodity_namespace_is_iso (const char *commodity_namespace)
	Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.
gboolean	gnc_commodity_is_iso (const gnc_commodity *cm)
	Checks to see if the specified commodity is an ISO 4217 recognized currency.
gboolean	gnc_commodity_is_currency (const gnc_commodity *cm)
	Checks to see if the specified commodity is an ISO 4217 recognized currency or a legacy currency.

Commodity Table
gnc_commodity_table *	gnc_commodity_table_get_table (QofBook *book)
	Returns the commodity table associated with a book.

Commodity Table Lookup functions
gnc_commodity *	gnc_commodity_table_lookup (const gnc_commodity_table *table, const char *commodity_namespace, const char *mnemonic)
gnc_commodity *	gnc_commodity_table_lookup_unique (const gnc_commodity_table *table, const char *unique_name)
gnc_commodity *	gnc_commodity_table_find_full (const gnc_commodity_table *t, const char *commodity_namespace, const char *fullname)
gnc_commodity *	gnc_commodity_find_commodity_by_guid (const GncGUID *guid, QofBook *book)

Commodity Table Maintenance functions
gnc_commodity *	gnc_commodity_table_insert (gnc_commodity_table *table, gnc_commodity *comm)
	Add a new commodity to the commodity table.
void	gnc_commodity_table_remove (gnc_commodity_table *table, gnc_commodity *comm)
	Remove a commodity from the commodity table.
gboolean	gnc_commodity_table_add_default_data (gnc_commodity_table *table, QofBook *book)
	Add all the standard namespaces and currencies to the commodity table.

Commodity Table Namespace functions
const char *	gnc_commodity_namespace_get_name (const gnc_commodity_namespace *ns)
	Return the textual name of a namespace data structure.
const char *	gnc_commodity_namespace_get_gui_name (const gnc_commodity_namespace *ns)
	Return the textual name of a namespace data structure in a form suitable to present to the user.
GList *	gnc_commodity_namespace_get_commodity_list (const gnc_commodity_namespace *ns)
	Return a list of all commodity data structures in the specified namespace.
int	gnc_commodity_table_has_namespace (const gnc_commodity_table *table, const char *commodity_namespace)
	Test to see if the indicated namespace exits in the commodity table.
GList *	gnc_commodity_table_get_namespaces (const gnc_commodity_table *t)
	Return a list of all namespaces in the commodity table.
GList *	gnc_commodity_table_get_namespaces_list (const gnc_commodity_table *t)
	Return a list of all namespace data structures in the commodity table.
gnc_commodity_namespace *	gnc_commodity_table_add_namespace (gnc_commodity_table *table, const char *commodity_namespace, QofBook *book)
	This function adds a new string to the list of commodity namespaces.
gnc_commodity_namespace *	gnc_commodity_table_find_namespace (const gnc_commodity_table *table, const char *commodity_namespace)
	This function finds a commodity namespace in the set of existing commodity namespaces.
void	gnc_commodity_table_delete_namespace (gnc_commodity_table *table, const char *commodity_namespace)
	This function deletes a string from the list of commodity namespaces.

Commodity Table Accessor functions
guint	gnc_commodity_table_get_size (const gnc_commodity_table *tbl)
	Returns the number of commodities in the commodity table.
CommodityList *	gnc_commodity_table_get_commodities (const gnc_commodity_table *table, const char *commodity_namespace)
	Return a list of all commodities in the commodity table that are in the given namespace.
CommodityList *	gnc_commodity_table_get_quotable_commodities (const gnc_commodity_table *table)
	This function returns a list of commodities for which price quotes should be retrieved.
gboolean	gnc_commodity_table_foreach_commodity (const gnc_commodity_table *table, gboolean(*f)(gnc_commodity *cm, gpointer user_data), gpointer user_data)
	Call a function once for each commodity in the commodity table.

Commodity Table Private/Internal-Use Only Routines
gnc_commodity_table *	gnc_commodity_table_new (void)
	You probably shouldn't be using gnc_commodity_table_new() directly, it's for internal use only.
void	gnc_commodity_table_destroy (gnc_commodity_table *table)
gnc_commodity *	gnc_commodity_obtain_twin (const gnc_commodity *findlike, QofBook *book)
	Given the commodity 'findlike', this routine will find and return the equivalent commodity (commodity with the same 'unique name') in the indicated book.
gboolean	gnc_commodity_table_register (void)
	You should probably not be using gnc_commodity_table_register() It is an internal routine for registering the gncObject for the commodity table.
void	gnc_commodity_begin_edit (gnc_commodity *cm)
void	gnc_commodity_commit_edit (gnc_commodity *cm)
#define	gnc_commodity_get_kvp_frame(cm)    qof_instance_get_slots(QOF_INSTANCE(cm))
	Get the internal KVP from of the currency.

Manipulate MonetaryList lists
MonetaryList *	gnc_monetary_list_add_monetary (MonetaryList *list, gnc_monetary mon)
	Add a gnc_monetary to the list.
MonetaryList *	gnc_monetary_list_delete_zeros (MonetaryList *list)
	Delete all the zero-value entries from a list.
void	gnc_monetary_list_free (MonetaryList *list)
	Free a monetary list and all the items it points to.

Detailed Description

A commodity is something of value that is easily tradeable or sellable; for example, currencies, stocks, bonds, grain, copper, and oil are all commodities.

This file provides an API for defining a commodities, and for working with collections of commodities. All GnuCash financial transactions must identify the commodity that is being traded.

Warning

The system used here does not follow the object handling and identification system (GncGUID's, Entities, etc.) that the other parts of GnuCash use. The API really should be ported over. This would allow us to get rid of the commodity table routines defined below.

Macro Definition Documentation

GNC_COMMODITY

#define GNC_COMMODITY

(

o

)

(G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_COMMODITY, gnc_commodity))

Definition at line 63 of file gnc-commodity.h.

{
    SOURCE_SINGLE = 0,  
    SOURCE_MULTI,       
    SOURCE_UNKNOWN, 
    SOURCE_MAX,
    SOURCE_CURRENCY = SOURCE_MAX, 
} QuoteSourceType;
 
gboolean gnc_quote_source_fq_installed (void);
 
const char* gnc_quote_source_fq_version (void);
 
gint gnc_quote_source_num_entries(QuoteSourceType type);
 
gnc_quote_source *gnc_quote_source_add_new(const char * name, gboolean supported);
 
/*@ dependent @*/
gnc_quote_source *gnc_quote_source_lookup_by_internal(const char * internal_name);
 
gnc_quote_source *gnc_quote_source_lookup_by_ti(QuoteSourceType type, gint index);
 
gboolean gnc_quote_source_get_supported (const gnc_quote_source *source);
 
QuoteSourceType gnc_quote_source_get_type (const gnc_quote_source *source);
 
gint gnc_quote_source_get_index (const gnc_quote_source *source);
 
/*@ dependent @*/
const char *gnc_quote_source_get_user_name (const gnc_quote_source *source);
 
/*@ dependent @*/
const char *gnc_quote_source_get_internal_name (const gnc_quote_source *source);
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_new(QofBook *book,
                                  /*@ null @*/ const char * fullname,
                                  /*@ null @*/ const char * commodity_namespace,
                                  /*@ null @*/ const char * mnemonic,
                                  /*@ null @*/ const char * cusip,
                                  int fraction);
 
void  gnc_commodity_destroy(gnc_commodity * cm);
 
void  gnc_commodity_copy(gnc_commodity * dest, const gnc_commodity *src);
 
gnc_commodity * gnc_commodity_clone(const gnc_commodity *src, QofBook *dest_book);
gboolean gnc_commodity_get_auto_quote_control_flag (const gnc_commodity *cm);
 
const char * gnc_commodity_get_mnemonic(const gnc_commodity * cm);
 
const char * gnc_commodity_get_namespace(const gnc_commodity * cm);
 
gnc_commodity_namespace *gnc_commodity_get_namespace_ds(const gnc_commodity * cm);
 
const char * gnc_commodity_get_fullname(const gnc_commodity * cm);
 
const char * gnc_commodity_get_printname(const gnc_commodity * cm);
 
const char * gnc_commodity_get_cusip(const gnc_commodity * cm);
 
const char * gnc_commodity_get_unique_name(const gnc_commodity * cm);
 
int     gnc_commodity_get_fraction(const gnc_commodity * cm);
 
gboolean    gnc_commodity_get_quote_flag(const gnc_commodity *cm);
 
/*@ dependent @*/
gnc_quote_source* gnc_commodity_get_quote_source(const gnc_commodity *cm);
/*@ dependent @*/
gnc_quote_source* gnc_commodity_get_default_quote_source(const gnc_commodity *cm);
 
const char* gnc_commodity_get_quote_tz(const gnc_commodity *cm);
 
const char* gnc_commodity_get_user_symbol(const gnc_commodity *cm);
 
const char* gnc_commodity_get_default_symbol(const gnc_commodity *cm);
 
const char*gnc_commodity_get_nice_symbol(const gnc_commodity *cm);
void gnc_commodity_set_auto_quote_control_flag (gnc_commodity *cm, const gboolean flag);
 
void  gnc_commodity_set_mnemonic(gnc_commodity * cm, const char * mnemonic);
 
void  gnc_commodity_set_namespace(gnc_commodity * cm, const char * new_namespace);
 
void  gnc_commodity_set_fullname(gnc_commodity * cm, const char * fullname);
 
void  gnc_commodity_set_cusip(gnc_commodity * cm, const char * cusip);
 
void  gnc_commodity_set_fraction(gnc_commodity * cm, int smallest_fraction);
 
void  gnc_commodity_user_set_quote_flag(gnc_commodity *cm,
                                        const gboolean flag);
 
void  gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag);
 
void  gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src);
 
void  gnc_commodity_set_quote_tz(gnc_commodity *cm, const char *tz);
 
void  gnc_commodity_set_user_symbol(gnc_commodity *cm, const char *user_symbol);
void
gnc_commodity_increment_usage_count(gnc_commodity *cm);
 
void
gnc_commodity_decrement_usage_count(gnc_commodity *cm);
gboolean gnc_commodity_equiv(const gnc_commodity * a, const gnc_commodity * b);
 
gboolean gnc_commodity_equal(const gnc_commodity * a, const gnc_commodity * b);
 
int gnc_commodity_compare(const gnc_commodity * a, const gnc_commodity * b);
 
int gnc_commodity_compare_void(const void * a, const void * b);
gboolean gnc_commodity_namespace_is_iso(const char *commodity_namespace);
 
gboolean gnc_commodity_is_iso(const gnc_commodity * cm);
 
gboolean gnc_commodity_is_currency(const gnc_commodity *cm);
 
/* =============================================================== */
/*@ dependent @*/
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book);
 
/* ---------------------------------------------------------- */
gnc_commodity * gnc_commodity_table_lookup(const gnc_commodity_table * table,
        const char * commodity_namespace,
        const char * mnemonic);
gnc_commodity *
gnc_commodity_table_lookup_unique(const gnc_commodity_table *table,
                                  const char * unique_name);
gnc_commodity * gnc_commodity_table_find_full(const gnc_commodity_table * t,
        const char * commodity_namespace,
        const char * fullname);
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_find_commodity_by_guid(const GncGUID *guid,
        QofBook *book);
 
/* ---------------------------------------------------------- */
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table * table,
        gnc_commodity * comm);
 
void gnc_commodity_table_remove(gnc_commodity_table * table,
                                gnc_commodity * comm);
 
gboolean gnc_commodity_table_add_default_data(gnc_commodity_table *table, QofBook *book);
 
/* ---------------------------------------------------------- */
const char * gnc_commodity_namespace_get_name (const gnc_commodity_namespace *ns) ;
 
const char * gnc_commodity_namespace_get_gui_name (const gnc_commodity_namespace *ns) ;
 
 
GList * gnc_commodity_namespace_get_commodity_list(const gnc_commodity_namespace * ns);
 
 
int gnc_commodity_table_has_namespace(const gnc_commodity_table * table,
                                      const char * commodity_namespace);
 
GList * gnc_commodity_table_get_namespaces(const gnc_commodity_table * t);
 
GList * gnc_commodity_table_get_namespaces_list(const gnc_commodity_table * t);
 
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table * table,
        const char * commodity_namespace,
        QofBook *book);
 
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table * table,
        const char * commodity_namespace);
 
void      gnc_commodity_table_delete_namespace(gnc_commodity_table * table,
        const char * commodity_namespace);
/* ---------------------------------------------------------- */
guint gnc_commodity_table_get_size(const gnc_commodity_table* tbl);
 
CommodityList * gnc_commodity_table_get_commodities(
    const gnc_commodity_table * table, const char * commodity_namespace);
 
CommodityList * gnc_commodity_table_get_quotable_commodities(
    const gnc_commodity_table * table);
 
gboolean gnc_commodity_table_foreach_commodity(const gnc_commodity_table * table,
        gboolean (*f)(gnc_commodity *cm,
                      gpointer user_data),
        gpointer user_data);
/* ---------------------------------------------------------- */
gnc_commodity_table * gnc_commodity_table_new(void);
void          gnc_commodity_table_destroy(gnc_commodity_table * table);
 
gnc_commodity * gnc_commodity_obtain_twin (const gnc_commodity *findlike, QofBook *book);
 
gboolean gnc_commodity_table_register (void);
 
void gnc_commodity_begin_edit (gnc_commodity *cm);
void gnc_commodity_commit_edit (gnc_commodity *cm);
 
#define gnc_commodity_get_kvp_frame(cm) \
    qof_instance_get_slots(QOF_INSTANCE(cm))
 
struct _gnc_monetary
{
    gnc_commodity *commodity;
    gnc_numeric value;
};
 
typedef struct _gnc_monetary gnc_monetary;
 
/* A list of monetary values.  This could be a hash table, but as currently
* used it rarely contains more than one or two different commodities so
* it doesn't seem worth the trouble.
*/
typedef GList MonetaryList;
 
static inline
gnc_monetary gnc_monetary_create(gnc_commodity *commod, gnc_numeric val)
{
    gnc_monetary out;
    out.commodity = commod;
    out.value = val;
    return out;
}
static inline
gnc_commodity * gnc_monetary_commodity(gnc_monetary a)
{
    return a.commodity;
}
 
static inline
gnc_numeric gnc_monetary_value(gnc_monetary a)
{
    return a.value;
}
MonetaryList *gnc_monetary_list_add_monetary(MonetaryList *list, gnc_monetary mon);
 
static inline
MonetaryList *gnc_monetary_list_add_value(MonetaryList *list,
        gnc_commodity *commod,
        gnc_numeric value)
{
    return gnc_monetary_list_add_monetary(list,
                                          gnc_monetary_create(commod, value));
}
 
MonetaryList *gnc_monetary_list_delete_zeros(MonetaryList *list);
 
void gnc_monetary_list_free(MonetaryList *list);
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* GNC_COMMODITY_H */

GNC_COMMODITY_CLASS

#define GNC_COMMODITY_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_COMMODITY, gnc_commodityClass))

Definition at line 65 of file gnc-commodity.h.

GNC_COMMODITY_GET_CLASS

#define GNC_COMMODITY_GET_CLASS

(

o

)

(G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_COMMODITY, gnc_commodityClass))

Definition at line 71 of file gnc-commodity.h.

gnc_commodity_get_kvp_frame

#define gnc_commodity_get_kvp_frame

(

cm

)

qof_instance_get_slots(QOF_INSTANCE(cm))

Get the internal KVP from of the currency.

You should rather use the individual accessors for individual properties

Definition at line 987 of file gnc-commodity.h.

GNC_COMMODITY_MAX_FRACTION

#define GNC_COMMODITY_MAX_FRACTION   1000000000

Max fraction is 10^9 because 10^10 would require changing it to an int64_t.

Definition at line 116 of file gnc-commodity.h.

GNC_COMMODITY_NAMESPACE

#define GNC_COMMODITY_NAMESPACE

(

o

)

(G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespace))

Definition at line 77 of file gnc-commodity.h.

GNC_COMMODITY_NAMESPACE_CLASS

#define GNC_COMMODITY_NAMESPACE_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespaceClass))

Definition at line 79 of file gnc-commodity.h.

GNC_COMMODITY_NAMESPACE_GET_CLASS

#define GNC_COMMODITY_NAMESPACE_GET_CLASS

(

o

)

(G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_COMMODITY_NAMESPACE, gnc_commodity_namespaceClass))

Definition at line 85 of file gnc-commodity.h.

GNC_COMMODITY_NS_CURRENCY

#define GNC_COMMODITY_NS_CURRENCY   "CURRENCY"

Definition at line 107 of file gnc-commodity.h.

GNC_COMMODITY_NS_ISO

#define GNC_COMMODITY_NS_ISO   "ISO4217"

Definition at line 106 of file gnc-commodity.h.

GNC_COMMODITY_NS_ISO_GUI

#define GNC_COMMODITY_NS_ISO_GUI   NC_("Commodity Type", "Currencies")

Definition at line 111 of file gnc-commodity.h.

GNC_COMMODITY_NS_LEGACY

#define GNC_COMMODITY_NS_LEGACY   "GNC_LEGACY_CURRENCIES"

The commodity namespace definitions are used to tag a commodity by its type, or a stocks by the exchange where it is traded.

The LEGACY name is only used by the file i/o routines, and is converted to another commodity namespace before it is seen by the rest of the system. The ISO namespace represents currencies. With the exception of the NASDAQ namespace (which is used once in the binary importer) the rest of the namespace declarations are only used to populate an option menu in the commodity selection window.

Definition at line 103 of file gnc-commodity.h.

GNC_COMMODITY_NS_NONCURRENCY

#define GNC_COMMODITY_NS_NONCURRENCY   "NONCURRENCY"

Definition at line 108 of file gnc-commodity.h.

GNC_COMMODITY_NS_NONISO_GUI

#define GNC_COMMODITY_NS_NONISO_GUI   NC_("Commodity Type", "All non-currency")

Definition at line 110 of file gnc-commodity.h.

GNC_COMMODITY_NS_TEMPLATE

#define GNC_COMMODITY_NS_TEMPLATE   "template"

Definition at line 104 of file gnc-commodity.h.

GNC_COMMODITY_TABLE

#define GNC_COMMODITY_TABLE   "gnc_commodity_table"

Definition at line 90 of file gnc-commodity.h.

GNC_IS_COMMODITY

#define GNC_IS_COMMODITY

(

o

)

(G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_COMMODITY))

Definition at line 67 of file gnc-commodity.h.

GNC_IS_COMMODITY_CLASS

#define GNC_IS_COMMODITY_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_COMMODITY))

Definition at line 69 of file gnc-commodity.h.

GNC_IS_COMMODITY_NAMESPACE

#define GNC_IS_COMMODITY_NAMESPACE

(

o

)

(G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_COMMODITY_NAMESPACE))

Definition at line 81 of file gnc-commodity.h.

GNC_IS_COMMODITY_NAMESPACE_CLASS

#define GNC_IS_COMMODITY_NAMESPACE_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_COMMODITY_NAMESPACE))

Definition at line 83 of file gnc-commodity.h.

GNC_TYPE_COMMODITY

#define GNC_TYPE_COMMODITY   (gnc_commodity_get_type ())

Definition at line 62 of file gnc-commodity.h.

GNC_TYPE_COMMODITY_NAMESPACE

#define GNC_TYPE_COMMODITY_NAMESPACE   (gnc_commodity_namespace_get_type ())

Definition at line 76 of file gnc-commodity.h.

Typedef Documentation

CommodityList

typedef GList CommodityList

Definition at line 118 of file gnc-commodity.h.

CommVec

using CommVec = std::vector<gnc_commodity*>

Definition at line 41 of file gnc-commodity.hpp.

MonetaryList

typedef GList MonetaryList

Definition at line 1007 of file gnc-commodity.h.

Enumeration Type Documentation

QuoteSourceType

enum QuoteSourceType

The quote source type enum account types are used to determine how the transaction data in the account is displayed.

These values can be safely changed from one release to the next.

Enumerator
SOURCE_SINGLE	This quote source pulls from a single specific web site. For example, the yahoo_australia source only pulls from the yahoo web site.
SOURCE_MULTI	This quote source may pull from multiple web sites. For example, the australia source may pull from ASX, yahoo, etc.
SOURCE_UNKNOWN	This is a locally installed quote source that gnucash knows nothing about. May pull from single or multiple locations.
SOURCE_CURRENCY	The special currency quote source.

Definition at line 128 of file gnc-commodity.h.

{
    SOURCE_SINGLE = 0,  
    SOURCE_MULTI,       
    SOURCE_UNKNOWN, 
    SOURCE_MAX,
    SOURCE_CURRENCY = SOURCE_MAX, 
} QuoteSourceType;

Function Documentation

gnc_commodity_begin_edit()

void gnc_commodity_begin_edit

(

gnc_commodity *

cm

)

Definition at line 493 of file gnc-commodity.cpp.

{
    qof_begin_edit(&cm->inst);
}

gnc_commodity_clone()

gnc_commodity * gnc_commodity_clone	(	const gnc_commodity *	src,
		QofBook *	dest_book
	)

allocate and copy

Definition at line 895 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* src_priv;
    gnc_commodityPrivate* dest_priv;
 
    auto dest = GNC_COMMODITY (g_object_new(GNC_TYPE_COMMODITY, nullptr));
    qof_instance_init_data (&dest->inst, GNC_ID_COMMODITY, dest_book);
    src_priv = GET_PRIVATE(src);
    dest_priv = GET_PRIVATE(dest);
 
    dest_priv->fullname = CACHE_INSERT(src_priv->fullname);
    dest_priv->mnemonic = CACHE_INSERT(src_priv->mnemonic);
    dest_priv->cusip = CACHE_INSERT(src_priv->cusip);
    dest_priv->quote_tz = CACHE_INSERT(src_priv->quote_tz);
 
    dest_priv->name_space = src_priv->name_space;
 
    dest_priv->fraction = src_priv->fraction;
    dest_priv->quote_flag = src_priv->quote_flag;
 
    gnc_commodity_set_quote_source (dest, gnc_commodity_get_quote_source (src));
 
    qof_instance_copy_kvp (QOF_INSTANCE (dest), QOF_INSTANCE (src));
 
    reset_printname(dest_priv);
    reset_unique_name(dest_priv);
 
    return dest;
}

gnc_commodity_commit_edit()

void gnc_commodity_commit_edit

(

gnc_commodity *

cm

)

Definition at line 513 of file gnc-commodity.cpp.

{
    if (!qof_commit_edit (QOF_INSTANCE(cm))) return;
    qof_commit_edit_part2 (&cm->inst, commit_err, noop, comm_free);
}

gnc_commodity_compare()

int gnc_commodity_compare	(	const gnc_commodity *	a,
		const gnc_commodity *	b
	)

This routine returns 0 if the two commodities are equal, 1 otherwise.

Commodities are equal if they have the same namespace, mnemonic, fullname, exchange private code and fraction. This function is useful for list-traversal comparison purposes where The semantics are 0, <0, or >0 (equal, greater than, less than) rather than "true or false"

Definition at line 1504 of file gnc-commodity.cpp.

{
    if (a == b) return 0;
    if (a && !b) return 1;
    if (b && !a) return -1;
    if (auto rv = g_strcmp0 (gnc_commodity_get_unique_name (a), gnc_commodity_get_unique_name (b)))
        return rv;
    return qof_instance_guid_compare(a, b);
}

gnc_commodity_compare_void()

int gnc_commodity_compare_void	(	const void *	a,
		const void *	b
	)

A wrapper around gnc_commodity_compare() which offers the function declaration that is needed for g_list_find_custom(), which needs void pointers instead of gnc_commodity ones.

Definition at line 1516 of file gnc-commodity.cpp.

{
    return gnc_commodity_compare(GNC_COMMODITY (a), GNC_COMMODITY (b));
}

gnc_commodity_copy()

void gnc_commodity_copy	(	gnc_commodity *	dest,
		const gnc_commodity *	src
	)

Copy src into dest.

Definition at line 878 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* src_priv = GET_PRIVATE(src);
    gnc_commodityPrivate* dest_priv = GET_PRIVATE(dest);
 
    gnc_commodity_set_fullname (dest, src_priv->fullname);
    gnc_commodity_set_mnemonic (dest, src_priv->mnemonic);
    dest_priv->name_space = src_priv->name_space;
    gnc_commodity_set_fraction (dest, src_priv->fraction);
    gnc_commodity_set_cusip (dest, src_priv->cusip);
    gnc_commodity_set_quote_flag (dest, src_priv->quote_flag);
    gnc_commodity_set_quote_source (dest, gnc_commodity_get_quote_source (src));
    gnc_commodity_set_quote_tz (dest, src_priv->quote_tz);
    qof_instance_copy_kvp (QOF_INSTANCE (dest), QOF_INSTANCE (src));
}

gnc_commodity_decrement_usage_count()

void gnc_commodity_decrement_usage_count

(

gnc_commodity *

cm

)

Decrement a commodity's internal counter that tracks how many accounts are using that commodity.

For currencies, this may have the side effect of disabling the commodity's quote flag.

Parameters

cm	A pointer to a commodity data structure.

Definition at line 1439 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    ENTER("(cm=%p)", cm);
 
    if (!cm)
    {
        LEAVE("");
        return;
    }
 
    priv = GET_PRIVATE(cm);
 
    if (priv->usage_count == 0)
    {
        PWARN("usage_count already zero");
        LEAVE("");
        return;
    }
 
    priv->usage_count--;
    if ((priv->usage_count == 0) && priv->quote_flag
            && gnc_commodity_get_auto_quote_control_flag(cm)
            && gnc_commodity_is_iso(cm))
    {
        /* if this is a currency with auto quote control enabled and no more
         * accounts reference this currency, disable quote retrieval */
        gnc_commodity_set_quote_flag(cm, FALSE);
    }
    LEAVE("(usage_count=%d)", priv->usage_count);
}

gnc_commodity_destroy()

void gnc_commodity_destroy

(

gnc_commodity *

cm

)

Destroy a commodity.

Release all memory attached to this data structure.

Note

This function does not (can not) check to see if the commodity is referenced anywhere.

Parameters

cm	The commodity to destroy.

Definition at line 870 of file gnc-commodity.cpp.

{
    gnc_commodity_begin_edit(cm);
    qof_instance_set_destroying(cm, TRUE);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_equal()

gboolean gnc_commodity_equal	(	const gnc_commodity *	a,
		const gnc_commodity *	b
	)

This routine returns TRUE if the two commodities are equal.

Commodities are equal if they have the same namespace, mnemonic, fullname, exchange private code and fraction.

Definition at line 1499 of file gnc-commodity.cpp.

{
    return gnc_commodity_compare(a, b) == 0;
}

gnc_commodity_equiv()

gboolean gnc_commodity_equiv	(	const gnc_commodity *	a,
		const gnc_commodity *	b
	)

This routine returns TRUE if the two commodities are equivalent.

Commodities are equivalent if they have the same namespace and mnemonic. Equivalent commodities may belong to different exchanges, may have different fullnames, and may have different fractions.

Definition at line 1482 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv_a;
    gnc_commodityPrivate* priv_b;
 
    if (a == b) return TRUE;
    if (!a || !b) return FALSE;
 
    priv_a = GET_PRIVATE(a);
    priv_b = GET_PRIVATE(b);
    if (priv_a->name_space != priv_b->name_space) return FALSE;
    if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0) return FALSE;
 
    return TRUE;
}

gnc_commodity_find_commodity_by_guid()

gnc_commodity * gnc_commodity_find_commodity_by_guid	(	const GncGUID *	guid,
		QofBook *	book
	)

Definition at line 2181 of file gnc-commodity.cpp.

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

gnc_commodity_get_auto_quote_control_flag()

gboolean gnc_commodity_get_auto_quote_control_flag

(

const gnc_commodity *

cm

)

Definition at line 1017 of file gnc-commodity.cpp.

{
    if (!cm) return FALSE;
    auto str{qof_instance_get_path_kvp<const char*> (QOF_INSTANCE (cm), {"auto_quote_control"})};
    return !str || g_strcmp0 (*str, "false");
}

gnc_commodity_get_cusip()

const char * gnc_commodity_get_cusip

(

const gnc_commodity *

cm

)

Retrieve the 'exchange code' for the specified commodity.

This will be a pointer to a null terminated string of the form "AXQ14728", etc. This field is often used when presenting information to the user.

Note

This is a unique code that specifies a particular item or set of shares of a commodity, not a code that specifies a stock exchange. That is the namespace field.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the exchange code for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 995 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->cusip;
}

gnc_commodity_get_default_quote_source()

gnc_quote_source * gnc_commodity_get_default_quote_source

(

const gnc_commodity *

cm

)

Definition at line 1052 of file gnc-commodity.cpp.

{
    if (cm && gnc_commodity_is_iso(cm))
        return &currency_quote_sources.front();
    /* Should make this a user option at some point. */
    return gnc_quote_source_lookup_by_internal("alphavantage");
}

gnc_commodity_get_default_symbol()

const char * gnc_commodity_get_default_symbol

(

const gnc_commodity *

cm

)

Retrieve the default symbol for the specified commodity.

This will be a pointer to a nul terminated string like "£", "US$", etc. Note that for the locale currency, you probably want to look at the system-provided symbol first. See gnc_commodity_get_nice_symbol.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the default symbol for this commodity.

Definition at line 1087 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->default_symbol;
}

gnc_commodity_get_fraction()

int gnc_commodity_get_fraction

(

const gnc_commodity *

cm

)

Retrieve the fraction for the specified commodity.

This will be an integer value specifying the number of fractional units that one of these commodities can be divided into. Should always be a power of 10.

Parameters

cm	A pointer to a commodity data structure.

Returns

The number of fractional units that one of these commodities can be divided into.

Definition at line 1006 of file gnc-commodity.cpp.

{
    if (!cm) return 0;
    return GET_PRIVATE(cm)->fraction;
}

gnc_commodity_get_fullname()

const char * gnc_commodity_get_fullname

(

const gnc_commodity *

cm

)

Retrieve the full name for the specified commodity.

This will be a pointer to a null terminated string of the form "Acme Systems, Inc.", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the full name for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 971 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->fullname;
}

gnc_commodity_get_mnemonic()

const char * gnc_commodity_get_mnemonic

(

const gnc_commodity *

cm

)

Retrieve the mnemonic for the specified commodity.

This will be a pointer to a null terminated string of the form "ACME", "QWER", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the mnemonic for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 930 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->mnemonic;
}

gnc_commodity_get_namespace()

const char * gnc_commodity_get_namespace

(

const gnc_commodity *

cm

)

Retrieve the namespace for the specified commodity.

This will be a pointer to a null terminated string of the form "AMEX", "NASDAQ", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the namespace for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 953 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
}

gnc_commodity_get_namespace_ds()

gnc_commodity_namespace * gnc_commodity_get_namespace_ds

(

const gnc_commodity *

cm

)

Retrieve the namespace data structure for the specified commodity.

This will be a pointer to another data structure.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the namespace data structure for this commodity.

Definition at line 960 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->name_space;
}

gnc_commodity_get_nice_symbol()

const char * gnc_commodity_get_nice_symbol

(

const gnc_commodity *

cm

)

Retrieve a symbol for the specified commodity, suitable for display to the user.

This will be a pointer to a nul terminated string like "£", "US$", etc. That function is locale-aware and will base its choice of symbol on the user-configured symbol, the locale a

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the symbol for this commodity.

Definition at line 1097 of file gnc-commodity.cpp.

{
    const char *nice_symbol;
    struct lconv *lc;
    if (!cm) return nullptr;
 
    nice_symbol = gnc_commodity_get_user_symbol(cm);
    if (nice_symbol && *nice_symbol)
        return nice_symbol;
 
    lc = gnc_localeconv();
    nice_symbol = lc->currency_symbol;
    if (!g_strcmp0(gnc_commodity_get_mnemonic(cm), lc->int_curr_symbol))
        return nice_symbol;
 
    nice_symbol = gnc_commodity_get_default_symbol(cm);
    if (nice_symbol && *nice_symbol)
        return nice_symbol;
 
    return gnc_commodity_get_mnemonic(cm);
}

gnc_commodity_get_printname()

const char * gnc_commodity_get_printname

(

const gnc_commodity *

cm

)

Retrieve the 'print' name for the specified commodity.

This will be a pointer to a null terminated string of the form "Acme Systems, Inc. (ACME)", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the print name for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 941 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->printname;
}

gnc_commodity_get_quote_flag()

gboolean gnc_commodity_get_quote_flag

(

const gnc_commodity *

cm

)

Retrieve the automatic price quote flag for the specified commodity.

This flag indicates whether stock quotes should be retrieved for the specified stock.

Parameters

cm	A pointer to a commodity data structure.

Returns

TRUE if quotes should be pulled for this commodity, FALSE otherwise.

Definition at line 1029 of file gnc-commodity.cpp.

{
    if (!cm) return FALSE;
    return (GET_PRIVATE(cm)->quote_flag);
}

gnc_commodity_get_quote_source()

gnc_quote_source * gnc_commodity_get_quote_source

(

const gnc_commodity *

cm

)

Retrieve the automatic price quote source for the specified commodity.

This will be a pointer to a null terminated string of the form "Yahoo (Asia)", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the price quote source for this commodity.

Definition at line 1040 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return nullptr;
    priv = GET_PRIVATE(cm);
    if (!priv->quote_source && gnc_commodity_is_iso(cm))
        return &currency_quote_sources.front();
    return priv->quote_source;
}

gnc_commodity_get_quote_tz()

const char * gnc_commodity_get_quote_tz

(

const gnc_commodity *

cm

)

Retrieve the automatic price quote timezone for the specified commodity.

This will be a pointer to a null terminated string of the form "America/New_York", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the price quote timezone for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 1065 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->quote_tz;
}

gnc_commodity_get_unique_name()

const char * gnc_commodity_get_unique_name

(

const gnc_commodity *

cm

)

Retrieve the 'unique' name for the specified commodity.

This will be a pointer to a null terminated string of the form "AMEX::ACME", etc. This field is often used when performing comparisons or other functions invisible to the user.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the 'unique' name for this commodity. This string is owned by the engine and should not be freed by the caller.

Definition at line 983 of file gnc-commodity.cpp.

{
    if (!cm) return nullptr;
    return GET_PRIVATE(cm)->unique_name;
}

gnc_commodity_get_user_symbol()

const char * gnc_commodity_get_user_symbol

(

const gnc_commodity *

cm

)

Retrieve the user-defined symbol for the specified commodity.

This will be a pointer to a nul terminated string like "£", "US$", etc.

Parameters

cm	A pointer to a commodity data structure.

Returns

A pointer to the user-defined symbol for this commodity. NULL means that the user didn't define any symbol, and that fallback to e.g. the mnemonic is in order. This string is owned by the engine and should not be freed by the caller.

Definition at line 1075 of file gnc-commodity.cpp.

{
    g_return_val_if_fail (GNC_IS_COMMODITY (cm), nullptr);
 
    auto sym{qof_instance_get_path_kvp<const char*> (QOF_INSTANCE(cm), {"user_symbol"})};
    return sym ? *sym : nullptr;
}

gnc_commodity_increment_usage_count()

void gnc_commodity_increment_usage_count

(

gnc_commodity *

cm

)

Increment a commodity's internal counter that tracks how many accounts are using that commodity.

For currencies, this may have the side effect of enabling the commodity's quote flag.

Parameters

cm	A pointer to a commodity data structure.

Definition at line 1404 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    ENTER("(cm=%p)", cm);
 
    if (!cm)
    {
        LEAVE("");
        return;
    }
 
    priv = GET_PRIVATE(cm);
 
    if ((priv->usage_count == 0) && !priv->quote_flag
            && gnc_commodity_get_auto_quote_control_flag(cm)
            && gnc_commodity_is_iso(cm))
    {
        /* compatibility hack - Gnucash 1.8 gets currency quotes when a
           non-default currency is assigned to an account.  */
        gnc_commodity_begin_edit(cm);
        gnc_commodity_set_quote_flag(cm, TRUE);
        gnc_commodity_set_quote_source(cm,
                                       gnc_commodity_get_default_quote_source(cm));
        gnc_commodity_commit_edit(cm);
    }
    priv->usage_count++;
    LEAVE("(usage_count=%d)", priv->usage_count);
}

gnc_commodity_is_currency()

gboolean gnc_commodity_is_currency

(

const gnc_commodity *

cm

)

Checks to see if the specified commodity is an ISO 4217 recognized currency or a legacy currency.

Parameters

cm	The commodity to check.

Returns

TRUE if the commodity represents a currency, FALSE otherwise.

Definition at line 1955 of file gnc-commodity.cpp.

{
    const char *ns_name;
    if (!cm) return FALSE;
 
    ns_name = gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
    return (!g_strcmp0(ns_name, GNC_COMMODITY_NS_LEGACY) ||
            !g_strcmp0(ns_name, GNC_COMMODITY_NS_CURRENCY));
}

gnc_commodity_is_iso()

gboolean gnc_commodity_is_iso

(

const gnc_commodity *

cm

)

Checks to see if the specified commodity is an ISO 4217 recognized currency.

Parameters

cm	The commodity to check.

Returns

TRUE if the commodity represents a currency, FALSE otherwise.

Definition at line 1943 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return FALSE;
 
    priv = GET_PRIVATE(cm);
    if ( !priv->name_space) return FALSE;
    return priv->name_space->iso4217;
}

gnc_commodity_namespace_get_commodity_list()

GList * gnc_commodity_namespace_get_commodity_list

(

const gnc_commodity_namespace *

ns

)

Return a list of all commodity data structures in the specified namespace.

Returns

A pointer to the list of structures. NULL if an invalid argument was supplied.

Note

This list is owned by the caller who must free the list.

Definition at line 1543 of file gnc-commodity.cpp.

{
    if (!name_space)
        return nullptr;
 
    return g_list_copy (name_space->cm_list);
}

gnc_commodity_namespace_get_gui_name()

const char * gnc_commodity_namespace_get_gui_name

(

const gnc_commodity_namespace *

ns

)

Return the textual name of a namespace data structure in a form suitable to present to the user.

Parameters

ns	A pointer to the namespace data structure.

Returns

A pointer to the gui friendly name of the namespace. This string is owned by the engine and should not be freed by the caller.

@notes The returned string is marked for translation, but not translated yet. If you want it translated pass the return value on to gettext.

Definition at line 1533 of file gnc-commodity.cpp.

{
    if (ns == nullptr)
        return nullptr;
    if (g_strcmp0 (ns->name, GNC_COMMODITY_NS_CURRENCY) == 0)
        return GNC_COMMODITY_NS_ISO_GUI;
    return ns->name;
}

gnc_commodity_namespace_get_name()

const char * gnc_commodity_namespace_get_name

(

const gnc_commodity_namespace *

ns

)

Return the textual name of a namespace data structure.

Parameters

ns	A pointer to the namespace data structure.

Returns

A pointer to the name of the namespace. This string is owned by the engine and should not be freed by the caller.

Definition at line 1525 of file gnc-commodity.cpp.

{
    if (ns == nullptr)
        return nullptr;
    return ns->name;
}

gnc_commodity_namespace_is_iso()

gboolean gnc_commodity_namespace_is_iso

(

const char *

commodity_namespace

)

Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.

Parameters

commodity_namespace

The string to check.

Returns

TRUE if the string indicates an ISO currency, FALSE otherwise.

Definition at line 1552 of file gnc-commodity.cpp.

{
    return ((g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0) ||
            (g_strcmp0(name_space, GNC_COMMODITY_NS_CURRENCY) == 0));
}

gnc_commodity_new()

gnc_commodity * gnc_commodity_new	(	QofBook *	book,
		const char *	fullname,
		const char *	commodity_namespace,
		const char *	mnemonic,
		const char *	cusip,
		int	fraction
	)

Create a new commodity.

This function allocates a new commodity data structure, populates it with the data provided, and then generates the dynamic names that exist as part of a commodity.

Note

This function does not check to see if the commodity exists before adding a new commodity.

Parameters

book	The book that the new commodity will belong to.
fullname	The complete name of this commodity. E.G. "Acme Systems, Inc."
commodity_namespace	An aggregation of commodities. E.G. ISO4217, Nasdaq, Downbelow, etc.
mnemonic	An abbreviation for this stock. For publicly traced stocks, this field should contain the stock ticker symbol. This field is used to get online price quotes, so it must match the stock ticker symbol used by the exchange where you want to get automatic stock quote updates. E.G. ACME, ACME.US, etc.
cusip	A string containing the CUSIP code or similar UNIQUE code for this commodity like the ISIN. The stock ticker is NOT appropriate as that goes in the mnemonic field.
fraction	The smallest division of this commodity allowed. I.E. If this is 1, then the commodity must be traded in whole units; if 100 then the commodity may be traded in 0.01 units, etc.

Returns

A pointer to the new commodity.

Definition at line 777 of file gnc-commodity.cpp.

{
    auto retval = GNC_COMMODITY(g_object_new(GNC_TYPE_COMMODITY, nullptr));
 
    qof_instance_init_data (&retval->inst, GNC_ID_COMMODITY, book);
    gnc_commodity_begin_edit(retval);
 
    if ( name_space != nullptr )
    {
    /* Prevent setting anything except template in namespace template. */
        if (g_strcmp0 (name_space, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
        g_strcmp0 (mnemonic, "template") != 0)
    {
        PWARN("Converting commodity %s from namespace template to "
          "namespace User", mnemonic);
        name_space = "User";
    }
        gnc_commodity_set_namespace(retval, name_space);
        if (gnc_commodity_namespace_is_iso(name_space))
        {
            gnc_commodity_set_quote_source(retval,
                                           gnc_quote_source_lookup_by_internal("currency") );
        }
    }
    gnc_commodity_set_fullname(retval, fullname);
    gnc_commodity_set_mnemonic(retval, mnemonic);
    gnc_commodity_set_cusip(retval, cusip);
    gnc_commodity_set_fraction(retval, fraction);
    mark_commodity_dirty (retval);
    gnc_commodity_commit_edit(retval);
 
    qof_event_gen (&retval->inst, QOF_EVENT_CREATE, nullptr);
 
    return retval;
}

gnc_commodity_obtain_twin()

gnc_commodity * gnc_commodity_obtain_twin	(	const gnc_commodity *	findlike,
		QofBook *	book
	)

Given the commodity 'findlike', this routine will find and return the equivalent commodity (commodity with the same 'unique name') in the indicated book.

This routine is primarily useful for setting up clones of things across multiple books.

Definition at line 1592 of file gnc-commodity.cpp.

{
    gnc_commodity *twin;
    const char * ucom;
    gnc_commodity_table * comtbl;
 
    if (!from) return nullptr;
    comtbl = gnc_commodity_table_get_table (book);
    if (!comtbl) return nullptr;
 
    ucom = gnc_commodity_get_unique_name (from);
    twin = gnc_commodity_table_lookup_unique (comtbl, ucom);
    if (!twin)
    {
        twin = gnc_commodity_clone (from, book);
        twin = gnc_commodity_table_insert (comtbl, twin);
    }
    return twin;
}

gnc_commodity_set_auto_quote_control_flag()

void gnc_commodity_set_auto_quote_control_flag	(	gnc_commodity *	cm,
		const gboolean	flag
	)

Definition at line 1235 of file gnc-commodity.cpp.

{
    ENTER ("(cm=%p, flag=%d)", cm, flag);
 
    if (!cm)
    {
        LEAVE("");
        return;
    }
    gnc_commodity_begin_edit(cm);
    auto val = flag ? std::nullopt : std::make_optional<const char*>(g_strdup("false"));
    qof_instance_set_path_kvp<const char*> (QOF_INSTANCE (cm), val, {"auto_quote_control"});
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
    LEAVE("");
}

gnc_commodity_set_cusip()

void gnc_commodity_set_cusip	(	gnc_commodity *	cm,
		const char *	cusip
	)

Set the 'exchange code' for the specified commodity.

This should be a pointer to a null terminated string of the form "AXQ14728", etc.

Note

This is a unique code that specifies a particular item or set of shares of a commodity, not a code that specifies a stock exchange. That is the namespace field.

Parameters

cm	A pointer to a commodity data structure.
cusip	A pointer to the cusip or other exchange specific data for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1199 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return;
 
    priv = GET_PRIVATE(cm);
    if (priv->cusip == cusip) return;
 
    gnc_commodity_begin_edit(cm);
    CACHE_REMOVE (priv->cusip);
    priv->cusip = CACHE_INSERT (cusip);
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_set_fraction()

void gnc_commodity_set_fraction	(	gnc_commodity *	cm,
		int	smallest_fraction
	)

Set the fraction for the specified commodity.

This should be an integer value specifying the number of fractional units that one of these commodities can be divided into. Should always be a power of 10.

Parameters

cm	A pointer to a commodity data structure.
smallest_fraction	The number of fractional units that one of these commodities can be divided into.

Definition at line 1221 of file gnc-commodity.cpp.

{
    if (!cm) return;
    gnc_commodity_begin_edit(cm);
    GET_PRIVATE(cm)->fraction = fraction;
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_set_fullname()

void gnc_commodity_set_fullname	(	gnc_commodity *	cm,
		const char *	fullname
	)

Set the full name for the specified commodity.

This should be a pointer to a null terminated string of the form "Acme Systems, Inc.", etc.

Parameters

cm	A pointer to a commodity data structure.
fullname	A pointer to the full name for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1177 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return;
    priv = GET_PRIVATE(cm);
    if (priv->fullname == fullname) return;
 
    CACHE_REMOVE (priv->fullname);
    priv->fullname = CACHE_INSERT (fullname);
 
    gnc_commodity_begin_edit(cm);
    mark_commodity_dirty(cm);
    reset_printname(priv);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_set_mnemonic()

void gnc_commodity_set_mnemonic	(	gnc_commodity *	cm,
		const char *	mnemonic
	)

Set the mnemonic for the specified commodity.

This should be a pointer to a null terminated string of the form "ACME", "QWER", etc.

Parameters

cm	A pointer to a commodity data structure.
mnemonic	A pointer to the mnemonic for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1124 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return;
    priv = GET_PRIVATE(cm);
    if (priv->mnemonic == mnemonic) return;
 
    gnc_commodity_begin_edit(cm);
    CACHE_REMOVE (priv->mnemonic);
    priv->mnemonic = CACHE_INSERT(mnemonic);
 
    mark_commodity_dirty (cm);
    reset_printname(priv);
    reset_unique_name(priv);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_set_namespace()

void gnc_commodity_set_namespace	(	gnc_commodity *	cm,
		const char *	new_namespace
	)

Set the namespace for the specified commodity.

This should be a pointer to a null terminated string of the form "AMEX", "NASDAQ", etc.

Parameters

cm	A pointer to a commodity data structure.
new_namespace	A pointer to the namespace for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1147 of file gnc-commodity.cpp.

{
    QofBook *book;
    gnc_commodity_table *table;
    gnc_commodity_namespace *nsp;
    gnc_commodityPrivate* priv;
 
    if (!cm) return;
    priv = GET_PRIVATE(cm);
    book = qof_instance_get_book (&cm->inst);
    table = gnc_commodity_table_get_table(book);
    nsp = gnc_commodity_table_add_namespace(table, name_space, book);
    if (priv->name_space == nsp)
        return;
 
    gnc_commodity_begin_edit(cm);
    priv->name_space = nsp;
    if (nsp->iso4217)
        priv->quote_source = gnc_quote_source_lookup_by_internal("currency");
    mark_commodity_dirty(cm);
    reset_printname(priv);
    reset_unique_name(priv);
    gnc_commodity_commit_edit(cm);
}

gnc_commodity_set_quote_flag()

void gnc_commodity_set_quote_flag	(	gnc_commodity *	cm,
		const gboolean	flag
	)

Set the automatic price quote flag for the specified commodity.

This flag indicates whether stock quotes should be retrieved for the specified stock.

Parameters

cm	A pointer to a commodity data structure.
flag	TRUE if quotes should be pulled for this commodity, FALSE otherwise.

Definition at line 1294 of file gnc-commodity.cpp.

{
    ENTER ("(cm=%p, flag=%d)", cm, flag);
 
    if (!cm) return;
    gnc_commodity_begin_edit(cm);
    GET_PRIVATE(cm)->quote_flag = flag;
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
    LEAVE(" ");
}

gnc_commodity_set_quote_source()

void gnc_commodity_set_quote_source	(	gnc_commodity *	cm,
		gnc_quote_source *	src
	)

Set the automatic price quote source for the specified commodity.

This should be a pointer to a null terminated string of the form "Yahoo (Asia)", etc. Legal values can be found in the quote_sources array in the file gnc-ui-util.c.

Parameters

cm	A pointer to a commodity data structure.
src	A pointer to the price quote source for this commodity.

Definition at line 1311 of file gnc-commodity.cpp.

{
    ENTER ("(cm=%p, src=%p(%s))", cm, src, src ? src->get_internal_name() : "unknown");
 
    if (!cm) return;
    gnc_commodity_begin_edit(cm);
    GET_PRIVATE(cm)->quote_source = src;
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
    LEAVE(" ");
}

gnc_commodity_set_quote_tz()

void gnc_commodity_set_quote_tz	(	gnc_commodity *	cm,
		const char *	tz
	)

Set the automatic price quote timezone for the specified commodity.

This should be a pointer to a null terminated string of the form "America/New_York", etc. Legal values can be found in the known_timezones array in the file src/gnome-utils/dialog-commodity.c.

Parameters

cm	A pointer to a commodity data structure.
tz	A pointer to the price quote timezone for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1328 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    if (!cm) return;
 
    ENTER ("(cm=%p, tz=%s)", cm, tz ? tz : "(null)");
 
    priv = GET_PRIVATE(cm);
 
    if (tz == priv->quote_tz)
    {
        LEAVE("Already correct TZ");
        return;
    }
 
    gnc_commodity_begin_edit(cm);
    CACHE_REMOVE (priv->quote_tz);
    priv->quote_tz = CACHE_INSERT (tz);
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
    LEAVE(" ");
}

gnc_commodity_set_user_symbol()

void gnc_commodity_set_user_symbol	(	gnc_commodity *	cm,
		const char *	user_symbol
	)

Set a user-defined symbol for the specified commodity.

This should be a pointer to a nul terminated string like "£", "US$", etc.

Parameters

cm	A pointer to a commodity data structure.
tz	A pointer to the symbol for this commodity. This string belongs to the caller and will be duplicated by the engine.

Definition at line 1357 of file gnc-commodity.cpp.

{
    struct lconv *lc;
 
    if (!cm) return;
 
    ENTER ("(cm=%p, symbol=%s)", cm, user_symbol ? user_symbol : "(null)");
 
    lc = gnc_localeconv();
    if (!user_symbol || !*user_symbol)
    user_symbol = nullptr;
    else if (!g_strcmp0(lc->int_curr_symbol, gnc_commodity_get_mnemonic(cm)) &&
         !g_strcmp0(lc->currency_symbol, user_symbol))
    /* if the user gives the ISO symbol for the locale currency or the
     * default symbol, actually remove the user symbol */
    user_symbol = nullptr;
    else if (!g_strcmp0(user_symbol, gnc_commodity_get_default_symbol(cm)))
    user_symbol = nullptr;
 
    gnc_commodity_begin_edit (cm);
 
    auto val = user_symbol ? std::make_optional<const char*>(g_strdup(user_symbol)) : std::nullopt;
    qof_instance_set_path_kvp<const char*> (QOF_INSTANCE(cm), val, {"user_symbol"});
 
    mark_commodity_dirty(cm);
    gnc_commodity_commit_edit(cm);
 
    LEAVE(" ");
}

gnc_commodity_table_add_default_data()

gboolean gnc_commodity_table_add_default_data	(	gnc_commodity_table *	table,
		QofBook *	book
	)

Add all the standard namespaces and currencies to the commodity table.

This routine creates the namespaces for the NYSE, NASDAQ, etc. It also adds all of the ISO 4217 currencies to the commodity table.

Parameters

table	A pointer to the commodity table.
book	Unused.

Definition at line 2319 of file gnc-commodity.cpp.

{
    QofCollection *col;
    gnc_commodity* c;
 
    ENTER ("table=%p", table);
    gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_TEMPLATE, book);
    c = gnc_commodity_new(book, "template", GNC_COMMODITY_NS_TEMPLATE, "template", "template", 1);
    gnc_commodity_table_insert(table, c);
 
#include "iso-4217-currencies.c"
 
    /* We've just created the default namespaces and currencies.  Mark
     * these collections as clean because there is no USER entered data
     * in these collections as of yet. */
    col = qof_book_get_collection(book, GNC_ID_COMMODITY);
    qof_collection_mark_clean(col);
    col = qof_book_get_collection(book, GNC_ID_COMMODITY_NAMESPACE);
    qof_collection_mark_clean(col);
 
    LEAVE ("table=%p", table);
    return TRUE;
}

gnc_commodity_table_add_namespace()

gnc_commodity_namespace * gnc_commodity_table_add_namespace	(	gnc_commodity_table *	table,
		const char *	commodity_namespace,
		QofBook *	book
	)

This function adds a new string to the list of commodity namespaces.

If the new namespace already exists, nothing happens.

Parameters

table	A pointer to the commodity table
commodity_namespace	The new namespace to be added.
book	The book that the new namespace will belong to.

Returns

A pointer to the newly created namespace.

Definition at line 2108 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * ns = nullptr;
 
    if (!table) return nullptr;
 
    name_space = gnc_commodity_table_map_namespace(name_space);
    ns = gnc_commodity_table_find_namespace(table, name_space);
    if (!ns)
    {
        ns = static_cast<gnc_commodity_namespace*>(g_object_new(GNC_TYPE_COMMODITY_NAMESPACE, nullptr));
        ns->cm_table = g_hash_table_new(g_str_hash, g_str_equal);
        ns->name = CACHE_INSERT(static_cast<const char*>(name_space));
        ns->iso4217 = gnc_commodity_namespace_is_iso(name_space);
        qof_instance_init_data (&ns->inst, GNC_ID_COMMODITY_NAMESPACE, book);
        qof_event_gen (&ns->inst, QOF_EVENT_CREATE, nullptr);
 
        g_hash_table_insert(table->ns_table,
                            (gpointer) ns->name,
                            (gpointer) ns);
        table->ns_list = g_list_append(table->ns_list, ns);
        qof_event_gen (&ns->inst, QOF_EVENT_ADD, nullptr);
    }
    return ns;
}

gnc_commodity_table_delete_namespace()

void gnc_commodity_table_delete_namespace	(	gnc_commodity_table *	table,
		const char *	commodity_namespace
	)

This function deletes a string from the list of commodity namespaces.

If the namespace does not exist, nothing happens.

Parameters

table	A pointer to the commodity table
commodity_namespace	The namespace to be deleted.

Note

This routine will destroy any commodities that exist as part of this namespace. Use it carefully.

Definition at line 2204 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * ns;
 
    if (!table) return;
 
    ns = gnc_commodity_table_find_namespace(table, name_space);
    if (!ns)
        return;
 
    qof_event_gen (&ns->inst, QOF_EVENT_REMOVE, nullptr);
    g_hash_table_remove(table->ns_table, name_space);
    table->ns_list = g_list_remove(table->ns_list, ns);
 
    g_list_free(ns->cm_list);
    ns->cm_list = nullptr;
 
    g_hash_table_foreach_remove(ns->cm_table, ns_helper, nullptr);
    g_hash_table_destroy(ns->cm_table);
    CACHE_REMOVE(ns->name);
 
    qof_event_gen (&ns->inst, QOF_EVENT_DESTROY, nullptr);
    /* qof_instance_release(&ns->inst); */
    g_object_unref(ns);
}

gnc_commodity_table_destroy()

void gnc_commodity_table_destroy

(

gnc_commodity_table *

table

)

Definition at line 2287 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * ns;
    GList *item, *next;
 
    if (!t) return;
    ENTER ("table=%p", t);
 
    for (item = t->ns_list; item; item = next)
    {
        next = g_list_next(item);
        ns = static_cast<gnc_commodity_namespace*>(item->data);
        gnc_commodity_table_delete_namespace(t, ns->name);
    }
 
    g_list_free(t->ns_list);
    t->ns_list = nullptr;
    g_hash_table_destroy(t->ns_table);
    t->ns_table = nullptr;
    LEAVE ("table=%p", t);
    g_free(t);
}

gnc_commodity_table_find_full()

gnc_commodity * gnc_commodity_table_find_full	(	const gnc_commodity_table *	t,
		const char *	commodity_namespace,
		const char *	fullname
	)

Definition at line 1720 of file gnc-commodity.cpp.

{
    gnc_commodity * retval = nullptr;
    GList         * all;
    GList         * iterator;
 
    if (!fullname || (fullname[0] == '\0'))
        return nullptr;
 
    all = gnc_commodity_table_get_commodities(table, name_space);
 
    for (iterator = all; iterator; iterator = iterator->next)
    {
        auto commodity = GNC_COMMODITY (iterator->data);
        if (!strcmp(fullname,
                    gnc_commodity_get_printname(commodity)))
        {
            retval = commodity;
            break;
        }
    }
 
    g_list_free (all);
 
    return retval;
}

gnc_commodity_table_find_namespace()

gnc_commodity_namespace * gnc_commodity_table_find_namespace	(	const gnc_commodity_table *	table,
		const char *	commodity_namespace
	)

This function finds a commodity namespace in the set of existing commodity namespaces.

Parameters

table	A pointer to the commodity table
commodity_namespace	The new namespace to be added.

Returns

The a pointer to the namespace found, or NULL if the namespace doesn't exist.

Definition at line 2169 of file gnc-commodity.cpp.

{
    if (!table || !name_space)
        return nullptr;
 
    name_space = gnc_commodity_table_map_namespace(name_space);
    return static_cast<gnc_commodity_namespace*>(g_hash_table_lookup(table->ns_table, (gpointer)name_space));
}

gnc_commodity_table_foreach_commodity()

gboolean gnc_commodity_table_foreach_commodity	(	const gnc_commodity_table *	table,
		gboolean(*)(gnc_commodity *cm, gpointer user_data)	f,
		gpointer	user_data
	)

Call a function once for each commodity in the commodity table.

This table walk returns whenever the end of the table is reached, or the function returns FALSE.

Parameters

table	A pointer to the commodity table
f	The function to call for each commodity.
user_data	A pointer that is passed into the function unchanged by the table walk routine.

gnc_commodity_table_get_commodities()

CommodityList * gnc_commodity_table_get_commodities	(	const gnc_commodity_table *	table,
		const char *	commodity_namespace
	)

Return a list of all commodities in the commodity table that are in the given namespace.

Parameters

table	A pointer to the commodity table
commodity_namespace	A string indicating which commodities should be returned. It is a required argument.

Returns

A pointer to the list of commodities. NULL if an invalid argument was supplied, or the namespace could not be found.

Note

It is the callers responsibility to free the list.

Definition at line 1991 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * ns = nullptr;
 
    if (!table)
        return nullptr;
    if (g_strcmp0(name_space, GNC_COMMODITY_NS_NONISO_GUI) == 0)
        return commodity_table_get_all_noncurrency_commodities(table);
    ns = gnc_commodity_table_find_namespace(table, name_space);
    if (!ns)
        return nullptr;
 
    return g_hash_table_values(ns->cm_table);
}

gnc_commodity_table_get_namespaces()

GList * gnc_commodity_table_get_namespaces

(

const gnc_commodity_table *

t

)

Return a list of all namespaces in the commodity table.

This returns both system and user defined namespaces.

Returns

A pointer to the list of names. NULL if an invalid argument was supplied.

Note

It is the callers responsibility to free the list.

Definition at line 1919 of file gnc-commodity.cpp.

{
    if (!table)
        return nullptr;
 
    return g_hash_table_keys(table->ns_table);
}

gnc_commodity_table_get_namespaces_list()

GList * gnc_commodity_table_get_namespaces_list

(

const gnc_commodity_table *

t

)

Return a list of all namespace data structures in the commodity table.

This returns both system and user defined namespace structures.

Returns

A pointer to the list of structures. NULL if an invalid argument was supplied.

Note

This list is owned by the caller who must free the list.

Definition at line 1928 of file gnc-commodity.cpp.

{
    if (!table)
        return nullptr;
 
    return g_list_copy (table->ns_list);
}

gnc_commodity_table_get_quotable_commodities()

CommodityList * gnc_commodity_table_get_quotable_commodities

(

const gnc_commodity_table *

table

)

This function returns a list of commodities for which price quotes should be retrieved.

It will scan the entire commodity table (or a subset) and check each commodity to see if the price_quote_flag field has been set. All matching commodities are queued onto a list, and the head of that list is returned. Use the command-line given expression as a filter on the commodities to be returned. If non-null, only commodities in namespace that match the specified regular expression are checked. If none was given, all commodities are checked.

Parameters

table

A pointer to the commodity table

Returns

A pointer to a list of commodities. NULL if invalid arguments were supplied or if there no commodities are flagged for quote retrieval.

Note

It is the callers responsibility to free the list.

Definition at line 2037 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * ns = nullptr;
    const char *name_space;
    GList * nslist, * tmp;
    GList * l = nullptr;
    regex_t pattern;
    const char *expression = gnc_prefs_get_namespace_regexp();
 
    ENTER("table=%p, expression=%s", table, expression);
    if (!table)
        return nullptr;
 
    if (expression && *expression)
    {
        if (regcomp(&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
        {
            LEAVE("Cannot compile regex");
            return nullptr;
        }
 
        nslist = gnc_commodity_table_get_namespaces(table);
        for (tmp = nslist; tmp; tmp = tmp->next)
        {
            name_space = static_cast<const char*>(tmp->data);
            if (regexec(&pattern, name_space, 0, nullptr, 0) == 0)
            {
                DEBUG("Running list of %s commodities", name_space);
                ns = gnc_commodity_table_find_namespace(table, name_space);
                if (ns)
                {
                    g_hash_table_foreach(ns->cm_table, &get_quotables_helper1, (gpointer) &l);
                }
            }
        }
        g_list_free(nslist);
        regfree(&pattern);
    }
    else
    {
        gnc_commodity_table_foreach_commodity(table, get_quotables_helper2,
                                              (gpointer) &l);
    }
    LEAVE("list head %p", l);
    return l;
}

gnc_commodity_table_get_size()

guint gnc_commodity_table_get_size

(

const gnc_commodity_table *

tbl

)

Returns the number of commodities in the commodity table.

Parameters

tbl	A pointer to the commodity table

Returns

The number of commodities in the table. 0 if there are no commodities, or the routine was passed a bad argument.

Definition at line 1635 of file gnc-commodity.cpp.

{
    guint count = 0;
    g_return_val_if_fail(tbl, 0);
    g_return_val_if_fail(tbl->ns_table, 0);
 
    g_hash_table_foreach(tbl->ns_table, count_coms, (gpointer)&count);
 
    return count;
}

gnc_commodity_table_get_table()

gnc_commodity_table * gnc_commodity_table_get_table

(

QofBook *

book

)

Returns the commodity table associated with a book.

Definition at line 1585 of file gnc-commodity.cpp.

{
    if (!book) return nullptr;
    return static_cast<gnc_commodity_table*>(qof_book_get_data (book, GNC_COMMODITY_TABLE));
}

gnc_commodity_table_has_namespace()

int gnc_commodity_table_has_namespace	(	const gnc_commodity_table *	table,
		const char *	commodity_namespace
	)

Test to see if the indicated namespace exits in the commodity table.

Parameters

table	A pointer to the commodity table
commodity_namespace	The new namespace to check.

Returns

1 if the namespace exists. 0 if it doesn't exist, or the routine was passed a bad argument.

Definition at line 1862 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * nsp = nullptr;
 
    if (!table || !name_space)
    {
        return 0;
    }
 
    nsp = gnc_commodity_table_find_namespace(table, name_space);
    if (nsp)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

gnc_commodity_table_insert()

gnc_commodity * gnc_commodity_table_insert	(	gnc_commodity_table *	table,
		gnc_commodity *	comm
	)

Add a new commodity to the commodity table.

This routine handles the cases where the commodity already exists in the database (does nothing), or another entries has the same namespace and mnemonic (updates the existing entry).

Parameters

table	A pointer to the commodity table
comm	A pointer to the commodity to add.

Returns

The added commodity. Null on error.

Note

The commodity pointer passed to this function should not be used after its return, as it may have been destroyed. Use the return value which is guaranteed to be valid.

Definition at line 1756 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * nsp = nullptr;
    gnc_commodity *c;
    const char *ns_name;
    gnc_commodityPrivate* priv;
    QofBook *book;
 
    if (!table) return nullptr;
    if (!comm) return nullptr;
 
    priv = GET_PRIVATE(comm);
 
    ENTER ("(table=%p, comm=%p) %s %s", table, comm,
           (priv->mnemonic == nullptr ? "(null)" : priv->mnemonic),
           (priv->fullname == nullptr ? "(null)" : priv->fullname));
    ns_name = gnc_commodity_namespace_get_name(priv->name_space);
    c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
 
    if (c)
    {
        if (c == comm)
        {
            LEAVE("already in table");
            return c;
        }
 
        /* Backward compatibility support for currencies that have
         * recently changed. */
        if (priv->name_space->iso4217)
        {
            auto it = gnc_new_iso_codes.find (priv->mnemonic);
            if (it != gnc_new_iso_codes.end())
                gnc_commodity_set_mnemonic(comm, it->second.c_str());
        }
        gnc_commodity_copy (c, comm);
        gnc_commodity_destroy (comm);
        LEAVE("found at %p", c);
        return c;
    }
 
    /* Prevent setting anything except template in namespace template. */
    if (g_strcmp0 (ns_name, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
    g_strcmp0 (priv->mnemonic, "template") != 0)
    {
    PWARN("Converting commodity %s from namespace template to "
          "namespace User", priv->mnemonic);
    gnc_commodity_set_namespace (comm, "User");
    ns_name = "User";
    mark_commodity_dirty (comm);
    }
 
    book = qof_instance_get_book (&comm->inst);
    nsp = gnc_commodity_table_add_namespace(table, ns_name, book);
 
    PINFO ("insert %p %s into nsp=%p %s", priv->mnemonic, priv->mnemonic,
           nsp->cm_table, nsp->name);
    g_hash_table_insert(nsp->cm_table,
                        (gpointer)CACHE_INSERT(priv->mnemonic),
                        (gpointer)comm);
    nsp->cm_list = g_list_append(nsp->cm_list, comm);
 
    qof_event_gen (&comm->inst, QOF_EVENT_ADD, nullptr);
    LEAVE ("(table=%p, comm=%p)", table, comm);
    return comm;
}

gnc_commodity_table_lookup()

gnc_commodity * gnc_commodity_table_lookup	(	const gnc_commodity_table *	table,
		const char *	commodity_namespace,
		const char *	mnemonic
	)

Definition at line 1652 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * nsp = nullptr;
 
    if (!table || !name_space || !mnemonic) return nullptr;
 
    nsp = gnc_commodity_table_find_namespace(table, name_space);
 
    if (nsp)
    {
        /*
         * Backward compatibility support for currencies that have
         * recently changed.
         */
        if (nsp->iso4217)
        {
            auto it = gnc_new_iso_codes.find (mnemonic);
            if (it != gnc_new_iso_codes.end())
                mnemonic = it->second.c_str();
        }
        return GNC_COMMODITY(g_hash_table_lookup(nsp->cm_table, (gpointer)mnemonic));
    }
    else
    {
        return nullptr;
    }
}

gnc_commodity_table_lookup_unique()

gnc_commodity * gnc_commodity_table_lookup_unique	(	const gnc_commodity_table *	table,
		const char *	unique_name
	)

Definition at line 1687 of file gnc-commodity.cpp.

{
    char *name_space;
    char *mnemonic;
    gnc_commodity *commodity;
 
    if (!table || !unique_name) return nullptr;
 
    name_space = g_strdup (unique_name);
    mnemonic = strstr (name_space, "::");
    if (!mnemonic)
    {
        g_free (name_space);
        return nullptr;
    }
 
    *mnemonic = '\0';
    mnemonic += 2;
 
    commodity = gnc_commodity_table_lookup (table, name_space, mnemonic);
 
    g_free (name_space);
 
    return commodity;
}

gnc_commodity_table_new()

gnc_commodity_table * gnc_commodity_table_new

(

void

)

You probably shouldn't be using gnc_commodity_table_new() directly, it's for internal use only.

You should probably be using gnc_commodity_table_get_table()

Definition at line 1572 of file gnc-commodity.cpp.

{
    gnc_commodity_table * retval = g_new0(gnc_commodity_table, 1);
    retval->ns_table = g_hash_table_new(&g_str_hash, &g_str_equal);
    retval->ns_list = nullptr;
    return retval;
}

gnc_commodity_table_register()

gboolean gnc_commodity_table_register

(

void

)

You should probably not be using gnc_commodity_table_register() It is an internal routine for registering the gncObject for the commodity table.

Definition at line 2428 of file gnc-commodity.cpp.

{
    if (!qof_object_register (&commodity_object_def))
        return FALSE;
    if (!qof_object_register (&namespace_object_def))
        return FALSE;
    return qof_object_register (&commodity_table_object_def);
}

gnc_commodity_table_remove()

void gnc_commodity_table_remove	(	gnc_commodity_table *	table,
		gnc_commodity *	comm
	)

Remove a commodity from the commodity table.

If the commodity to remove doesn't exist, nothing happens.

Parameters

table	A pointer to the commodity table
comm	A pointer to the commodity to remove.

Definition at line 1830 of file gnc-commodity.cpp.

{
    gnc_commodity_namespace * nsp;
    gnc_commodity *c;
    gnc_commodityPrivate* priv;
    const char *ns_name;
 
    if (!table) return;
    if (!comm) return;
 
    priv = GET_PRIVATE(comm);
    ns_name = gnc_commodity_namespace_get_name(priv->name_space);
    c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
    if (c != comm) return;
 
    qof_event_gen (&comm->inst, QOF_EVENT_REMOVE, nullptr);
 
    nsp = gnc_commodity_table_find_namespace(table, ns_name);
    if (!nsp) return;
 
    nsp->cm_list = g_list_remove(nsp->cm_list, comm);
    g_hash_table_remove (nsp->cm_table, priv->mnemonic);
    /* XXX minor mem leak, should remove the key as well */
}

gnc_commodity_table_rename_namespace()

bool gnc_commodity_table_rename_namespace	(	const gnc_commodity_table *	table,
		const char *	namespace_name,
		const char *	new_namespace_name
	)

This function renames a namespace.

Parameters

table	A pointer to the commodity table
namespace_name	The name of the namespace to rename.
new_namespace_name	The new name for the namespace.

Returns

Return true if rename successful.

Definition at line 2137 of file gnc-commodity.cpp.

{
    if (!table || !namespace_name || !new_namespace_name ||
        (g_strcmp0 (namespace_name, new_namespace_name) == 0) ||
        (g_strcmp0 (new_namespace_name, GNC_COMMODITY_NS_ISO_GUI) == 0) ||
        (g_strcmp0 (new_namespace_name, _(GNC_COMMODITY_NS_ISO_GUI)) == 0) ||
        gnc_commodity_table_find_namespace (table, new_namespace_name))
        return false;
 
    auto ns = gnc_commodity_table_find_namespace (table, namespace_name);
    if (!ns)
        return false;
 
    ns->name = CACHE_INSERT(static_cast<const char*>(new_namespace_name));
 
    g_hash_table_insert (table->ns_table,
                         (gpointer) ns->name,
                         (gpointer) ns);
 
    g_hash_table_remove (table->ns_table,
                         (gpointer) namespace_name);
 
    CACHE_REMOVE(namespace_name);
 
    qof_instance_set_dirty (&ns->inst);
    qof_event_gen (&ns->inst, QOF_EVENT_MODIFY, nullptr);
    return true;
}

gnc_commodity_user_set_quote_flag()

void gnc_commodity_user_set_quote_flag	(	gnc_commodity *	cm,
		const gboolean	flag
	)

Set the automatic price quote flag for the specified commodity, based on user input.

This flag indicates whether stock quotes should be retrieved for the specified stock.

It is necessary to have a separate function to distinguish when this setting is being modified by a user so that the auto-enabling/auto-disabling of currencies can be handled properly.

Parameters

cm	A pointer to a commodity data structure.
flag	TRUE if quotes should be pulled for this commodity, FALSE otherwise.

Definition at line 1258 of file gnc-commodity.cpp.

{
    gnc_commodityPrivate* priv;
 
    ENTER ("(cm=%p, flag=%d)", cm, flag);
 
    if (!cm)
    {
        LEAVE("");
        return;
    }
 
    priv = GET_PRIVATE(cm);
    gnc_commodity_begin_edit(cm);
    gnc_commodity_set_quote_flag(cm, flag);
    if (gnc_commodity_is_iso(cm))
    {
        /* For currencies, disable auto quote control if the quote flag is being
         * changed from its default value and enable it if the quote flag is being
         * reset to its default value.  The defaults for the quote flag are
         * disabled if no accounts are using the currency, and true otherwise.
         * Thus enable auto quote control if flag is FALSE and there are not any
         * accounts using this currency OR flag is TRUE and there are accounts
         * using this currency; otherwise disable auto quote control */
        gnc_commodity_set_auto_quote_control_flag(cm,
                (!flag && (priv->usage_count == 0)) || (flag && (priv->usage_count != 0)));
    }
    gnc_commodity_commit_edit(cm);
    LEAVE("");
}

gnc_monetary_list_add_monetary()

MonetaryList * gnc_monetary_list_add_monetary	(	MonetaryList *	list,
		gnc_monetary	mon
	)

Add a gnc_monetary to the list.

Definition at line 2443 of file gnc-commodity.cpp.

{
    MonetaryList *l = list, *tmp;
    for (tmp = list; tmp; tmp = tmp->next)
    {
        auto list_mon = static_cast<gnc_monetary*>(tmp->data);
        if (gnc_commodity_equiv(list_mon->commodity, add_mon.commodity))
        {
            list_mon->value = gnc_numeric_add(list_mon->value, add_mon.value,
                                              GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
            break;
        }
    }
 
    /* See if we found an entry, and add one if not */
    if (tmp == nullptr)
    {
        auto new_mon = static_cast<gnc_monetary*>(g_new0(gnc_monetary, 1));
        *new_mon = add_mon;
        l = g_list_prepend(l, new_mon);
    }
 
    return l;
}

gnc_monetary_list_delete_zeros()

MonetaryList * gnc_monetary_list_delete_zeros

(

MonetaryList *

list

)

Delete all the zero-value entries from a list.

Delete all the zero-value entries from a list.

Return list pointer will be a null pointer if there are no non-zero entries

Definition at line 2471 of file gnc-commodity.cpp.

{
    MonetaryList *node, *next;
    for (node = list; node; node = next)
    {
        auto mon = static_cast<gnc_monetary*>(node->data);
        next = node->next;
        if (gnc_numeric_zero_p(mon->value))
        {
            g_free(mon);
            list = g_list_delete_link(list, node);
        }
    }
    return list;
}

gnc_monetary_list_free()

void gnc_monetary_list_free

(

MonetaryList *

list

)

Free a monetary list and all the items it points to.

Free a monetary list and all the items it points to.

Definition at line 2489 of file gnc-commodity.cpp.

{
    MonetaryList *tmp;
    for (tmp = list; tmp; tmp = tmp->next)
    {
        g_free(tmp->data);
    }
 
    g_list_free(list);
}

gnc_quote_source_add_new()

gnc_quote_source * gnc_quote_source_add_new	(	const char *	name,
		gboolean	supported
	)

Create a new quote source.

This is called by the F::Q startup code or the XML parsing code to add new entries to the list of available quote sources.

Parameters

name	The internal name for this new quote source.
supported	TRUE if this quote source is supported by F::Q. Should only be set by the F::Q startup routine.

Returns

A pointer to the newly created quote source.

Definition at line 319 of file gnc-commodity.cpp.

{
    DEBUG("Creating new source %s", (!source_name ? "(null)" : source_name));
    /* This name can be changed if/when support for this price source is
     * integrated into gnucash. */
    /* This name is permanent and must be kept the same if/when support
     * for this price source is integrated into gnucash (i.e. for a
     * nice user name). */
    return &new_quote_sources.emplace_back (supported, SOURCE_UNKNOWN, source_name, source_name);
}

gnc_quote_source_fq_installed()

gboolean gnc_quote_source_fq_installed

(

void

)

This function indicates whether or not the Finance::Quote module is installed on a user's computer.

This includes any other related modules that gnucash need to process F::Q information.

Returns

TRUE is F::Q is installed properly.

Definition at line 267 of file gnc-commodity.cpp.

{
    return (!fq_version.empty());
}

gnc_quote_source_fq_version()

const char * gnc_quote_source_fq_version

(

void

)

This function returns the version of the Finance::Quote module installed on a user's computer.

If no proper installation is found it will return NULL.

Returns

a version string or NULL

Definition at line 280 of file gnc-commodity.cpp.

{
    return fq_version.c_str();
}

gnc_quote_source_get_index()

gint gnc_quote_source_get_index

(

const gnc_quote_source *

source

)

Given a gnc_quote_source data structure, return the index of this particular quote source within its type.

Parameters

source

The quote source in question.

Returns

The index of this quote source in its type.

Definition at line 390 of file gnc-commodity.cpp.

{
    if (!source)
    {
        PWARN ("bad source");
        return 0;
    }
 
    auto& sources = get_quote_source_from_type (source->get_type());
    auto is_source = [&source](const auto& findif_source)
    { return &findif_source == source; };
 
    auto iter = std::find_if (sources.begin(), sources.end(), is_source);
    if (iter != sources.end())
        return std::distance (sources.begin(), iter);
 
    PWARN ("couldn't locate source");
    return 0;
}

gnc_quote_source_get_internal_name()

const char * gnc_quote_source_get_internal_name

(

const gnc_quote_source *

source

)

Given a gnc_quote_source data structure, return the internal name of this quote source.

This is the name used by both gnucash and by Finance::Quote. E.G. "yahoo_australia" or "australia"

Parameters

source

The quote source in question.

Returns

The internal name.

Definition at line 438 of file gnc-commodity.cpp.

{
    ENTER("%p", source);
    if (!source)
    {
        LEAVE("bad source");
        return nullptr;
    }
    LEAVE("internal name %s", source->get_internal_name());
    return source->get_internal_name();
}

gnc_quote_source_get_supported()

gboolean gnc_quote_source_get_supported

(

const gnc_quote_source *

source

)

Given a gnc_quote_source data structure, return the flag that indicates whether this particular quote source is supported by the user's F::Q installation.

Parameters

source

The quote source in question.

Returns

TRUE if the user's computer supports this quote source.

Definition at line 411 of file gnc-commodity.cpp.

{
    ENTER("%p", source);
    if (!source)
    {
        LEAVE("bad source");
        return FALSE;
    }
 
    LEAVE("%s supported", source && source->get_supported() ? "" : "not ");
    return source->get_supported();
}

gnc_quote_source_get_type()

QuoteSourceType gnc_quote_source_get_type

(

const gnc_quote_source *

source

)

Given a gnc_quote_source data structure, return the type of this particular quote source.

(SINGLE, MULTI, UNKNOWN)

Parameters

source

The quote source in question.

Returns

The type of this quote source.

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

{
    ENTER("%p", source);
    if (!source)
    {
        LEAVE("bad source");
        return SOURCE_SINGLE;
    }
 
    LEAVE("type is %d", source->get_type());
    return source->get_type();
}

gnc_quote_source_get_user_name()

const char * gnc_quote_source_get_user_name

(

const gnc_quote_source *

source

)

Given a gnc_quote_source data structure, return the user friendly name of this quote source.

E.G. "Yahoo Australia" or "Australia (Yahoo, ASX, ...)"

Parameters

source

The quote source in question.

Returns

The user friendly name.

Definition at line 425 of file gnc-commodity.cpp.

{
    ENTER("%p", source);
    if (!source)
    {
        LEAVE("bad source");
        return nullptr;
    }
    LEAVE("user name %s", source->get_user_name());
    return source->get_user_name();
}

gnc_quote_source_lookup_by_internal()

gnc_quote_source * gnc_quote_source_lookup_by_internal

(

const char *

internal_name

)

Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by this name.

Parameters

internal_name

The name of this quote source.

Returns

A pointer to the price quote source that has the specified internal name.

Definition at line 352 of file gnc-commodity.cpp.

{
    if (!name || !*name)
        return nullptr;
 
    for (const auto& [_, sources] : quote_sources_map)
    {
        auto source_it = std::find_if (sources.begin(), sources.end(),
                                       [name] (const auto& qs)
                                       { return (g_strcmp0(name, qs.get_internal_name()) == 0); });
        if (source_it != sources.end())
            return &(*source_it);
    }
 
    DEBUG("gnc_quote_source_lookup_by_internal: Unknown source %s", name);
    return nullptr;
}

gnc_quote_source_lookup_by_ti()

gnc_quote_source * gnc_quote_source_lookup_by_ti	(	QuoteSourceType	type,
		gint	index
	)

Given the type/index of a quote source, find the data structure identified by this pair.

Parameters

type	The type of this quote source.
index	The index of this quote source within its type.

Returns

A pointer to the price quote source that has the specified type/index.

Definition at line 336 of file gnc-commodity.cpp.

{
    ENTER("type/index is %d/%d", type, index);
    auto& sources = get_quote_source_from_type (type);
    if ((size_t) index < sources.size())
    {
        auto it = std::next(sources.begin(), index);
        LEAVE("found %s", it->get_user_name());
        return &*it;
    }
 
    LEAVE("not found");
    return nullptr;
}

gnc_quote_source_num_entries()

gint gnc_quote_source_num_entries

(

QuoteSourceType

type

)

Return the number of entries for a given type of quote source.

Parameters

type	The quote source type whose count should be returned.

Returns

The number of entries for this type of quote source.

Definition at line 303 of file gnc-commodity.cpp.

{
    return get_quote_source_from_type(type).size();
}

gnc_quote_source_set_fq_installed()

void gnc_quote_source_set_fq_installed	(	const char *	version_string,
		const std::vector< std::string > &	sources_list
	)

Update gnucash internal tables based on what Finance::Quote sources are installed.

Sources that have been explicitly coded into gnucash are marked sensitive/insensitive based upon whether they are present. New sources that gnucash doesn't know about are added to its internal tables.

Parameters

sources_list

A list of strings containing the source names as they are known to F::Q.

Definition at line 458 of file gnc-commodity.cpp.

{
    ENTER(" ");
 
    if (sources_list.empty())
        return;
 
    if (version_string)
        fq_version = version_string;
    else
        fq_version.clear();
 
    for (const auto& source_name_str : sources_list)
    {
        auto source_name = source_name_str.c_str();
        auto source = gnc_quote_source_lookup_by_internal(source_name);
 
        if (source)
        {
            DEBUG("Found source %s: %s", source_name, source->get_user_name());
            source->set_supported (true);
            continue;
        }
 
        gnc_quote_source_add_new(source_name, TRUE);
    }
    LEAVE(" ");
}