GnuCash  5.6-150-g038405b370+
Files | Data Structures | Macros | Typedefs | Functions

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

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. More...
 
const char * gnc_quote_source_fq_version (void)
 This function returns the version of the Finance::Quote module installed on a user's computer. More...
 
gint gnc_quote_source_num_entries (QuoteSourceType type)
 Return the number of entries for a given type of quote source. More...
 
gnc_quote_source * gnc_quote_source_add_new (const char *name, gboolean supported)
 Create a new quote source. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

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. More...
 
void gnc_commodity_destroy (gnc_commodity *cm)
 Destroy a commodity. More...
 
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

const char * gnc_commodity_get_mnemonic (const gnc_commodity *cm)
 Retrieve the mnemonic for the specified commodity. More...
 
const char * gnc_commodity_get_namespace (const gnc_commodity *cm)
 Retrieve the namespace for the specified commodity. More...
 
gnc_commodity_namespace * gnc_commodity_get_namespace_ds (const gnc_commodity *cm)
 Retrieve the namespace data structure for the specified commodity. More...
 
const char * gnc_commodity_get_fullname (const gnc_commodity *cm)
 Retrieve the full name for the specified commodity. More...
 
const char * gnc_commodity_get_printname (const gnc_commodity *cm)
 Retrieve the 'print' name for the specified commodity. More...
 
const char * gnc_commodity_get_cusip (const gnc_commodity *cm)
 Retrieve the 'exchange code' for the specified commodity. More...
 
const char * gnc_commodity_get_unique_name (const gnc_commodity *cm)
 Retrieve the 'unique' name for the specified commodity. More...
 
int gnc_commodity_get_fraction (const gnc_commodity *cm)
 Retrieve the fraction for the specified commodity. More...
 
gboolean gnc_commodity_get_quote_flag (const gnc_commodity *cm)
 Retrieve the automatic price quote flag for the specified commodity. More...
 
gnc_quote_source * gnc_commodity_get_quote_source (const gnc_commodity *cm)
 Retrieve the automatic price quote source for the specified commodity. More...
 
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. More...
 
const char * gnc_commodity_get_user_symbol (const gnc_commodity *cm)
 Retrieve the user-defined symbol for the specified commodity. More...
 
const char * gnc_commodity_get_default_symbol (const gnc_commodity *cm)
 Retrieve the default symbol for the specified commodity. More...
 
const char * gnc_commodity_get_nice_symbol (const gnc_commodity *cm)
 Retrieve a symbol for the specified commodity, suitable for display to the user. More...
 

Commodity Accessor Routines - Set

void gnc_commodity_set_mnemonic (gnc_commodity *cm, const char *mnemonic)
 Set the mnemonic for the specified commodity. More...
 
void gnc_commodity_set_namespace (gnc_commodity *cm, const char *new_namespace)
 Set the namespace for the specified commodity. More...
 
void gnc_commodity_set_fullname (gnc_commodity *cm, const char *fullname)
 Set the full name for the specified commodity. More...
 
void gnc_commodity_set_cusip (gnc_commodity *cm, const char *cusip)
 Set the 'exchange code' for the specified commodity. More...
 
void gnc_commodity_set_fraction (gnc_commodity *cm, int smallest_fraction)
 Set the fraction for the specified commodity. More...
 
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. More...
 
void gnc_commodity_set_quote_flag (gnc_commodity *cm, const gboolean flag)
 Set the automatic price quote flag for the specified commodity. More...
 
void gnc_commodity_set_quote_source (gnc_commodity *cm, gnc_quote_source *src)
 Set the automatic price quote source for the specified commodity. More...
 
void gnc_commodity_set_quote_tz (gnc_commodity *cm, const char *tz)
 Set the automatic price quote timezone for the specified commodity. More...
 
void gnc_commodity_set_user_symbol (gnc_commodity *cm, const char *user_symbol)
 Set a user-defined symbol for the specified commodity. More...
 

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. More...
 
void gnc_commodity_decrement_usage_count (gnc_commodity *cm)
 Decrement a commodity's internal counter that tracks how many accounts are using that commodity. More...
 

Commodity Comparison

gboolean gnc_commodity_equiv (const gnc_commodity *a, const gnc_commodity *b)
 This routine returns TRUE if the two commodities are equivalent. More...
 
gboolean gnc_commodity_equal (const gnc_commodity *a, const gnc_commodity *b)
 This routine returns TRUE if the two commodities are equal. More...
 
int gnc_commodity_compare (const gnc_commodity *a, const gnc_commodity *b)
 This routine returns 0 if the two commodities are equal, 1 otherwise. More...
 
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. More...
 
gboolean gnc_commodity_is_iso (const gnc_commodity *cm)
 Checks to see if the specified commodity is an ISO 4217 recognized currency. More...
 
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. More...
 

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. More...
 
void gnc_commodity_table_remove (gnc_commodity_table *table, gnc_commodity *comm)
 Remove a commodity from the commodity table. More...
 
gboolean gnc_commodity_table_add_default_data (gnc_commodity_table *table, QofBook *book)
 Add all the standard namespaces and currencies to the commodity table. More...
 

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. More...
 
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. More...
 
GList * gnc_commodity_namespace_get_commodity_list (const gnc_commodity_namespace *ns)
 Return a list of all commodity data structures in the specified namespace. More...
 
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. More...
 
GList * gnc_commodity_table_get_namespaces (const gnc_commodity_table *t)
 Return a list of all namespaces in the commodity table. More...
 
GList * gnc_commodity_table_get_namespaces_list (const gnc_commodity_table *t)
 Return a list of all namespace data structures in the commodity table. More...
 
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. More...
 
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. More...
 
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. More...
 

Commodity Table Accessor functions

guint gnc_commodity_table_get_size (const gnc_commodity_table *tbl)
 Returns the number of commodities in the commodity table. More...
 
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. More...
 
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. More...
 
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. More...
 

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

Monetary value, commodity identity and numeric value

typedef GList MonetaryList
 

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. More...
 
void gnc_monetary_list_free (MonetaryList *list)
 Free a monetary list and all the items it points to. More...
 

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

Enumeration Type Documentation

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

129 {
130  SOURCE_SINGLE = 0,
134  SOURCE_MULTI,
141  SOURCE_MAX,
142  SOURCE_CURRENCY = SOURCE_MAX,
This quote source pulls from a single specific web site.
The special currency quote source.
This is a locally installed quote source that gnucash knows nothing about.
QuoteSourceType
The quote source type enum account types are used to determine how the transaction data in the accoun...
This quote source may pull from multiple web sites.

Function Documentation

◆ 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 1534 of file gnc-commodity.cpp.

1535 {
1536  if (a == b) return 0;
1537  if (a && !b) return 1;
1538  if (b && !a) return -1;
1539  return qof_instance_guid_compare(a, b);
1540 }
gint qof_instance_guid_compare(gconstpointer ptr1, gconstpointer ptr2)
Compare the GncGUID values of two instances.

◆ 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
cmA pointer to a commodity data structure.

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

1468 {
1469  gnc_commodityPrivate* priv;
1470 
1471  ENTER("(cm=%p)", cm);
1472 
1473  if (!cm)
1474  {
1475  LEAVE("");
1476  return;
1477  }
1478 
1479  priv = GET_PRIVATE(cm);
1480 
1481  if (priv->usage_count == 0)
1482  {
1483  PWARN("usage_count already zero");
1484  LEAVE("");
1485  return;
1486  }
1487 
1488  priv->usage_count--;
1489  if ((priv->usage_count == 0) && priv->quote_flag
1490  && gnc_commodity_get_auto_quote_control_flag(cm)
1491  && gnc_commodity_is_iso(cm))
1492  {
1493  /* if this is a currency with auto quote control enabled and no more
1494  * accounts reference this currency, disable quote retrieval */
1495  gnc_commodity_set_quote_flag(cm, FALSE);
1496  }
1497  LEAVE("(usage_count=%d)", priv->usage_count);
1498 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ 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
cmThe commodity to destroy.

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

871 {
872  gnc_commodity_begin_edit(cm);
873  qof_instance_set_destroying(cm, TRUE);
874  gnc_commodity_commit_edit(cm);
875 }

◆ 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 1527 of file gnc-commodity.cpp.

1528 {
1529  return gnc_commodity_compare(a, b) == 0;
1530 }
int gnc_commodity_compare(const gnc_commodity *a, const gnc_commodity *b)
This routine returns 0 if the two commodities are equal, 1 otherwise.

◆ 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 1510 of file gnc-commodity.cpp.

1511 {
1512  gnc_commodityPrivate* priv_a;
1513  gnc_commodityPrivate* priv_b;
1514 
1515  if (a == b) return TRUE;
1516  if (!a || !b) return FALSE;
1517 
1518  priv_a = GET_PRIVATE(a);
1519  priv_b = GET_PRIVATE(b);
1520  if (priv_a->name_space != priv_b->name_space) return FALSE;
1521  if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0) return FALSE;
1522 
1523  return TRUE;
1524 }

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

996 {
997  if (!cm) return nullptr;
998  return GET_PRIVATE(cm)->cusip;
999 }

◆ 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
cmA pointer to a commodity data structure.
Returns
A pointer to the default symbol for this commodity.

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

1098 {
1099  if (!cm) return nullptr;
1100  return GET_PRIVATE(cm)->default_symbol;
1101 }

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

1007 {
1008  if (!cm) return 0;
1009  return GET_PRIVATE(cm)->fraction;
1010 }

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

972 {
973  if (!cm) return nullptr;
974  return GET_PRIVATE(cm)->fullname;
975 }

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

931 {
932  if (!cm) return nullptr;
933  return GET_PRIVATE(cm)->mnemonic;
934 }

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

954 {
955  if (!cm) return nullptr;
956  return gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
957 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.

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

961 {
962  if (!cm) return nullptr;
963  return GET_PRIVATE(cm)->name_space;
964 }

◆ 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
cmA pointer to a commodity data structure.
Returns
A pointer to the symbol for this commodity.

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

1108 {
1109  const char *nice_symbol;
1110  struct lconv *lc;
1111  if (!cm) return nullptr;
1112 
1113  nice_symbol = gnc_commodity_get_user_symbol(cm);
1114  if (nice_symbol && *nice_symbol)
1115  return nice_symbol;
1116 
1117  lc = gnc_localeconv();
1118  nice_symbol = lc->currency_symbol;
1119  if (!g_strcmp0(gnc_commodity_get_mnemonic(cm), lc->int_curr_symbol))
1120  return nice_symbol;
1121 
1122  nice_symbol = gnc_commodity_get_default_symbol(cm);
1123  if (nice_symbol && *nice_symbol)
1124  return nice_symbol;
1125 
1126  return gnc_commodity_get_mnemonic(cm);
1127 }
const char * gnc_commodity_get_mnemonic(const gnc_commodity *cm)
Retrieve the mnemonic 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.

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

942 {
943  if (!cm) return nullptr;
944  return GET_PRIVATE(cm)->printname;
945 }

◆ 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
cmA pointer to a commodity data structure.
Returns
TRUE if quotes should be pulled for this commodity, FALSE otherwise.

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

1037 {
1038  if (!cm) return FALSE;
1039  return (GET_PRIVATE(cm)->quote_flag);
1040 }

◆ 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
cmA pointer to a commodity data structure.
Returns
A pointer to the price quote source for this commodity.

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

1048 {
1049  gnc_commodityPrivate* priv;
1050 
1051  if (!cm) return nullptr;
1052  priv = GET_PRIVATE(cm);
1053  if (!priv->quote_source && gnc_commodity_is_iso(cm))
1054  return &currency_quote_sources.front();
1055  return priv->quote_source;
1056 }
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ 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
cmA 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 1072 of file gnc-commodity.cpp.

1073 {
1074  if (!cm) return nullptr;
1075  return GET_PRIVATE(cm)->quote_tz;
1076 }

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

984 {
985  if (!cm) return nullptr;
986  return GET_PRIVATE(cm)->unique_name;
987 }

◆ 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
cmA 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 1082 of file gnc-commodity.cpp.

1083 {
1084  g_return_val_if_fail (GNC_IS_COMMODITY (cm), nullptr);
1085 
1086  GValue v = G_VALUE_INIT;
1087  qof_instance_get_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1088  const char *rv = G_VALUE_HOLDS_STRING (&v) ? g_value_get_string (&v) : nullptr;
1089  g_value_unset (&v);
1090  return rv;
1091 }
void qof_instance_get_kvp(QofInstance *, GValue *value, unsigned count,...)
Retrieves the contents of a KVP slot into a provided GValue.

◆ 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
cmA pointer to a commodity data structure.

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

1433 {
1434  gnc_commodityPrivate* priv;
1435 
1436  ENTER("(cm=%p)", cm);
1437 
1438  if (!cm)
1439  {
1440  LEAVE("");
1441  return;
1442  }
1443 
1444  priv = GET_PRIVATE(cm);
1445 
1446  if ((priv->usage_count == 0) && !priv->quote_flag
1447  && gnc_commodity_get_auto_quote_control_flag(cm)
1448  && gnc_commodity_is_iso(cm))
1449  {
1450  /* compatibility hack - Gnucash 1.8 gets currency quotes when a
1451  non-default currency is assigned to an account. */
1452  gnc_commodity_begin_edit(cm);
1453  gnc_commodity_set_quote_flag(cm, TRUE);
1455  gnc_commodity_get_default_quote_source(cm));
1456  gnc_commodity_commit_edit(cm);
1457  }
1458  priv->usage_count++;
1459  LEAVE("(usage_count=%d)", priv->usage_count);
1460 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
void gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src)
Set the automatic price quote source for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ 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
cmThe commodity to check.
Returns
TRUE if the commodity represents a currency, FALSE otherwise.

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

1984 {
1985  const char *ns_name;
1986  if (!cm) return FALSE;
1987 
1988  ns_name = gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
1989  return (!g_strcmp0(ns_name, GNC_COMMODITY_NS_LEGACY) ||
1990  !g_strcmp0(ns_name, GNC_COMMODITY_NS_CURRENCY));
1991 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
#define GNC_COMMODITY_NS_LEGACY
The commodity namespace definitions are used to tag a commodity by its type, or a stocks by the excha...

◆ 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
cmThe commodity to check.
Returns
TRUE if the commodity represents a currency, FALSE otherwise.

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

1972 {
1973  gnc_commodityPrivate* priv;
1974 
1975  if (!cm) return FALSE;
1976 
1977  priv = GET_PRIVATE(cm);
1978  if ( !priv->name_space) return FALSE;
1979  return priv->name_space->iso4217;
1980 }

◆ 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 1571 of file gnc-commodity.cpp.

1572 {
1573  if (!name_space)
1574  return nullptr;
1575 
1576  return g_list_copy (name_space->cm_list);
1577 }

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

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 1561 of file gnc-commodity.cpp.

1562 {
1563  if (ns == nullptr)
1564  return nullptr;
1565  if (g_strcmp0 (ns->name, GNC_COMMODITY_NS_CURRENCY) == 0)
1566  return GNC_COMMODITY_NS_ISO_GUI;
1567  return ns->name;
1568 }

◆ 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
nsA 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 1553 of file gnc-commodity.cpp.

1554 {
1555  if (ns == nullptr)
1556  return nullptr;
1557  return ns->name;
1558 }

◆ 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_namespaceThe string to check.
Returns
TRUE if the string indicates an ISO currency, FALSE otherwise.

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

1581 {
1582  return ((g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0) ||
1583  (g_strcmp0(name_space, GNC_COMMODITY_NS_CURRENCY) == 0));
1584 }

◆ 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
bookThe book that the new commodity will belong to.
fullnameThe complete name of this commodity. E.G. "Acme Systems, Inc."
commodity_namespaceAn aggregation of commodities. E.G. ISO4217, Nasdaq, Downbelow, etc.
mnemonicAn 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.
cusipA 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.
fractionThe 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.

780 {
781  auto retval = GNC_COMMODITY(g_object_new(GNC_TYPE_COMMODITY, nullptr));
782 
783  qof_instance_init_data (&retval->inst, GNC_ID_COMMODITY, book);
784  gnc_commodity_begin_edit(retval);
785 
786  if ( name_space != nullptr )
787  {
788  /* Prevent setting anything except template in namespace template. */
789  if (g_strcmp0 (name_space, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
790  g_strcmp0 (mnemonic, "template") != 0)
791  {
792  PWARN("Converting commodity %s from namespace template to "
793  "namespace User", mnemonic);
794  name_space = "User";
795  }
796  gnc_commodity_set_namespace(retval, name_space);
797  if (gnc_commodity_namespace_is_iso(name_space))
798  {
801  }
802  }
803  gnc_commodity_set_fullname(retval, fullname);
804  gnc_commodity_set_mnemonic(retval, mnemonic);
805  gnc_commodity_set_cusip(retval, cusip);
806  gnc_commodity_set_fraction(retval, fraction);
807  mark_commodity_dirty (retval);
808  gnc_commodity_commit_edit(retval);
809 
810  qof_event_gen (&retval->inst, QOF_EVENT_CREATE, nullptr);
811 
812  return retval;
813 }
void gnc_commodity_set_fraction(gnc_commodity *cm, int fraction)
Set the fraction for the specified commodity.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void qof_instance_init_data(QofInstance *inst, QofIdType type, QofBook *book)
Initialise the settings associated with an instance.
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_cusip(gnc_commodity *cm, const char *cusip)
Set the &#39;exchange code&#39; for the specified commodity.
gboolean gnc_commodity_namespace_is_iso(const char *name_space)
Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.
gnc_quote_source * gnc_quote_source_lookup_by_internal(const char *name)
Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by th...
void gnc_commodity_set_fullname(gnc_commodity *cm, const char *fullname)
Set the full name for the specified commodity.
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 *name_space)
Set the namespace for the specified commodity.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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 1620 of file gnc-commodity.cpp.

1621 {
1622  gnc_commodity *twin;
1623  const char * ucom;
1624  gnc_commodity_table * comtbl;
1625 
1626  if (!from) return nullptr;
1627  comtbl = gnc_commodity_table_get_table (book);
1628  if (!comtbl) return nullptr;
1629 
1630  ucom = gnc_commodity_get_unique_name (from);
1631  twin = gnc_commodity_table_lookup_unique (comtbl, ucom);
1632  if (!twin)
1633  {
1634  twin = gnc_commodity_clone (from, book);
1635  twin = gnc_commodity_table_insert (comtbl, twin);
1636  }
1637  return twin;
1638 }
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table *table, gnc_commodity *comm)
Add a new commodity to the commodity table.
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
gnc_commodity * gnc_commodity_clone(const gnc_commodity *src, QofBook *dest_book)
allocate and copy
const char * gnc_commodity_get_unique_name(const gnc_commodity *cm)
Retrieve the &#39;unique&#39; name for the specified commodity.

◆ 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
cmA pointer to a commodity data structure.
cusipA 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 1209 of file gnc-commodity.cpp.

1211 {
1212  gnc_commodityPrivate* priv;
1213 
1214  if (!cm) return;
1215 
1216  priv = GET_PRIVATE(cm);
1217  if (priv->cusip == cusip) return;
1218 
1219  gnc_commodity_begin_edit(cm);
1220  CACHE_REMOVE (priv->cusip);
1221  priv->cusip = CACHE_INSERT (cusip);
1222  mark_commodity_dirty(cm);
1223  gnc_commodity_commit_edit(cm);
1224 }

◆ 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
cmA pointer to a commodity data structure.
smallest_fractionThe number of fractional units that one of these commodities can be divided into.

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

1232 {
1233  if (!cm) return;
1234  gnc_commodity_begin_edit(cm);
1235  GET_PRIVATE(cm)->fraction = fraction;
1236  mark_commodity_dirty(cm);
1237  gnc_commodity_commit_edit(cm);
1238 }

◆ 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
cmA pointer to a commodity data structure.
fullnameA pointer to the full name for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1188 {
1189  gnc_commodityPrivate* priv;
1190 
1191  if (!cm) return;
1192  priv = GET_PRIVATE(cm);
1193  if (priv->fullname == fullname) return;
1194 
1195  CACHE_REMOVE (priv->fullname);
1196  priv->fullname = CACHE_INSERT (fullname);
1197 
1198  gnc_commodity_begin_edit(cm);
1199  mark_commodity_dirty(cm);
1200  reset_printname(priv);
1201  gnc_commodity_commit_edit(cm);
1202 }

◆ 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
cmA pointer to a commodity data structure.
mnemonicA pointer to the mnemonic for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1135 {
1136  gnc_commodityPrivate* priv;
1137 
1138  if (!cm) return;
1139  priv = GET_PRIVATE(cm);
1140  if (priv->mnemonic == mnemonic) return;
1141 
1142  gnc_commodity_begin_edit(cm);
1143  CACHE_REMOVE (priv->mnemonic);
1144  priv->mnemonic = CACHE_INSERT(mnemonic);
1145 
1146  mark_commodity_dirty (cm);
1147  reset_printname(priv);
1148  reset_unique_name(priv);
1149  gnc_commodity_commit_edit(cm);
1150 }

◆ 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
cmA pointer to a commodity data structure.
new_namespaceA pointer to the namespace for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1158 {
1159  QofBook *book;
1160  gnc_commodity_table *table;
1161  gnc_commodity_namespace *nsp;
1162  gnc_commodityPrivate* priv;
1163 
1164  if (!cm) return;
1165  priv = GET_PRIVATE(cm);
1166  book = qof_instance_get_book (&cm->inst);
1168  nsp = gnc_commodity_table_add_namespace(table, name_space, book);
1169  if (priv->name_space == nsp)
1170  return;
1171 
1172  gnc_commodity_begin_edit(cm);
1173  priv->name_space = nsp;
1174  if (nsp->iso4217)
1175  priv->quote_source = gnc_quote_source_lookup_by_internal("currency");
1176  mark_commodity_dirty(cm);
1177  reset_printname(priv);
1178  reset_unique_name(priv);
1179  gnc_commodity_commit_edit(cm);
1180 }
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book)
Returns the commodity table associated with a book.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table *table, const char *name_space, QofBook *book)
This function adds a new string to the list of commodity namespaces.
gnc_quote_source * gnc_quote_source_lookup_by_internal(const char *name)
Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by th...

◆ 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
cmA pointer to a commodity data structure.
flagTRUE if quotes should be pulled for this commodity, FALSE otherwise.

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

1313 {
1314  ENTER ("(cm=%p, flag=%d)", cm, flag);
1315 
1316  if (!cm) return;
1317  gnc_commodity_begin_edit(cm);
1318  GET_PRIVATE(cm)->quote_flag = flag;
1319  mark_commodity_dirty(cm);
1320  gnc_commodity_commit_edit(cm);
1321  LEAVE(" ");
1322 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
cmA pointer to a commodity data structure.
srcA pointer to the price quote source for this commodity.

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

1330 {
1331  ENTER ("(cm=%p, src=%p(%s))", cm, src, src ? src->get_internal_name() : "unknown");
1332 
1333  if (!cm) return;
1334  gnc_commodity_begin_edit(cm);
1335  GET_PRIVATE(cm)->quote_source = src;
1336  mark_commodity_dirty(cm);
1337  gnc_commodity_commit_edit(cm);
1338  LEAVE(" ");
1339 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
cmA pointer to a commodity data structure.
tzA 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 1346 of file gnc-commodity.cpp.

1347 {
1348  gnc_commodityPrivate* priv;
1349 
1350  if (!cm) return;
1351 
1352  ENTER ("(cm=%p, tz=%s)", cm, tz ? tz : "(null)");
1353 
1354  priv = GET_PRIVATE(cm);
1355 
1356  if (tz == priv->quote_tz)
1357  {
1358  LEAVE("Already correct TZ");
1359  return;
1360  }
1361 
1362  gnc_commodity_begin_edit(cm);
1363  CACHE_REMOVE (priv->quote_tz);
1364  priv->quote_tz = CACHE_INSERT (tz);
1365  mark_commodity_dirty(cm);
1366  gnc_commodity_commit_edit(cm);
1367  LEAVE(" ");
1368 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
cmA pointer to a commodity data structure.
tzA pointer to the symbol for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1376 {
1377  struct lconv *lc;
1378 
1379  if (!cm) return;
1380 
1381  ENTER ("(cm=%p, symbol=%s)", cm, user_symbol ? user_symbol : "(null)");
1382 
1383  lc = gnc_localeconv();
1384  if (!user_symbol || !*user_symbol)
1385  user_symbol = nullptr;
1386  else if (!g_strcmp0(lc->int_curr_symbol, gnc_commodity_get_mnemonic(cm)) &&
1387  !g_strcmp0(lc->currency_symbol, user_symbol))
1388  /* if the user gives the ISO symbol for the locale currency or the
1389  * default symbol, actually remove the user symbol */
1390  user_symbol = nullptr;
1391  else if (!g_strcmp0(user_symbol, gnc_commodity_get_default_symbol(cm)))
1392  user_symbol = nullptr;
1393 
1394  gnc_commodity_begin_edit (cm);
1395 
1396  if (user_symbol)
1397  {
1398  GValue v = G_VALUE_INIT;
1399  g_value_init (&v, G_TYPE_STRING);
1400  g_value_set_static_string (&v, user_symbol);
1401  qof_instance_set_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1402  g_value_unset (&v);
1403  }
1404  else
1405  {
1406  qof_instance_set_kvp (QOF_INSTANCE(cm), nullptr, 1, "user_symbol");
1407  }
1408 
1409  mark_commodity_dirty(cm);
1410  gnc_commodity_commit_edit(cm);
1411 
1412  LEAVE(" ");
1413 }
void qof_instance_set_kvp(QofInstance *, GValue const *value, unsigned count,...)
Sets a KVP slot to a value from a GValue.
const char * gnc_commodity_get_mnemonic(const gnc_commodity *cm)
Retrieve the mnemonic for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
const char * gnc_commodity_get_default_symbol(const gnc_commodity *cm)
Retrieve the default symbol for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
tableA pointer to the commodity table.
bookUnused.

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

2317 {
2318  QofCollection *col;
2319  gnc_commodity* c;
2320 
2321  ENTER ("table=%p", table);
2322  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_TEMPLATE, book);
2323  c = gnc_commodity_new(book, "template", GNC_COMMODITY_NS_TEMPLATE, "template", "template", 1);
2325 
2326 #include "iso-4217-currencies.c"
2327 
2328  /* We've just created the default namespaces and currencies. Mark
2329  * these collections as clean because there is no USER entered data
2330  * in these collections as of yet. */
2331  col = qof_book_get_collection(book, GNC_ID_COMMODITY);
2333  col = qof_book_get_collection(book, GNC_ID_COMMODITY_NAMESPACE);
2335 
2336  LEAVE ("table=%p", table);
2337  return TRUE;
2338 }
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table *table, gnc_commodity *comm)
Add a new commodity to the commodity table.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table *table, const char *name_space, QofBook *book)
This function adds a new string to the list of commodity namespaces.
gnc_commodity * gnc_commodity_new(QofBook *book, const char *fullname, const char *name_space, const char *mnemonic, const char *cusip, int fraction)
Create a new commodity.
void qof_collection_mark_clean(QofCollection *)
reset value of dirty flag
Definition: qofid.cpp:261
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:521

◆ 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
tableA pointer to the commodity table
commodity_namespaceThe new namespace to be added.
bookThe book that the new namespace will belong to.
Returns
A pointer to the newly created namespace.

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

2139 {
2140  gnc_commodity_namespace * ns = nullptr;
2141 
2142  if (!table) return nullptr;
2143 
2144  name_space = gnc_commodity_table_map_namespace(name_space);
2145  ns = gnc_commodity_table_find_namespace(table, name_space);
2146  if (!ns)
2147  {
2148  ns = static_cast<gnc_commodity_namespace*>(g_object_new(GNC_TYPE_COMMODITY_NAMESPACE, nullptr));
2149  ns->cm_table = g_hash_table_new(g_str_hash, g_str_equal);
2150  ns->name = CACHE_INSERT(static_cast<const char*>(name_space));
2151  ns->iso4217 = gnc_commodity_namespace_is_iso(name_space);
2152  qof_instance_init_data (&ns->inst, GNC_ID_COMMODITY_NAMESPACE, book);
2153  qof_event_gen (&ns->inst, QOF_EVENT_CREATE, nullptr);
2154 
2155  g_hash_table_insert(table->ns_table,
2156  (gpointer) ns->name,
2157  (gpointer) ns);
2158  table->ns_list = g_list_append(table->ns_list, ns);
2159  qof_event_gen (&ns->inst, QOF_EVENT_ADD, nullptr);
2160  }
2161  return ns;
2162 }
void qof_instance_init_data(QofInstance *inst, QofIdType type, QofBook *book)
Initialise the settings associated with an instance.
gboolean gnc_commodity_namespace_is_iso(const char *name_space)
Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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
tableA pointer to the commodity table
commodity_namespaceThe namespace to be deleted.
Note
This routine will destroy any commodities that exist as part of this namespace. Use it carefully.

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

2203 {
2204  gnc_commodity_namespace * ns;
2205 
2206  if (!table) return;
2207 
2208  ns = gnc_commodity_table_find_namespace(table, name_space);
2209  if (!ns)
2210  return;
2211 
2212  qof_event_gen (&ns->inst, QOF_EVENT_REMOVE, nullptr);
2213  g_hash_table_remove(table->ns_table, name_space);
2214  table->ns_list = g_list_remove(table->ns_list, ns);
2215 
2216  g_list_free(ns->cm_list);
2217  ns->cm_list = nullptr;
2218 
2219  g_hash_table_foreach_remove(ns->cm_table, ns_helper, nullptr);
2220  g_hash_table_destroy(ns->cm_table);
2221  CACHE_REMOVE(ns->name);
2222 
2223  qof_event_gen (&ns->inst, QOF_EVENT_DESTROY, nullptr);
2224  /* qof_instance_release(&ns->inst); */
2225  g_object_unref(ns);
2226 }
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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
tableA pointer to the commodity table
commodity_namespaceThe new namespace to be added.
Returns
The a pointer to the namespace found, or NULL if the namespace doesn't exist.

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

2168 {
2169  if (!table || !name_space)
2170  return nullptr;
2171 
2172  name_space = gnc_commodity_table_map_namespace(name_space);
2173  return static_cast<gnc_commodity_namespace*>(g_hash_table_lookup(table->ns_table, (gpointer)name_space));
2174 }

◆ 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
tableA pointer to the commodity table
fThe function to call for each commodity.
user_dataA 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
tableA pointer to the commodity table
commodity_namespaceA 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 2019 of file gnc-commodity.cpp.

2021 {
2022  gnc_commodity_namespace * ns = nullptr;
2023 
2024  if (!table)
2025  return nullptr;
2026  if (g_strcmp0(name_space, GNC_COMMODITY_NS_NONISO_GUI) == 0)
2027  return commodity_table_get_all_noncurrency_commodities(table);
2028  ns = gnc_commodity_table_find_namespace(table, name_space);
2029  if (!ns)
2030  return nullptr;
2031 
2032  return g_hash_table_values(ns->cm_table);
2033 }
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.

◆ 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 1947 of file gnc-commodity.cpp.

1948 {
1949  if (!table)
1950  return nullptr;
1951 
1952  return g_hash_table_keys(table->ns_table);
1953 }

◆ 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 1956 of file gnc-commodity.cpp.

1957 {
1958  if (!table)
1959  return nullptr;
1960 
1961  return g_list_copy (table->ns_list);
1962 }

◆ 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
tableA 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 2065 of file gnc-commodity.cpp.

2066 {
2067  gnc_commodity_namespace * ns = nullptr;
2068  const char *name_space;
2069  GList * nslist, * tmp;
2070  GList * l = nullptr;
2071  regex_t pattern;
2072  const char *expression = gnc_prefs_get_namespace_regexp();
2073 
2074  ENTER("table=%p, expression=%s", table, expression);
2075  if (!table)
2076  return nullptr;
2077 
2078  if (expression && *expression)
2079  {
2080  if (regcomp(&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
2081  {
2082  LEAVE("Cannot compile regex");
2083  return nullptr;
2084  }
2085 
2087  for (tmp = nslist; tmp; tmp = tmp->next)
2088  {
2089  name_space = static_cast<const char*>(tmp->data);
2090  if (regexec(&pattern, name_space, 0, nullptr, 0) == 0)
2091  {
2092  DEBUG("Running list of %s commodities", name_space);
2093  ns = gnc_commodity_table_find_namespace(table, name_space);
2094  if (ns)
2095  {
2096  g_hash_table_foreach(ns->cm_table, &get_quotables_helper1, (gpointer) &l);
2097  }
2098  }
2099  }
2100  g_list_free(nslist);
2101  regfree(&pattern);
2102  }
2103  else
2104  {
2105  gnc_commodity_table_foreach_commodity(table, get_quotables_helper2,
2106  (gpointer) &l);
2107  }
2108  LEAVE("list head %p", l);
2109  return l;
2110 }
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.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
GList * gnc_commodity_table_get_namespaces(const gnc_commodity_table *table)
Return a list of all namespaces in the commodity table.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
tblA 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 1663 of file gnc-commodity.cpp.

1664 {
1665  guint count = 0;
1666  g_return_val_if_fail(tbl, 0);
1667  g_return_val_if_fail(tbl->ns_table, 0);
1668 
1669  g_hash_table_foreach(tbl->ns_table, count_coms, (gpointer)&count);
1670 
1671  return count;
1672 }

◆ 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
tableA pointer to the commodity table
commodity_namespaceThe 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 1890 of file gnc-commodity.cpp.

1892 {
1893  gnc_commodity_namespace * nsp = nullptr;
1894 
1895  if (!table || !name_space)
1896  {
1897  return 0;
1898  }
1899 
1900  nsp = gnc_commodity_table_find_namespace(table, name_space);
1901  if (nsp)
1902  {
1903  return 1;
1904  }
1905  else
1906  {
1907  return 0;
1908  }
1909 }
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.

◆ 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
tableA pointer to the commodity table
commA 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 1784 of file gnc-commodity.cpp.

1786 {
1787  gnc_commodity_namespace * nsp = nullptr;
1788  gnc_commodity *c;
1789  const char *ns_name;
1790  gnc_commodityPrivate* priv;
1791  QofBook *book;
1792 
1793  if (!table) return nullptr;
1794  if (!comm) return nullptr;
1795 
1796  priv = GET_PRIVATE(comm);
1797 
1798  ENTER ("(table=%p, comm=%p) %s %s", table, comm,
1799  (priv->mnemonic == nullptr ? "(null)" : priv->mnemonic),
1800  (priv->fullname == nullptr ? "(null)" : priv->fullname));
1801  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1802  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1803 
1804  if (c)
1805  {
1806  if (c == comm)
1807  {
1808  LEAVE("already in table");
1809  return c;
1810  }
1811 
1812  /* Backward compatibility support for currencies that have
1813  * recently changed. */
1814  if (priv->name_space->iso4217)
1815  {
1816  auto it = gnc_new_iso_codes.find (priv->mnemonic);
1817  if (it != gnc_new_iso_codes.end())
1818  gnc_commodity_set_mnemonic(comm, it->second.c_str());
1819  }
1820  gnc_commodity_copy (c, comm);
1821  gnc_commodity_destroy (comm);
1822  LEAVE("found at %p", c);
1823  return c;
1824  }
1825 
1826  /* Prevent setting anything except template in namespace template. */
1827  if (g_strcmp0 (ns_name, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
1828  g_strcmp0 (priv->mnemonic, "template") != 0)
1829  {
1830  PWARN("Converting commodity %s from namespace template to "
1831  "namespace User", priv->mnemonic);
1832  gnc_commodity_set_namespace (comm, "User");
1833  ns_name = "User";
1834  mark_commodity_dirty (comm);
1835  }
1836 
1837  book = qof_instance_get_book (&comm->inst);
1838  nsp = gnc_commodity_table_add_namespace(table, ns_name, book);
1839 
1840  PINFO ("insert %p %s into nsp=%p %s", priv->mnemonic, priv->mnemonic,
1841  nsp->cm_table, nsp->name);
1842  g_hash_table_insert(nsp->cm_table,
1843  (gpointer)CACHE_INSERT(priv->mnemonic),
1844  (gpointer)comm);
1845  nsp->cm_list = g_list_append(nsp->cm_list, comm);
1846 
1847  qof_event_gen (&comm->inst, QOF_EVENT_ADD, nullptr);
1848  LEAVE ("(table=%p, comm=%p)", table, comm);
1849  return comm;
1850 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table *table, const char *name_space, QofBook *book)
This function adds a new string to the list of commodity namespaces.
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void gnc_commodity_set_mnemonic(gnc_commodity *cm, const char *mnemonic)
Set the mnemonic for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
void gnc_commodity_set_namespace(gnc_commodity *cm, const char *name_space)
Set the namespace for the specified commodity.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
void gnc_commodity_copy(gnc_commodity *dest, const gnc_commodity *src)
Copy src into dest.
void gnc_commodity_destroy(gnc_commodity *cm)
Destroy a 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 1600 of file gnc-commodity.cpp.

1601 {
1602  gnc_commodity_table * retval = g_new0(gnc_commodity_table, 1);
1603  retval->ns_table = g_hash_table_new(&g_str_hash, &g_str_equal);
1604  retval->ns_list = nullptr;
1605  return retval;
1606 }

◆ 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
tableA pointer to the commodity table
commA pointer to the commodity to remove.

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

1860 {
1861  gnc_commodity_namespace * nsp;
1862  gnc_commodity *c;
1863  gnc_commodityPrivate* priv;
1864  const char *ns_name;
1865 
1866  if (!table) return;
1867  if (!comm) return;
1868 
1869  priv = GET_PRIVATE(comm);
1870  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1871  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1872  if (c != comm) return;
1873 
1874  qof_event_gen (&comm->inst, QOF_EVENT_REMOVE, nullptr);
1875 
1876  nsp = gnc_commodity_table_find_namespace(table, ns_name);
1877  if (!nsp) return;
1878 
1879  nsp->cm_list = g_list_remove(nsp->cm_list, comm);
1880  g_hash_table_remove (nsp->cm_table, priv->mnemonic);
1881  /* XXX minor mem leak, should remove the key as well */
1882 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ 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
cmA pointer to a commodity data structure.
flagTRUE if quotes should be pulled for this commodity, FALSE otherwise.

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

1277 {
1278  gnc_commodityPrivate* priv;
1279 
1280  ENTER ("(cm=%p, flag=%d)", cm, flag);
1281 
1282  if (!cm)
1283  {
1284  LEAVE("");
1285  return;
1286  }
1287 
1288  priv = GET_PRIVATE(cm);
1289  gnc_commodity_begin_edit(cm);
1290  gnc_commodity_set_quote_flag(cm, flag);
1291  if (gnc_commodity_is_iso(cm))
1292  {
1293  /* For currencies, disable auto quote control if the quote flag is being
1294  * changed from its default value and enable it if the quote flag is being
1295  * reset to its default value. The defaults for the quote flag are
1296  * disabled if no accounts are using the currency, and true otherwise.
1297  * Thus enable auto quote control if flag is FALSE and there are not any
1298  * accounts using this currency OR flag is TRUE and there are accounts
1299  * using this currency; otherwise disable auto quote control */
1300  gnc_commodity_set_auto_quote_control_flag(cm,
1301  (!flag && (priv->usage_count == 0)) || (flag && (priv->usage_count != 0)));
1302  }
1303  gnc_commodity_commit_edit(cm);
1304  LEAVE("");
1305 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ 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 2468 of file gnc-commodity.cpp.

2469 {
2470  MonetaryList *node, *next;
2471  for (node = list; node; node = next)
2472  {
2473  auto mon = static_cast<gnc_monetary*>(node->data);
2474  next = node->next;
2475  if (gnc_numeric_zero_p(mon->value))
2476  {
2477  g_free(mon);
2478  list = g_list_delete_link(list, node);
2479  }
2480  }
2481  return list;
2482 }
gboolean gnc_numeric_zero_p(gnc_numeric a)
Returns 1 if the given gnc_numeric is 0 (zero), else returns 0.

◆ 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 2486 of file gnc-commodity.cpp.

2487 {
2488  MonetaryList *tmp;
2489  for (tmp = list; tmp; tmp = tmp->next)
2490  {
2491  g_free(tmp->data);
2492  }
2493 
2494  g_list_free(list);
2495 }

◆ 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
nameThe internal name for this new quote source.
supportedTRUE 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.

320 {
321  DEBUG("Creating new source %s", (!source_name ? "(null)" : source_name));
322  /* This name can be changed if/when support for this price source is
323  * integrated into gnucash. */
324  /* This name is permanent and must be kept the same if/when support
325  * for this price source is integrated into gnucash (i.e. for a
326  * nice user name). */
327  return &new_quote_sources.emplace_back (supported, SOURCE_UNKNOWN, source_name, source_name);
328 }
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
This is a locally installed quote source that gnucash knows nothing about.

◆ 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 266 of file gnc-commodity.cpp.

267 {
268  return (!fq_version.empty());
269 }

◆ 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 279 of file gnc-commodity.cpp.

280 {
281  return fq_version.c_str();
282 }

◆ 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
sourceThe quote source in question.
Returns
The index of this quote source in its type.

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

391 {
392  if (!source)
393  {
394  PWARN ("bad source");
395  return 0;
396  }
397 
398  auto& sources = get_quote_source_from_type (source->get_type());
399  auto is_source = [&source](const auto& findif_source)
400  { return &findif_source == source; };
401 
402  auto iter = std::find_if (sources.begin(), sources.end(), is_source);
403  if (iter != sources.end())
404  return std::distance (sources.begin(), iter);
405 
406  PWARN ("couldn't locate source");
407  return 0;
408 }
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250

◆ 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
sourceThe quote source in question.
Returns
The internal name.

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

439 {
440  ENTER("%p", source);
441  if (!source)
442  {
443  LEAVE("bad source");
444  return nullptr;
445  }
446  LEAVE("internal name %s", source->get_internal_name());
447  return source->get_internal_name();
448 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
sourceThe quote source in question.
Returns
TRUE if the user's computer supports this quote source.

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

412 {
413  ENTER("%p", source);
414  if (!source)
415  {
416  LEAVE("bad source");
417  return FALSE;
418  }
419 
420  LEAVE("%s supported", source && source->get_supported() ? "" : "not ");
421  return source->get_supported();
422 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
sourceThe quote source in question.
Returns
The type of this quote source.

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

377 {
378  ENTER("%p", source);
379  if (!source)
380  {
381  LEAVE("bad source");
382  return SOURCE_SINGLE;
383  }
384 
385  LEAVE("type is %d", source->get_type());
386  return source->get_type();
387 }
This quote source pulls from a single specific web site.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
sourceThe quote source in question.
Returns
The user friendly name.

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

426 {
427  ENTER("%p", source);
428  if (!source)
429  {
430  LEAVE("bad source");
431  return nullptr;
432  }
433  LEAVE("user name %s", source->get_user_name());
434  return source->get_user_name();
435 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

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

353 {
354  if (!name || !*name)
355  return nullptr;
356 
357  for (const auto& [_, sources] : quote_sources_map)
358  {
359  auto source_it = std::find_if (sources.begin(), sources.end(),
360  [name] (const auto& qs)
361  { return (g_strcmp0(name, qs.get_internal_name()) == 0); });
362  if (source_it != sources.end())
363  return &(*source_it);
364  }
365 
366  DEBUG("gnc_quote_source_lookup_by_internal: Unknown source %s", name);
367  return nullptr;
368 }
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264

◆ 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
typeThe type of this quote source.
indexThe 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.

337 {
338  ENTER("type/index is %d/%d", type, index);
339  auto& sources = get_quote_source_from_type (type);
340  if ((size_t) index < sources.size())
341  {
342  auto it = std::next(sources.begin(), index);
343  LEAVE("found %s", it->get_user_name());
344  return &*it;
345  }
346 
347  LEAVE("not found");
348  return nullptr;
349 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ 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
typeThe quote source type whose count should be returned.
Returns
The number of entries for this type of quote source.

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

303 {
304  auto source{get_quote_source_from_type(type)};
305  return std::distance(source.begin(), source.end());
306 }

◆ 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_listA list of strings containing the source names as they are known to F::Q.

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

460 {
461  ENTER(" ");
462 
463  if (sources_list.empty())
464  return;
465 
466  if (version_string)
467  fq_version = version_string;
468  else
469  fq_version.clear();
470 
471  for (const auto& source_name_str : sources_list)
472  {
473  auto source_name = source_name_str.c_str();
474  auto source = gnc_quote_source_lookup_by_internal(source_name);
475 
476  if (source)
477  {
478  DEBUG("Found source %s: %s", source_name, source->get_user_name());
479  source->set_supported (true);
480  continue;
481  }
482 
483  gnc_quote_source_add_new(source_name, TRUE);
484  }
485  LEAVE(" ");
486 }
gnc_quote_source * gnc_quote_source_add_new(const char *source_name, gboolean supported)
Create a new quote source.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_quote_source * gnc_quote_source_lookup_by_internal(const char *name)
Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by th...
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282