GnuCash  3.5-352-gccd9ca8a8
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.
 

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_NASDAQ   "NASDAQ"
 
#define GNC_COMMODITY_NS_NYSE   "NYSE"
 
#define GNC_COMMODITY_NS_EUREX   "EUREX"
 
#define GNC_COMMODITY_NS_MUTUAL   "FUND"
 
#define GNC_COMMODITY_NS_AMEX   "AMEX"
 
#define GNC_COMMODITY_NS_ASX   "ASX"
 
#define GNC_COMMODITY_NS_NONCURRENCY   _("All non-currency")
 
#define GNC_COMMODITY_NS_ISO_GUI   N_("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
 

Functions

GType gnc_commodity_get_type (void)
 
GType gnc_commodity_namespace_get_type (void)
 

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...
 
void gnc_quote_source_set_fq_installed (const char *version_string, const GList *sources_list)
 Update gnucash internal tables based on what Finance::Quote sources are installed. 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 strucure 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 strucure. More...
 
const char * gnc_commodity_namespace_get_gui_name (const gnc_commodity_namespace *ns)
 Return the textual name of a namespace data strucure 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 proably shouldn't be using gnc_commodity_table_new() directly, its 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 1000 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 102 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 133 of file gnc-commodity.h.

134 {
135  SOURCE_SINGLE = 0,
139  SOURCE_MULTI,
146  SOURCE_MAX,
147  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 1673 of file gnc-commodity.c.

1674 {
1675  if (gnc_commodity_equal(a, b))
1676  {
1677  return 0;
1678  }
1679  else
1680  {
1681  return 1;
1682  }
1683 }
gboolean gnc_commodity_equal(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equal.

◆ 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 1559 of file gnc-commodity.c.

1560 {
1561  gnc_commodityPrivate* priv;
1562 
1563  ENTER("(cm=%p)", cm);
1564 
1565  if (!cm)
1566  {
1567  LEAVE("");
1568  return;
1569  }
1570 
1571  priv = GET_PRIVATE(cm);
1572 
1573  if (priv->usage_count == 0)
1574  {
1575  PWARN("usage_count already zero");
1576  LEAVE("");
1577  return;
1578  }
1579 
1580  priv->usage_count--;
1581  if ((priv->usage_count == 0) && priv->quote_flag
1582  && gnc_commodity_get_auto_quote_control_flag(cm)
1583  && gnc_commodity_is_iso(cm))
1584  {
1585  /* if this is a currency with auto quote control enabled and no more
1586  * accounts reference this currency, disable quote retrieval */
1587  gnc_commodity_set_quote_flag(cm, FALSE);
1588  }
1589  LEAVE("(usage_count=%d)", priv->usage_count);
1590 }
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:266
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:248
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276
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 971 of file gnc-commodity.c.

972 {
973  gnc_commodity_begin_edit(cm);
974  qof_instance_set_destroying(cm, TRUE);
975  gnc_commodity_commit_edit(cm);
976 }

◆ 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 1618 of file gnc-commodity.c.

1619 {
1620  gnc_commodityPrivate* priv_a;
1621  gnc_commodityPrivate* priv_b;
1622  gboolean same_book;
1623 
1624  if (a == b) return TRUE;
1625 
1626  if (!a || !b)
1627  {
1628  DEBUG ("one is NULL");
1629  return FALSE;
1630  }
1631 
1632  priv_a = GET_PRIVATE(a);
1633  priv_b = GET_PRIVATE(b);
1634  same_book = qof_instance_get_book(QOF_INSTANCE(a)) == qof_instance_get_book(QOF_INSTANCE(b));
1635 
1636  if ((same_book && priv_a->name_space != priv_b->name_space)
1637  || (!same_book && g_strcmp0( gnc_commodity_namespace_get_name(priv_a->name_space),
1638  gnc_commodity_namespace_get_name(priv_b->name_space)) != 0))
1639  {
1640  DEBUG ("namespaces differ: %p(%s) vs %p(%s)",
1641  priv_a->name_space, gnc_commodity_namespace_get_name(priv_a->name_space),
1642  priv_b->name_space, gnc_commodity_namespace_get_name(priv_b->name_space));
1643  return FALSE;
1644  }
1645 
1646  if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0)
1647  {
1648  DEBUG ("mnemonics differ: %s vs %s", priv_a->mnemonic, priv_b->mnemonic);
1649  return FALSE;
1650  }
1651 
1652  if (g_strcmp0(priv_a->fullname, priv_b->fullname) != 0)
1653  {
1654  DEBUG ("fullnames differ: %s vs %s", priv_a->fullname, priv_b->fullname);
1655  return FALSE;
1656  }
1657 
1658  if (g_strcmp0(priv_a->cusip, priv_b->cusip) != 0)
1659  {
1660  DEBUG ("cusips differ: %s vs %s", priv_a->cusip, priv_b->cusip);
1661  return FALSE;
1662  }
1663 
1664  if (priv_a->fraction != priv_b->fraction)
1665  {
1666  DEBUG ("fractions differ: %d vs %d", priv_a->fraction, priv_b->fraction);
1667  return FALSE;
1668  }
1669 
1670  return TRUE;
1671 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:260
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data strucure.

◆ 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 1602 of file gnc-commodity.c.

1603 {
1604  gnc_commodityPrivate* priv_a;
1605  gnc_commodityPrivate* priv_b;
1606 
1607  if (a == b) return TRUE;
1608  if (!a || !b) return FALSE;
1609 
1610  priv_a = GET_PRIVATE(a);
1611  priv_b = GET_PRIVATE(b);
1612  if (priv_a->name_space != priv_b->name_space) return FALSE;
1613  if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0) return FALSE;
1614  return TRUE;
1615 }

◆ 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 1096 of file gnc-commodity.c.

1097 {
1098  if (!cm) return NULL;
1099  return GET_PRIVATE(cm)->cusip;
1100 }

◆ 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 1195 of file gnc-commodity.c.

1196 {
1197  if (!cm) return NULL;
1198  return GET_PRIVATE(cm)->default_symbol;
1199 }

◆ 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 1107 of file gnc-commodity.c.

1108 {
1109  if (!cm) return 0;
1110  return GET_PRIVATE(cm)->fraction;
1111 }

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

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

◆ 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 1031 of file gnc-commodity.c.

1032 {
1033  if (!cm) return NULL;
1034  return GET_PRIVATE(cm)->mnemonic;
1035 }

◆ 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 1054 of file gnc-commodity.c.

1055 {
1056  if (!cm) return NULL;
1057  return gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
1058 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data strucure.

◆ gnc_commodity_get_namespace_ds()

gnc_commodity_namespace* gnc_commodity_get_namespace_ds ( const gnc_commodity *  cm)

Retrieve the namespace data strucure 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 1061 of file gnc-commodity.c.

1062 {
1063  if (!cm) return NULL;
1064  return GET_PRIVATE(cm)->name_space;
1065 }

◆ 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 1205 of file gnc-commodity.c.

1206 {
1207  const char *nice_symbol;
1208  struct lconv *lc;
1209  if (!cm) return NULL;
1210 
1211  nice_symbol = gnc_commodity_get_user_symbol(cm);
1212  if (nice_symbol && *nice_symbol)
1213  return nice_symbol;
1214 
1215  lc = gnc_localeconv();
1216  nice_symbol = lc->currency_symbol;
1217  if (!g_strcmp0(gnc_commodity_get_mnemonic(cm), lc->int_curr_symbol))
1218  return nice_symbol;
1219 
1220  nice_symbol = gnc_commodity_get_default_symbol(cm);
1221  if (nice_symbol && *nice_symbol)
1222  return nice_symbol;
1223 
1224  return gnc_commodity_get_mnemonic(cm);
1225 }
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 1042 of file gnc-commodity.c.

1043 {
1044  if (!cm) return NULL;
1045  return GET_PRIVATE(cm)->printname;
1046 }

◆ 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 1135 of file gnc-commodity.c.

1136 {
1137  if (!cm) return FALSE;
1138  return (GET_PRIVATE(cm)->quote_flag);
1139 }

◆ 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 1146 of file gnc-commodity.c.

1147 {
1148  gnc_commodityPrivate* priv;
1149 
1150  if (!cm) return NULL;
1151  priv = GET_PRIVATE(cm);
1152  if (!priv->quote_source && gnc_commodity_is_iso(cm))
1153  return &currency_quote_source;
1154  return priv->quote_source;
1155 }
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 1171 of file gnc-commodity.c.

1172 {
1173  if (!cm) return NULL;
1174  return GET_PRIVATE(cm)->quote_tz;
1175 }

◆ 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 1084 of file gnc-commodity.c.

1085 {
1086  if (!cm) return NULL;
1087  return GET_PRIVATE(cm)->unique_name;
1088 }

◆ 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 1181 of file gnc-commodity.c.

1182 {
1183  GValue v = G_VALUE_INIT;
1184  if (!cm) return NULL;
1185  qof_instance_get_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1186  if (G_VALUE_HOLDS_STRING (&v))
1187  return g_value_get_string (&v);
1188  return NULL;
1189 }
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 1524 of file gnc-commodity.c.

1525 {
1526  gnc_commodityPrivate* priv;
1527 
1528  ENTER("(cm=%p)", cm);
1529 
1530  if (!cm)
1531  {
1532  LEAVE("");
1533  return;
1534  }
1535 
1536  priv = GET_PRIVATE(cm);
1537 
1538  if ((priv->usage_count == 0) && !priv->quote_flag
1539  && gnc_commodity_get_auto_quote_control_flag(cm)
1540  && gnc_commodity_is_iso(cm))
1541  {
1542  /* compatibility hack - Gnucash 1.8 gets currency quotes when a
1543  non-default currency is assigned to an account. */
1544  gnc_commodity_begin_edit(cm);
1545  gnc_commodity_set_quote_flag(cm, TRUE);
1547  gnc_commodity_get_default_quote_source(cm));
1548  gnc_commodity_commit_edit(cm);
1549  }
1550  priv->usage_count++;
1551  LEAVE("(usage_count=%d)", priv->usage_count);
1552 }
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:266
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:276
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 2136 of file gnc-commodity.c.

2137 {
2138  const char *ns_name;
2139  if (!cm) return FALSE;
2140 
2141  ns_name = gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
2142  return (!g_strcmp0(ns_name, GNC_COMMODITY_NS_LEGACY) ||
2143  !g_strcmp0(ns_name, GNC_COMMODITY_NS_CURRENCY));
2144 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data strucure.
#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 2124 of file gnc-commodity.c.

2125 {
2126  gnc_commodityPrivate* priv;
2127 
2128  if (!cm) return FALSE;
2129 
2130  priv = GET_PRIVATE(cm);
2131  if ( !priv->name_space) return FALSE;
2132  return priv->name_space->iso4217;
2133 }

◆ 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 engine. The caller must not free the list.

Definition at line 1712 of file gnc-commodity.c.

1713 {
1714  if (!name_space)
1715  return NULL;
1716 
1717  return name_space->cm_list;
1718 }

◆ 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 strucure in a form suitable to present to the user.

Parameters
nsA pointer to the namespace data strucure.
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 1702 of file gnc-commodity.c.

1703 {
1704  if (ns == NULL)
1705  return NULL;
1706  if (g_strcmp0 (ns->name, GNC_COMMODITY_NS_CURRENCY) == 0)
1707  return GNC_COMMODITY_NS_ISO_GUI;
1708  return ns->name;
1709 }

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

Parameters
nsA pointer to the namespace data strucure.
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 1694 of file gnc-commodity.c.

1695 {
1696  if (ns == NULL)
1697  return NULL;
1698  return ns->name;
1699 }

◆ 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 1721 of file gnc-commodity.c.

1722 {
1723  return ((g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0) ||
1724  (g_strcmp0(name_space, GNC_COMMODITY_NS_CURRENCY) == 0));
1725 }

◆ 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 878 of file gnc-commodity.c.

881 {
882  gnc_commodity * retval = g_object_new(GNC_TYPE_COMMODITY, NULL);
883 
884  qof_instance_init_data (&retval->inst, GNC_ID_COMMODITY, book);
885  gnc_commodity_begin_edit(retval);
886 
887  if ( name_space != NULL )
888  {
889  /* Prevent setting anything except template in namespace template. */
890  if (g_strcmp0 (name_space, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
891  g_strcmp0 (mnemonic, "template") != 0)
892  {
893  PWARN("Converting commodity %s from namespace template to "
894  "namespace User", mnemonic);
895  name_space = "User";
896  }
897  gnc_commodity_set_namespace(retval, name_space);
898  if (gnc_commodity_namespace_is_iso(name_space))
899  {
902  }
903  }
904  gnc_commodity_set_fullname(retval, fullname);
905  gnc_commodity_set_mnemonic(retval, mnemonic);
906  gnc_commodity_set_cusip(retval, cusip);
907  gnc_commodity_set_fraction(retval, fraction);
908  mark_commodity_dirty (retval);
909  gnc_commodity_commit_edit(retval);
910 
911  qof_event_gen (&retval->inst, QOF_EVENT_CREATE, NULL);
912 
913  return retval;
914 }
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:248
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:234

◆ 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 1761 of file gnc-commodity.c.

1762 {
1763  gnc_commodity *twin;
1764  const char * ucom;
1765  gnc_commodity_table * comtbl;
1766 
1767  if (!from) return NULL;
1768  comtbl = gnc_commodity_table_get_table (book);
1769  if (!comtbl) return NULL;
1770 
1771  ucom = gnc_commodity_get_unique_name (from);
1772  twin = gnc_commodity_table_lookup_unique (comtbl, ucom);
1773  if (!twin)
1774  {
1775  twin = gnc_commodity_clone (from, book);
1776  twin = gnc_commodity_table_insert (comtbl, twin);
1777  }
1778  return twin;
1779 }
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 1307 of file gnc-commodity.c.

1309 {
1310  gnc_commodityPrivate* priv;
1311 
1312  if (!cm) return;
1313 
1314  priv = GET_PRIVATE(cm);
1315  if (priv->cusip == cusip) return;
1316 
1317  gnc_commodity_begin_edit(cm);
1318  CACHE_REMOVE (priv->cusip);
1319  priv->cusip = CACHE_INSERT (cusip);
1320  mark_commodity_dirty(cm);
1321  gnc_commodity_commit_edit(cm);
1322 }

◆ 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 1329 of file gnc-commodity.c.

1330 {
1331  if (!cm) return;
1332  gnc_commodity_begin_edit(cm);
1333  GET_PRIVATE(cm)->fraction = fraction;
1334  mark_commodity_dirty(cm);
1335  gnc_commodity_commit_edit(cm);
1336 }

◆ 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 1285 of file gnc-commodity.c.

1286 {
1287  gnc_commodityPrivate* priv;
1288 
1289  if (!cm) return;
1290  priv = GET_PRIVATE(cm);
1291  if (priv->fullname == fullname) return;
1292 
1293  CACHE_REMOVE (priv->fullname);
1294  priv->fullname = CACHE_INSERT (fullname);
1295 
1296  gnc_commodity_begin_edit(cm);
1297  mark_commodity_dirty(cm);
1298  reset_printname(priv);
1299  gnc_commodity_commit_edit(cm);
1300 }

◆ 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 1232 of file gnc-commodity.c.

1233 {
1234  gnc_commodityPrivate* priv;
1235 
1236  if (!cm) return;
1237  priv = GET_PRIVATE(cm);
1238  if (priv->mnemonic == mnemonic) return;
1239 
1240  gnc_commodity_begin_edit(cm);
1241  CACHE_REMOVE (priv->mnemonic);
1242  priv->mnemonic = CACHE_INSERT(mnemonic);
1243 
1244  mark_commodity_dirty (cm);
1245  reset_printname(priv);
1246  reset_unique_name(priv);
1247  gnc_commodity_commit_edit(cm);
1248 }

◆ 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 1255 of file gnc-commodity.c.

1256 {
1257  QofBook *book;
1258  gnc_commodity_table *table;
1259  gnc_commodity_namespace *nsp;
1260  gnc_commodityPrivate* priv;
1261 
1262  if (!cm) return;
1263  priv = GET_PRIVATE(cm);
1264  book = qof_instance_get_book (&cm->inst);
1266  nsp = gnc_commodity_table_add_namespace(table, name_space, book);
1267  if (priv->name_space == nsp)
1268  return;
1269 
1270  gnc_commodity_begin_edit(cm);
1271  priv->name_space = nsp;
1272  if (nsp->iso4217)
1273  priv->quote_source = gnc_quote_source_lookup_by_internal("currency");
1274  mark_commodity_dirty(cm);
1275  reset_printname(priv);
1276  reset_unique_name(priv);
1277  gnc_commodity_commit_edit(cm);
1278 }
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 1409 of file gnc-commodity.c.

1410 {
1411  ENTER ("(cm=%p, flag=%d)", cm, flag);
1412 
1413  if (!cm) return;
1414  gnc_commodity_begin_edit(cm);
1415  GET_PRIVATE(cm)->quote_flag = flag;
1416  mark_commodity_dirty(cm);
1417  gnc_commodity_commit_edit(cm);
1418  LEAVE(" ");
1419 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 1426 of file gnc-commodity.c.

1427 {
1428  ENTER ("(cm=%p, src=%p(%s))", cm, src, src ? src->internal_name : "unknown");
1429 
1430  if (!cm) return;
1431  gnc_commodity_begin_edit(cm);
1432  GET_PRIVATE(cm)->quote_source = src;
1433  mark_commodity_dirty(cm);
1434  gnc_commodity_commit_edit(cm);
1435  LEAVE(" ");
1436 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 1443 of file gnc-commodity.c.

1444 {
1445  gnc_commodityPrivate* priv;
1446 
1447  if (!cm) return;
1448 
1449  ENTER ("(cm=%p, tz=%s)", cm, tz ? tz : "(null)");
1450 
1451  priv = GET_PRIVATE(cm);
1452 
1453  if (tz == priv->quote_tz)
1454  {
1455  LEAVE("Already correct TZ");
1456  return;
1457  }
1458 
1459  gnc_commodity_begin_edit(cm);
1460  CACHE_REMOVE (priv->quote_tz);
1461  priv->quote_tz = CACHE_INSERT (tz);
1462  mark_commodity_dirty(cm);
1463  gnc_commodity_commit_edit(cm);
1464  LEAVE(" ");
1465 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 1472 of file gnc-commodity.c.

1473 {
1474  struct lconv *lc;
1475  GValue v = G_VALUE_INIT;
1476  if (!cm) return;
1477 
1478  ENTER ("(cm=%p, symbol=%s)", cm, user_symbol ? user_symbol : "(null)");
1479 
1480  gnc_commodity_begin_edit(cm);
1481 
1482  lc = gnc_localeconv();
1483  if (!user_symbol || !*user_symbol)
1484  user_symbol = NULL;
1485  else if (!g_strcmp0(lc->int_curr_symbol, gnc_commodity_get_mnemonic(cm)) &&
1486  !g_strcmp0(lc->currency_symbol, user_symbol))
1487  /* if the user gives the ISO symbol for the locale currency or the
1488  * default symbol, actually remove the user symbol */
1489  user_symbol = NULL;
1490  else if (!g_strcmp0(user_symbol, gnc_commodity_get_default_symbol(cm)))
1491  user_symbol = NULL;
1492  if (user_symbol)
1493  {
1494  g_value_init (&v, G_TYPE_STRING);
1495  g_value_set_string (&v, user_symbol);
1496  qof_instance_set_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1497  }
1498  else
1499  qof_instance_set_kvp (QOF_INSTANCE(cm), NULL, 1, "user_symbol");
1500 
1501  mark_commodity_dirty(cm);
1502  gnc_commodity_commit_edit(cm);
1503 
1504  LEAVE(" ");
1505 }
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:266
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:276

◆ 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 2471 of file gnc-commodity.c.

2472 {
2473  QofCollection *col;
2474  gnc_commodity* c;
2475 
2476  ENTER ("table=%p", table);
2477  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_AMEX, book);
2478  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_NYSE, book);
2479  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_NASDAQ, book);
2480  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_EUREX, book);
2481  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_MUTUAL, book);
2482  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_TEMPLATE, book);
2483  c = gnc_commodity_new(book, "template", GNC_COMMODITY_NS_TEMPLATE, "template", "template", 1);
2485 
2486 #include "iso-4217-currencies.c"
2487 
2488  /* We've just created the default namespaces and currencies. Mark
2489  * these collections as clean because there is no USER entered data
2490  * in these collections as of yet. */
2491  col = qof_book_get_collection(book, GNC_ID_COMMODITY);
2493  col = qof_book_get_collection(book, GNC_ID_COMMODITY_NAMESPACE);
2495 
2496  LEAVE ("table=%p", table);
2497  return TRUE;
2498 }
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:266
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:262
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:603

◆ 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 2291 of file gnc-commodity.c.

2294 {
2295  gnc_commodity_namespace * ns = NULL;
2296 
2297  if (!table) return NULL;
2298 
2299  name_space = gnc_commodity_table_map_namespace(name_space);
2300  ns = gnc_commodity_table_find_namespace(table, name_space);
2301  if (!ns)
2302  {
2303  ns = g_object_new(GNC_TYPE_COMMODITY_NAMESPACE, NULL);
2304  ns->cm_table = g_hash_table_new(g_str_hash, g_str_equal);
2305  ns->name = CACHE_INSERT((gpointer)name_space);
2306  ns->iso4217 = gnc_commodity_namespace_is_iso(name_space);
2307  qof_instance_init_data (&ns->inst, GNC_ID_COMMODITY_NAMESPACE, book);
2308  qof_event_gen (&ns->inst, QOF_EVENT_CREATE, NULL);
2309 
2310  g_hash_table_insert(table->ns_table,
2311  (gpointer) ns->name,
2312  (gpointer) ns);
2313  table->ns_list = g_list_append(table->ns_list, ns);
2314  qof_event_gen (&ns->inst, QOF_EVENT_ADD, NULL);
2315  }
2316  return ns;
2317 }
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:234

◆ 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 2356 of file gnc-commodity.c.

2358 {
2359  gnc_commodity_namespace * ns;
2360 
2361  if (!table) return;
2362 
2363  ns = gnc_commodity_table_find_namespace(table, name_space);
2364  if (!ns)
2365  return;
2366 
2367  qof_event_gen (&ns->inst, QOF_EVENT_REMOVE, NULL);
2368  g_hash_table_remove(table->ns_table, name_space);
2369  table->ns_list = g_list_remove(table->ns_list, ns);
2370 
2371  g_list_free(ns->cm_list);
2372  ns->cm_list = NULL;
2373 
2374  g_hash_table_foreach_remove(ns->cm_table, ns_helper, NULL);
2375  g_hash_table_destroy(ns->cm_table);
2376  CACHE_REMOVE(ns->name);
2377 
2378  qof_event_gen (&ns->inst, QOF_EVENT_DESTROY, NULL);
2379  /* qof_instance_release(&ns->inst); */
2380  g_object_unref(ns);
2381 }
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:234

◆ 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 2321 of file gnc-commodity.c.

2323 {
2324  if (!table || !name_space)
2325  return NULL;
2326 
2327  name_space = gnc_commodity_table_map_namespace(name_space);
2328  return g_hash_table_lookup(table->ns_table, (gpointer)name_space);
2329 }

◆ 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 2172 of file gnc-commodity.c.

2174 {
2175  gnc_commodity_namespace * ns = NULL;
2176 
2177  if (!table)
2178  return NULL;
2179  if (g_strcmp0(name_space, GNC_COMMODITY_NS_NONCURRENCY) == 0)
2180  return commodity_table_get_all_noncurrency_commodities(table);
2181  ns = gnc_commodity_table_find_namespace(table, name_space);
2182  if (!ns)
2183  return NULL;
2184 
2185  return g_hash_table_values(ns->cm_table);
2186 }
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 2100 of file gnc-commodity.c.

2101 {
2102  if (!table)
2103  return NULL;
2104 
2105  return g_hash_table_keys(table->ns_table);
2106 }

◆ 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 engine. The caller must not free the list.

Definition at line 2109 of file gnc-commodity.c.

2110 {
2111  if (!table)
2112  return NULL;
2113 
2114  return table->ns_list;
2115 }

◆ 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 2220 of file gnc-commodity.c.

2221 {
2222  gnc_commodity_namespace * ns = NULL;
2223  const char *name_space;
2224  GList * nslist, * tmp;
2225  GList * l = NULL;
2226  regex_t pattern;
2227  const char *expression = gnc_prefs_get_namespace_regexp();
2228 
2229  ENTER("table=%p, expression=%s", table, expression);
2230  if (!table)
2231  return NULL;
2232 
2233  if (expression && *expression)
2234  {
2235  if (regcomp(&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
2236  {
2237  LEAVE("Cannot compile regex");
2238  return NULL;
2239  }
2240 
2242  for (tmp = nslist; tmp; tmp = tmp->next)
2243  {
2244  name_space = tmp->data;
2245  if (regexec(&pattern, name_space, 0, NULL, 0) == 0)
2246  {
2247  DEBUG("Running list of %s commodities", name_space);
2248  ns = gnc_commodity_table_find_namespace(table, name_space);
2249  if (ns)
2250  {
2251  g_hash_table_foreach(ns->cm_table, &get_quotables_helper1, (gpointer) &l);
2252  }
2253  }
2254  }
2255  g_list_free(nslist);
2256  regfree(&pattern);
2257  }
2258  else
2259  {
2260  gnc_commodity_table_foreach_commodity(table, get_quotables_helper2,
2261  (gpointer) &l);
2262  }
2263  LEAVE("list head %p", l);
2264  return l;
2265 }
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:260
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
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:276

◆ 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 1804 of file gnc-commodity.c.

1805 {
1806  guint count = 0;
1807  g_return_val_if_fail(tbl, 0);
1808  g_return_val_if_fail(tbl->ns_table, 0);
1809 
1810  g_hash_table_foreach(tbl->ns_table, count_coms, (gpointer)&count);
1811 
1812  return count;
1813 }

◆ 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 2043 of file gnc-commodity.c.

2045 {
2046  gnc_commodity_namespace * nsp = NULL;
2047 
2048  if (!table || !name_space)
2049  {
2050  return 0;
2051  }
2052 
2053  nsp = gnc_commodity_table_find_namespace(table, name_space);
2054  if (nsp)
2055  {
2056  return 1;
2057  }
2058  else
2059  {
2060  return 0;
2061  }
2062 }
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 1930 of file gnc-commodity.c.

1932 {
1933  gnc_commodity_namespace * nsp = NULL;
1934  gnc_commodity *c;
1935  const char *ns_name;
1936  gnc_commodityPrivate* priv;
1937  QofBook *book;
1938 
1939  if (!table) return NULL;
1940  if (!comm) return NULL;
1941 
1942  priv = GET_PRIVATE(comm);
1943 
1944  ENTER ("(table=%p, comm=%p) %s %s", table, comm,
1945  (priv->mnemonic == NULL ? "(null)" : priv->mnemonic),
1946  (priv->fullname == NULL ? "(null)" : priv->fullname));
1947  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1948  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1949 
1950  if (c)
1951  {
1952  if (c == comm)
1953  {
1954  LEAVE("already in table");
1955  return c;
1956  }
1957 
1958  /* Backward compatibility support for currencies that have
1959  * recently changed. */
1960  if (priv->name_space->iso4217)
1961  {
1962  guint i;
1963  for (i = 0; i < GNC_NEW_ISO_CODES; i++)
1964  {
1965  if (!priv->mnemonic
1966  || !strcmp(priv->mnemonic, gnc_new_iso_codes[i].old_code))
1967  {
1968  gnc_commodity_set_mnemonic(comm, gnc_new_iso_codes[i].new_code);
1969  break;
1970  }
1971  }
1972  }
1973  gnc_commodity_copy (c, comm);
1974  gnc_commodity_destroy (comm);
1975  LEAVE("found at %p", c);
1976  return c;
1977  }
1978 
1979  /* Prevent setting anything except template in namespace template. */
1980  if (g_strcmp0 (ns_name, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
1981  g_strcmp0 (priv->mnemonic, "template") != 0)
1982  {
1983  PWARN("Converting commodity %s from namespace template to "
1984  "namespace User", priv->mnemonic);
1985  gnc_commodity_set_namespace (comm, "User");
1986  ns_name = "User";
1987  mark_commodity_dirty (comm);
1988  }
1989 
1990  book = qof_instance_get_book (&comm->inst);
1991  nsp = gnc_commodity_table_add_namespace(table, ns_name, book);
1992 
1993  PINFO ("insert %p %s into nsp=%p %s", priv->mnemonic, priv->mnemonic,
1994  nsp->cm_table, nsp->name);
1995  g_hash_table_insert(nsp->cm_table,
1996  CACHE_INSERT(priv->mnemonic),
1997  (gpointer)comm);
1998  nsp->cm_list = g_list_append(nsp->cm_list, comm);
1999 
2000  qof_event_gen (&comm->inst, QOF_EVENT_ADD, NULL);
2001  LEAVE ("(table=%p, comm=%p)", table, comm);
2002  return comm;
2003 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:254
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
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 strucure.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:248
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:276
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:234
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 proably shouldn't be using gnc_commodity_table_new() directly, its for internal use only.

You should probably be using gnc_commodity_table_get_table()

Definition at line 1741 of file gnc-commodity.c.

1742 {
1743  gnc_commodity_table * retval = g_new0(gnc_commodity_table, 1);
1744  retval->ns_table = g_hash_table_new(&g_str_hash, &g_str_equal);
1745  retval->ns_list = NULL;
1746  return retval;
1747 }

◆ 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 2011 of file gnc-commodity.c.

2013 {
2014  gnc_commodity_namespace * nsp;
2015  gnc_commodity *c;
2016  gnc_commodityPrivate* priv;
2017  const char *ns_name;
2018 
2019  if (!table) return;
2020  if (!comm) return;
2021 
2022  priv = GET_PRIVATE(comm);
2023  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
2024  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
2025  if (c != comm) return;
2026 
2027  qof_event_gen (&comm->inst, QOF_EVENT_REMOVE, NULL);
2028 
2029  nsp = gnc_commodity_table_find_namespace(table, ns_name);
2030  if (!nsp) return;
2031 
2032  nsp->cm_list = g_list_remove(nsp->cm_list, comm);
2033  g_hash_table_remove (nsp->cm_table, priv->mnemonic);
2034  /* XXX minor mem leak, should remove the key as well */
2035 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data strucure.
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:234

◆ 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 1373 of file gnc-commodity.c.

1374 {
1375  gnc_commodityPrivate* priv;
1376 
1377  ENTER ("(cm=%p, flag=%d)", cm, flag);
1378 
1379  if (!cm)
1380  {
1381  LEAVE("");
1382  return;
1383  }
1384 
1385  priv = GET_PRIVATE(cm);
1386  gnc_commodity_begin_edit(cm);
1387  gnc_commodity_set_quote_flag(cm, flag);
1388  if (gnc_commodity_is_iso(cm))
1389  {
1390  /* For currencies, disable auto quote control if the quote flag is being
1391  * changed from its default value and enable it if the quote flag is being
1392  * reset to its default value. The defaults for the quote flag are
1393  * disabled if no accounts are using the currency, and true otherwise.
1394  * Thus enable auto quote control if flag is FALSE and there are not any
1395  * accounts using this currency OR flag is TRUE and there are accounts
1396  * using this currency; otherwise disable auto quote control */
1397  gnc_commodity_set_auto_quote_control_flag(cm,
1398  (!flag && (priv->usage_count == 0)) || (flag && (priv->usage_count != 0)));
1399  }
1400  gnc_commodity_commit_edit(cm);
1401  LEAVE("");
1402 }
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:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276
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 2630 of file gnc-commodity.c.

2631 {
2632  MonetaryList *node, *next;
2633  for (node = list; node; node = next)
2634  {
2635  gnc_monetary *mon = node->data;
2636  next = node->next;
2637  if (gnc_numeric_zero_p(mon->value))
2638  {
2639  g_free(mon);
2640  list = g_list_delete_link(list, node);
2641  }
2642  }
2643  return list;
2644 }
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 2648 of file gnc-commodity.c.

2649 {
2650  MonetaryList *tmp;
2651  for (tmp = list; tmp; tmp = tmp->next)
2652  {
2653  g_free(tmp->data);
2654  }
2655 
2656  g_list_free(list);
2657 }

◆ 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 350 of file gnc-commodity.c.

351 {
352  gnc_quote_source *new_source;
353 
354  DEBUG("Creating new source %s", (source_name == NULL ? "(null)" : source_name));
355  new_source = malloc(sizeof(gnc_quote_source));
356  new_source->supported = supported;
357  new_source->type = SOURCE_UNKNOWN;
358  new_source->index = g_list_length(new_quote_sources);
359 
360  /* This name can be changed if/when support for this price source is
361  * integrated into gnucash. */
362  new_source->user_name = g_strdup(source_name);
363 
364  /* This name is permanent and must be kept the same if/when support
365  * for this price source is integrated into gnucash (i.e. for a
366  * nice user name). */
367  new_source->old_internal_name = g_strdup(source_name);
368  new_source->internal_name = g_strdup(source_name);
369  new_quote_sources = g_list_append(new_quote_sources, new_source);
370  return new_source;
371 }
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:260
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 277 of file gnc-commodity.c.

278 {
279  return (fq_version != NULL);
280 }

◆ 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 290 of file gnc-commodity.c.

291 {
292  return fq_version;
293 }

◆ 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 490 of file gnc-commodity.c.

491 {
492  ENTER("%p", source);
493  if (!source)
494  {
495  LEAVE("bad source");
496  return 0;
497  }
498 
499  LEAVE("index is %d", source->index);
500  return source->index;
501 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 531 of file gnc-commodity.c.

532 {
533  ENTER("%p", source);
534  if (!source)
535  {
536  LEAVE("bad source");
537  return NULL;
538  }
539  LEAVE("internal name %s", source->internal_name);
540  return source->internal_name;
541 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 504 of file gnc-commodity.c.

505 {
506  ENTER("%p", source);
507  if (!source)
508  {
509  LEAVE("bad source");
510  return FALSE;
511  }
512 
513  LEAVE("%ssupported", source && source->supported ? "" : "not ");
514  return source->supported;
515 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 476 of file gnc-commodity.c.

477 {
478  ENTER("%p", source);
479  if (!source)
480  {
481  LEAVE("bad source");
482  return SOURCE_SINGLE;
483  }
484 
485  LEAVE("type is %d", source->type);
486  return source->type;
487 }
This quote source pulls from a single specific web site.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 518 of file gnc-commodity.c.

519 {
520  ENTER("%p", source);
521  if (!source)
522  {
523  LEAVE("bad source");
524  return NULL;
525  }
526  LEAVE("user name %s", source->user_name);
527  return source->user_name;
528 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 425 of file gnc-commodity.c.

426 {
427  gnc_quote_source *source;
428  GList *node;
429  gint i;
430 
431  if ((name == NULL) || (g_strcmp0(name, "") == 0))
432  {
433  return NULL;
434  }
435 
436  if (g_strcmp0(name, currency_quote_source.internal_name) == 0)
437  return &currency_quote_source;
438  if (g_strcmp0(name, currency_quote_source.old_internal_name) == 0)
439  return &currency_quote_source;
440 
441  for (i = 0; i < num_single_quote_sources; i++)
442  {
443  if (g_strcmp0(name, single_quote_sources[i].internal_name) == 0)
444  return &single_quote_sources[i];
445  if (g_strcmp0(name, single_quote_sources[i].old_internal_name) == 0)
446  return &single_quote_sources[i];
447  }
448 
449  for (i = 0; i < num_multiple_quote_sources; i++)
450  {
451  if (g_strcmp0(name, multiple_quote_sources[i].internal_name) == 0)
452  return &multiple_quote_sources[i];
453  if (g_strcmp0(name, multiple_quote_sources[i].old_internal_name) == 0)
454  return &multiple_quote_sources[i];
455  }
456 
457  for (i = 0, node = new_quote_sources; node; node = node->next, i++)
458  {
459  source = node->data;
460  if (g_strcmp0(name, source->internal_name) == 0)
461  return source;
462  if (g_strcmp0(name, source->old_internal_name) == 0)
463  return source;
464  }
465 
466  DEBUG("gnc_quote_source_lookup_by_internal: Unknown source %s", name);
467  return NULL;
468 }
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:260

◆ 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 379 of file gnc-commodity.c.

380 {
381  gnc_quote_source *source;
382  GList *node;
383 
384  ENTER("type/index is %d/%d", type, index);
385  switch (type)
386  {
387  case SOURCE_CURRENCY:
388  LEAVE("found %s", currency_quote_source.user_name);
389  return &currency_quote_source;
390  break;
391 
392  case SOURCE_SINGLE:
393  if (index < num_single_quote_sources)
394  {
395  LEAVE("found %s", single_quote_sources[index].user_name);
396  return &single_quote_sources[index];
397  }
398  break;
399 
400  case SOURCE_MULTI:
401  if (index < num_multiple_quote_sources)
402  {
403  LEAVE("found %s", multiple_quote_sources[index].user_name);
404  return &multiple_quote_sources[index];
405  }
406  break;
407 
408  case SOURCE_UNKNOWN:
409  default:
410  node = g_list_nth(new_quote_sources, index);
411  if (node)
412  {
413  source = node->data;
414  LEAVE("found %s", source->user_name);
415  return source;
416  }
417  break;
418  }
419 
420  LEAVE("not found");
421  return NULL;
422 }
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.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
This quote source may pull from multiple web sites.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:276

◆ 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 300 of file gnc-commodity.c.

301 {
302  if (type == SOURCE_CURRENCY)
303  return 1;
304 
305  if (type == SOURCE_SINGLE)
306  return num_single_quote_sources;
307 
308  if (type == SOURCE_MULTI)
309  return num_multiple_quote_sources;
310 
311  return g_list_length(new_quote_sources);
312 }
This quote source pulls from a single specific web site.
The special currency quote source.
This quote source may pull from multiple web sites.

◆ gnc_quote_source_set_fq_installed()

void gnc_quote_source_set_fq_installed ( const char *  version_string,
const GList *  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 551 of file gnc-commodity.c.

553 {
554  gnc_quote_source *source;
555  char *source_name;
556  const GList *node;
557 
558  ENTER(" ");
559 
560  if (!sources_list)
561  return;
562 
563  if (fq_version)
564  {
565  g_free (fq_version);
566  fq_version = NULL;
567  }
568 
569  if (version_string)
570  fq_version = g_strdup (version_string);
571 
572  for (node = sources_list; node; node = node->next)
573  {
574  source_name = node->data;
575 
576  source = gnc_quote_source_lookup_by_internal(source_name);
577  if (source != NULL)
578  {
579  DEBUG("Found source %s: %s", source_name, source->user_name);
580  source->supported = TRUE;
581  continue;
582  }
583 
584  gnc_quote_source_add_new(source_name, TRUE);
585  }
586  LEAVE(" ");
587 }
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:260
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:266
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:276