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

Commodity Accessor Routines - Set

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

Commodity Usage Count Adjustment Routines

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

Commodity Comparison

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

Currency Checks

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

Commodity Table

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

Commodity Table Lookup functions

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

Commodity Table Maintenance functions

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

Commodity Table Namespace functions

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

Commodity Table Accessor functions

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

Commodity Table Private/Internal-Use Only Routines

gnc_commodity_table * gnc_commodity_table_new (void)
 You probably shouldn't be using gnc_commodity_table_new() directly, 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 1005 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 107 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 138 of file gnc-commodity.h.

139 {
140  SOURCE_SINGLE = 0,
144  SOURCE_MULTI,
151  SOURCE_MAX,
152  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 1709 of file gnc-commodity.c.

1710 {
1711  if (gnc_commodity_equal(a, b))
1712  {
1713  return 0;
1714  }
1715  else
1716  {
1717  return 1;
1718  }
1719 }
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 1595 of file gnc-commodity.c.

1596 {
1597  gnc_commodityPrivate* priv;
1598 
1599  ENTER("(cm=%p)", cm);
1600 
1601  if (!cm)
1602  {
1603  LEAVE("");
1604  return;
1605  }
1606 
1607  priv = GET_PRIVATE(cm);
1608 
1609  if (priv->usage_count == 0)
1610  {
1611  PWARN("usage_count already zero");
1612  LEAVE("");
1613  return;
1614  }
1615 
1616  priv->usage_count--;
1617  if ((priv->usage_count == 0) && priv->quote_flag
1618  && gnc_commodity_get_auto_quote_control_flag(cm)
1619  && gnc_commodity_is_iso(cm))
1620  {
1621  /* if this is a currency with auto quote control enabled and no more
1622  * accounts reference this currency, disable quote retrieval */
1623  gnc_commodity_set_quote_flag(cm, FALSE);
1624  }
1625  LEAVE("(usage_count=%d)", priv->usage_count);
1626 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ gnc_commodity_destroy()

void gnc_commodity_destroy ( gnc_commodity *  cm)

Destroy a commodity.

Release all memory attached to this data structure.

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

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

981 {
982  gnc_commodity_begin_edit(cm);
983  qof_instance_set_destroying(cm, TRUE);
984  gnc_commodity_commit_edit(cm);
985 }

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

1655 {
1656  gnc_commodityPrivate* priv_a;
1657  gnc_commodityPrivate* priv_b;
1658  gboolean same_book;
1659 
1660  if (a == b) return TRUE;
1661 
1662  if (!a || !b)
1663  {
1664  DEBUG ("one is NULL");
1665  return FALSE;
1666  }
1667 
1668  priv_a = GET_PRIVATE(a);
1669  priv_b = GET_PRIVATE(b);
1670  same_book = qof_instance_get_book(QOF_INSTANCE(a)) == qof_instance_get_book(QOF_INSTANCE(b));
1671 
1672  if ((same_book && priv_a->name_space != priv_b->name_space)
1673  || (!same_book && g_strcmp0( gnc_commodity_namespace_get_name(priv_a->name_space),
1674  gnc_commodity_namespace_get_name(priv_b->name_space)) != 0))
1675  {
1676  DEBUG ("namespaces differ: %p(%s) vs %p(%s)",
1677  priv_a->name_space, gnc_commodity_namespace_get_name(priv_a->name_space),
1678  priv_b->name_space, gnc_commodity_namespace_get_name(priv_b->name_space));
1679  return FALSE;
1680  }
1681 
1682  if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0)
1683  {
1684  DEBUG ("mnemonics differ: %s vs %s", priv_a->mnemonic, priv_b->mnemonic);
1685  return FALSE;
1686  }
1687 
1688  if (g_strcmp0(priv_a->fullname, priv_b->fullname) != 0)
1689  {
1690  DEBUG ("fullnames differ: %s vs %s", priv_a->fullname, priv_b->fullname);
1691  return FALSE;
1692  }
1693 
1694  if (g_strcmp0(priv_a->cusip, priv_b->cusip) != 0)
1695  {
1696  DEBUG ("cusips differ: %s vs %s", priv_a->cusip, priv_b->cusip);
1697  return FALSE;
1698  }
1699 
1700  if (priv_a->fraction != priv_b->fraction)
1701  {
1702  DEBUG ("fractions differ: %d vs %d", priv_a->fraction, priv_b->fraction);
1703  return FALSE;
1704  }
1705 
1706  return TRUE;
1707 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.

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

1639 {
1640  gnc_commodityPrivate* priv_a;
1641  gnc_commodityPrivate* priv_b;
1642 
1643  if (a == b) return TRUE;
1644  if (!a || !b) return FALSE;
1645 
1646  priv_a = GET_PRIVATE(a);
1647  priv_b = GET_PRIVATE(b);
1648  if (priv_a->name_space != priv_b->name_space) return FALSE;
1649  if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0) return FALSE;
1650  return TRUE;
1651 }

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

1106 {
1107  if (!cm) return NULL;
1108  return GET_PRIVATE(cm)->cusip;
1109 }

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

1212 {
1213  if (!cm) return NULL;
1214  return GET_PRIVATE(cm)->default_symbol;
1215 }

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

1117 {
1118  if (!cm) return 0;
1119  return GET_PRIVATE(cm)->fraction;
1120 }

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

1082 {
1083  if (!cm) return NULL;
1084  return GET_PRIVATE(cm)->fullname;
1085 }

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

1041 {
1042  if (!cm) return NULL;
1043  return GET_PRIVATE(cm)->mnemonic;
1044 }

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

1064 {
1065  if (!cm) return NULL;
1066  return gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
1067 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.

◆ gnc_commodity_get_namespace_ds()

gnc_commodity_namespace* gnc_commodity_get_namespace_ds ( const gnc_commodity *  cm)

Retrieve the namespace data structure for the specified commodity.

This will be a pointer to another data structure.

Parameters
cmA pointer to a commodity data structure.
Returns
A pointer to the namespace data structure for this commodity.

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

1071 {
1072  if (!cm) return NULL;
1073  return GET_PRIVATE(cm)->name_space;
1074 }

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

1222 {
1223  const char *nice_symbol;
1224  struct lconv *lc;
1225  if (!cm) return NULL;
1226 
1227  nice_symbol = gnc_commodity_get_user_symbol(cm);
1228  if (nice_symbol && *nice_symbol)
1229  return nice_symbol;
1230 
1231  lc = gnc_localeconv();
1232  nice_symbol = lc->currency_symbol;
1233  if (!g_strcmp0(gnc_commodity_get_mnemonic(cm), lc->int_curr_symbol))
1234  return nice_symbol;
1235 
1236  nice_symbol = gnc_commodity_get_default_symbol(cm);
1237  if (nice_symbol && *nice_symbol)
1238  return nice_symbol;
1239 
1240  return gnc_commodity_get_mnemonic(cm);
1241 }
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 1051 of file gnc-commodity.c.

1052 {
1053  if (!cm) return NULL;
1054  return GET_PRIVATE(cm)->printname;
1055 }

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

1147 {
1148  if (!cm) return FALSE;
1149  return (GET_PRIVATE(cm)->quote_flag);
1150 }

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

1158 {
1159  gnc_commodityPrivate* priv;
1160 
1161  if (!cm) return NULL;
1162  priv = GET_PRIVATE(cm);
1163  if (!priv->quote_source && gnc_commodity_is_iso(cm))
1164  return &currency_quote_source;
1165  return priv->quote_source;
1166 }
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 1182 of file gnc-commodity.c.

1183 {
1184  if (!cm) return NULL;
1185  return GET_PRIVATE(cm)->quote_tz;
1186 }

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

1094 {
1095  if (!cm) return NULL;
1096  return GET_PRIVATE(cm)->unique_name;
1097 }

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

1193 {
1194  gnc_commodityPrivate* priv;
1195  g_return_val_if_fail (GNC_IS_COMMODITY (cm), NULL);
1196  priv = GET_PRIVATE(cm);
1197  if (priv->user_symbol == is_unset)
1198  {
1199  GValue v = G_VALUE_INIT;
1200  qof_instance_get_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1201  priv->user_symbol = G_VALUE_HOLDS_STRING (&v) ? g_value_dup_string (&v) : NULL;
1202  g_value_unset (&v);
1203  }
1204  return priv->user_symbol;
1205 }
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 1560 of file gnc-commodity.c.

1561 {
1562  gnc_commodityPrivate* priv;
1563 
1564  ENTER("(cm=%p)", cm);
1565 
1566  if (!cm)
1567  {
1568  LEAVE("");
1569  return;
1570  }
1571 
1572  priv = GET_PRIVATE(cm);
1573 
1574  if ((priv->usage_count == 0) && !priv->quote_flag
1575  && gnc_commodity_get_auto_quote_control_flag(cm)
1576  && gnc_commodity_is_iso(cm))
1577  {
1578  /* compatibility hack - Gnucash 1.8 gets currency quotes when a
1579  non-default currency is assigned to an account. */
1580  gnc_commodity_begin_edit(cm);
1581  gnc_commodity_set_quote_flag(cm, TRUE);
1583  gnc_commodity_get_default_quote_source(cm));
1584  gnc_commodity_commit_edit(cm);
1585  }
1586  priv->usage_count++;
1587  LEAVE("(usage_count=%d)", priv->usage_count);
1588 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
void gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src)
Set the automatic price quote source for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ gnc_commodity_is_currency()

gboolean gnc_commodity_is_currency ( const gnc_commodity *  cm)

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

Parameters
cmThe commodity to check.
Returns
TRUE if the commodity represents a currency, FALSE otherwise.

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

2173 {
2174  const char *ns_name;
2175  if (!cm) return FALSE;
2176 
2177  ns_name = gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
2178  return (!g_strcmp0(ns_name, GNC_COMMODITY_NS_LEGACY) ||
2179  !g_strcmp0(ns_name, GNC_COMMODITY_NS_CURRENCY));
2180 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
#define GNC_COMMODITY_NS_LEGACY
The commodity namespace definitions are used to tag a commodity by its type, or a stocks by the excha...

◆ gnc_commodity_is_iso()

gboolean gnc_commodity_is_iso ( const gnc_commodity *  cm)

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

Parameters
cmThe commodity to check.
Returns
TRUE if the commodity represents a currency, FALSE otherwise.

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

2161 {
2162  gnc_commodityPrivate* priv;
2163 
2164  if (!cm) return FALSE;
2165 
2166  priv = GET_PRIVATE(cm);
2167  if ( !priv->name_space) return FALSE;
2168  return priv->name_space->iso4217;
2169 }

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

1749 {
1750  if (!name_space)
1751  return NULL;
1752 
1753  return name_space->cm_list;
1754 }

◆ gnc_commodity_namespace_get_gui_name()

const char* gnc_commodity_namespace_get_gui_name ( const gnc_commodity_namespace *  ns)

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

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

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

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

1739 {
1740  if (ns == NULL)
1741  return NULL;
1742  if (g_strcmp0 (ns->name, GNC_COMMODITY_NS_CURRENCY) == 0)
1743  return GNC_COMMODITY_NS_ISO_GUI;
1744  return ns->name;
1745 }

◆ gnc_commodity_namespace_get_name()

const char* gnc_commodity_namespace_get_name ( const gnc_commodity_namespace *  ns)

Return the textual name of a namespace data structure.

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

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

1731 {
1732  if (ns == NULL)
1733  return NULL;
1734  return ns->name;
1735 }

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

1758 {
1759  return ((g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0) ||
1760  (g_strcmp0(name_space, GNC_COMMODITY_NS_CURRENCY) == 0));
1761 }

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

886 {
887  gnc_commodity * retval = g_object_new(GNC_TYPE_COMMODITY, NULL);
888 
889  qof_instance_init_data (&retval->inst, GNC_ID_COMMODITY, book);
890  gnc_commodity_begin_edit(retval);
891 
892  if ( name_space != NULL )
893  {
894  /* Prevent setting anything except template in namespace template. */
895  if (g_strcmp0 (name_space, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
896  g_strcmp0 (mnemonic, "template") != 0)
897  {
898  PWARN("Converting commodity %s from namespace template to "
899  "namespace User", mnemonic);
900  name_space = "User";
901  }
902  gnc_commodity_set_namespace(retval, name_space);
903  if (gnc_commodity_namespace_is_iso(name_space))
904  {
907  }
908  }
909  gnc_commodity_set_fullname(retval, fullname);
910  gnc_commodity_set_mnemonic(retval, mnemonic);
911  gnc_commodity_set_cusip(retval, cusip);
912  gnc_commodity_set_fraction(retval, fraction);
913  mark_commodity_dirty (retval);
914  gnc_commodity_commit_edit(retval);
915 
916  qof_event_gen (&retval->inst, QOF_EVENT_CREATE, NULL);
917 
918  return retval;
919 }
void gnc_commodity_set_fraction(gnc_commodity *cm, int fraction)
Set the fraction for the specified commodity.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void qof_instance_init_data(QofInstance *inst, QofIdType type, QofBook *book)
Initialise the settings associated with an instance.
void gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src)
Set the automatic price quote source for the specified commodity.
void gnc_commodity_set_cusip(gnc_commodity *cm, const char *cusip)
Set the &#39;exchange code&#39; for the specified commodity.
gboolean gnc_commodity_namespace_is_iso(const char *name_space)
Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.
gnc_quote_source * gnc_quote_source_lookup_by_internal(const char *name)
Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by th...
void gnc_commodity_set_fullname(gnc_commodity *cm, const char *fullname)
Set the full name for the specified commodity.
void gnc_commodity_set_mnemonic(gnc_commodity *cm, const char *mnemonic)
Set the mnemonic for the specified commodity.
void gnc_commodity_set_namespace(gnc_commodity *cm, const char *name_space)
Set the namespace for the specified commodity.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ gnc_commodity_obtain_twin()

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

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

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

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

1798 {
1799  gnc_commodity *twin;
1800  const char * ucom;
1801  gnc_commodity_table * comtbl;
1802 
1803  if (!from) return NULL;
1804  comtbl = gnc_commodity_table_get_table (book);
1805  if (!comtbl) return NULL;
1806 
1807  ucom = gnc_commodity_get_unique_name (from);
1808  twin = gnc_commodity_table_lookup_unique (comtbl, ucom);
1809  if (!twin)
1810  {
1811  twin = gnc_commodity_clone (from, book);
1812  twin = gnc_commodity_table_insert (comtbl, twin);
1813  }
1814  return twin;
1815 }
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 1323 of file gnc-commodity.c.

1325 {
1326  gnc_commodityPrivate* priv;
1327 
1328  if (!cm) return;
1329 
1330  priv = GET_PRIVATE(cm);
1331  if (priv->cusip == cusip) return;
1332 
1333  gnc_commodity_begin_edit(cm);
1334  CACHE_REMOVE (priv->cusip);
1335  priv->cusip = CACHE_INSERT (cusip);
1336  mark_commodity_dirty(cm);
1337  gnc_commodity_commit_edit(cm);
1338 }

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

1346 {
1347  if (!cm) return;
1348  gnc_commodity_begin_edit(cm);
1349  GET_PRIVATE(cm)->fraction = fraction;
1350  mark_commodity_dirty(cm);
1351  gnc_commodity_commit_edit(cm);
1352 }

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

1302 {
1303  gnc_commodityPrivate* priv;
1304 
1305  if (!cm) return;
1306  priv = GET_PRIVATE(cm);
1307  if (priv->fullname == fullname) return;
1308 
1309  CACHE_REMOVE (priv->fullname);
1310  priv->fullname = CACHE_INSERT (fullname);
1311 
1312  gnc_commodity_begin_edit(cm);
1313  mark_commodity_dirty(cm);
1314  reset_printname(priv);
1315  gnc_commodity_commit_edit(cm);
1316 }

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

1249 {
1250  gnc_commodityPrivate* priv;
1251 
1252  if (!cm) return;
1253  priv = GET_PRIVATE(cm);
1254  if (priv->mnemonic == mnemonic) return;
1255 
1256  gnc_commodity_begin_edit(cm);
1257  CACHE_REMOVE (priv->mnemonic);
1258  priv->mnemonic = CACHE_INSERT(mnemonic);
1259 
1260  mark_commodity_dirty (cm);
1261  reset_printname(priv);
1262  reset_unique_name(priv);
1263  gnc_commodity_commit_edit(cm);
1264 }

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

1272 {
1273  QofBook *book;
1274  gnc_commodity_table *table;
1275  gnc_commodity_namespace *nsp;
1276  gnc_commodityPrivate* priv;
1277 
1278  if (!cm) return;
1279  priv = GET_PRIVATE(cm);
1280  book = qof_instance_get_book (&cm->inst);
1282  nsp = gnc_commodity_table_add_namespace(table, name_space, book);
1283  if (priv->name_space == nsp)
1284  return;
1285 
1286  gnc_commodity_begin_edit(cm);
1287  priv->name_space = nsp;
1288  if (nsp->iso4217)
1289  priv->quote_source = gnc_quote_source_lookup_by_internal("currency");
1290  mark_commodity_dirty(cm);
1291  reset_printname(priv);
1292  reset_unique_name(priv);
1293  gnc_commodity_commit_edit(cm);
1294 }
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 1426 of file gnc-commodity.c.

1427 {
1428  ENTER ("(cm=%p, flag=%d)", cm, flag);
1429 
1430  if (!cm) return;
1431  gnc_commodity_begin_edit(cm);
1432  GET_PRIVATE(cm)->quote_flag = flag;
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:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_commodity_set_quote_source()

void gnc_commodity_set_quote_source ( gnc_commodity *  cm,
gnc_quote_source *  src 
)

Set the automatic price quote source for the specified commodity.

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

Parameters
cmA pointer to a commodity data structure.
srcA pointer to the price quote source for this commodity.

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

1444 {
1445  ENTER ("(cm=%p, src=%p(%s))", cm, src, src ? src->internal_name : "unknown");
1446 
1447  if (!cm) return;
1448  gnc_commodity_begin_edit(cm);
1449  GET_PRIVATE(cm)->quote_source = src;
1450  mark_commodity_dirty(cm);
1451  gnc_commodity_commit_edit(cm);
1452  LEAVE(" ");
1453 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_commodity_set_quote_tz()

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

Set the automatic price quote timezone for the specified commodity.

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

Parameters
cmA pointer to a commodity data structure.
tzA pointer to the price quote timezone for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1461 {
1462  gnc_commodityPrivate* priv;
1463 
1464  if (!cm) return;
1465 
1466  ENTER ("(cm=%p, tz=%s)", cm, tz ? tz : "(null)");
1467 
1468  priv = GET_PRIVATE(cm);
1469 
1470  if (tz == priv->quote_tz)
1471  {
1472  LEAVE("Already correct TZ");
1473  return;
1474  }
1475 
1476  gnc_commodity_begin_edit(cm);
1477  CACHE_REMOVE (priv->quote_tz);
1478  priv->quote_tz = CACHE_INSERT (tz);
1479  mark_commodity_dirty(cm);
1480  gnc_commodity_commit_edit(cm);
1481  LEAVE(" ");
1482 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_commodity_set_user_symbol()

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

Set a user-defined symbol for the specified commodity.

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

Parameters
cmA pointer to a commodity data structure.
tzA pointer to the symbol for this commodity. This string belongs to the caller and will be duplicated by the engine.

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

1490 {
1491  struct lconv *lc;
1492  gnc_commodityPrivate* priv;
1493 
1494  if (!cm) return;
1495  priv = GET_PRIVATE(cm);
1496 
1497  ENTER ("(cm=%p, symbol=%s)", cm, user_symbol ? user_symbol : "(null)");
1498 
1499  lc = gnc_localeconv();
1500  if (!user_symbol || !*user_symbol)
1501  user_symbol = NULL;
1502  else if (!g_strcmp0(lc->int_curr_symbol, gnc_commodity_get_mnemonic(cm)) &&
1503  !g_strcmp0(lc->currency_symbol, user_symbol))
1504  /* if the user gives the ISO symbol for the locale currency or the
1505  * default symbol, actually remove the user symbol */
1506  user_symbol = NULL;
1507  else if (!g_strcmp0(user_symbol, gnc_commodity_get_default_symbol(cm)))
1508  user_symbol = NULL;
1509 
1510  if (priv->user_symbol != is_unset)
1511  {
1512  if (!g_strcmp0 (user_symbol, priv->user_symbol))
1513  {
1514  LEAVE ("gnc_commodity_set_user_symbol: no change");
1515  return;
1516  }
1517  g_free (priv->user_symbol);
1518  }
1519 
1520  gnc_commodity_begin_edit (cm);
1521 
1522  if (user_symbol)
1523  {
1524  GValue v = G_VALUE_INIT;
1525  g_value_init (&v, G_TYPE_STRING);
1526  g_value_set_string (&v, user_symbol);
1527  qof_instance_set_kvp (QOF_INSTANCE(cm), &v, 1, "user_symbol");
1528  priv->user_symbol = g_strdup (user_symbol);
1529  g_value_unset (&v);
1530  }
1531  else
1532  {
1533  qof_instance_set_kvp (QOF_INSTANCE(cm), NULL, 1, "user_symbol");
1534  priv->user_symbol = NULL;
1535  }
1536 
1537  mark_commodity_dirty(cm);
1538  gnc_commodity_commit_edit(cm);
1539 
1540  LEAVE(" ");
1541 }
void qof_instance_set_kvp(QofInstance *, GValue const *value, unsigned count,...)
Sets a KVP slot to a value from a GValue.
const char * gnc_commodity_get_mnemonic(const gnc_commodity *cm)
Retrieve the mnemonic for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
const char * gnc_commodity_get_default_symbol(const gnc_commodity *cm)
Retrieve the default symbol for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_commodity_table_add_default_data()

gboolean gnc_commodity_table_add_default_data ( gnc_commodity_table *  table,
QofBook *  book 
)

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

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

Parameters
tableA pointer to the commodity table.
bookUnused.

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

2508 {
2509  QofCollection *col;
2510  gnc_commodity* c;
2511 
2512  ENTER ("table=%p", table);
2513  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_AMEX, book);
2514  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_NYSE, book);
2515  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_NASDAQ, book);
2516  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_EUREX, book);
2517  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_MUTUAL, book);
2518  gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_TEMPLATE, book);
2519  c = gnc_commodity_new(book, "template", GNC_COMMODITY_NS_TEMPLATE, "template", "template", 1);
2521 
2522 #include "iso-4217-currencies.c"
2523 
2524  /* We've just created the default namespaces and currencies. Mark
2525  * these collections as clean because there is no USER entered data
2526  * in these collections as of yet. */
2527  col = qof_book_get_collection(book, GNC_ID_COMMODITY);
2529  col = qof_book_get_collection(book, GNC_ID_COMMODITY_NAMESPACE);
2531 
2532  LEAVE ("table=%p", table);
2533  return TRUE;
2534 }
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table *table, gnc_commodity *comm)
Add a new commodity to the commodity table.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table *table, const char *name_space, QofBook *book)
This function adds a new string to the list of commodity namespaces.
gnc_commodity * gnc_commodity_new(QofBook *book, const char *fullname, const char *name_space, const char *mnemonic, const char *cusip, int fraction)
Create a new commodity.
void qof_collection_mark_clean(QofCollection *)
reset value of dirty flag
Definition: qofid.cpp:263
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:604

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

2330 {
2331  gnc_commodity_namespace * ns = NULL;
2332 
2333  if (!table) return NULL;
2334 
2335  name_space = gnc_commodity_table_map_namespace(name_space);
2336  ns = gnc_commodity_table_find_namespace(table, name_space);
2337  if (!ns)
2338  {
2339  ns = g_object_new(GNC_TYPE_COMMODITY_NAMESPACE, NULL);
2340  ns->cm_table = g_hash_table_new(g_str_hash, g_str_equal);
2341  ns->name = CACHE_INSERT((gpointer)name_space);
2342  ns->iso4217 = gnc_commodity_namespace_is_iso(name_space);
2343  qof_instance_init_data (&ns->inst, GNC_ID_COMMODITY_NAMESPACE, book);
2344  qof_event_gen (&ns->inst, QOF_EVENT_CREATE, NULL);
2345 
2346  g_hash_table_insert(table->ns_table,
2347  (gpointer) ns->name,
2348  (gpointer) ns);
2349  table->ns_list = g_list_append(table->ns_list, ns);
2350  qof_event_gen (&ns->inst, QOF_EVENT_ADD, NULL);
2351  }
2352  return ns;
2353 }
void qof_instance_init_data(QofInstance *inst, QofIdType type, QofBook *book)
Initialise the settings associated with an instance.
gboolean gnc_commodity_namespace_is_iso(const char *name_space)
Checks to see if the specified commodity namespace is the namespace for ISO 4217 currencies.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ gnc_commodity_table_delete_namespace()

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

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

If the namespace does not exist, nothing happens.

Parameters
tableA pointer to the commodity table
commodity_namespaceThe namespace to be deleted.
Note
This routine will destroy any commodities that exist as part of this namespace. Use it carefully.

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

2394 {
2395  gnc_commodity_namespace * ns;
2396 
2397  if (!table) return;
2398 
2399  ns = gnc_commodity_table_find_namespace(table, name_space);
2400  if (!ns)
2401  return;
2402 
2403  qof_event_gen (&ns->inst, QOF_EVENT_REMOVE, NULL);
2404  g_hash_table_remove(table->ns_table, name_space);
2405  table->ns_list = g_list_remove(table->ns_list, ns);
2406 
2407  g_list_free(ns->cm_list);
2408  ns->cm_list = NULL;
2409 
2410  g_hash_table_foreach_remove(ns->cm_table, ns_helper, NULL);
2411  g_hash_table_destroy(ns->cm_table);
2412  CACHE_REMOVE(ns->name);
2413 
2414  qof_event_gen (&ns->inst, QOF_EVENT_DESTROY, NULL);
2415  /* qof_instance_release(&ns->inst); */
2416  g_object_unref(ns);
2417 }
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ gnc_commodity_table_find_namespace()

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

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

Parameters
tableA pointer to the commodity table
commodity_namespaceThe new namespace to be added.
Returns
The a pointer to the namespace found, or NULL if the namespace doesn't exist.

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

2359 {
2360  if (!table || !name_space)
2361  return NULL;
2362 
2363  name_space = gnc_commodity_table_map_namespace(name_space);
2364  return g_hash_table_lookup(table->ns_table, (gpointer)name_space);
2365 }

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

2210 {
2211  gnc_commodity_namespace * ns = NULL;
2212 
2213  if (!table)
2214  return NULL;
2215  if (g_strcmp0(name_space, GNC_COMMODITY_NS_NONCURRENCY) == 0)
2216  return commodity_table_get_all_noncurrency_commodities(table);
2217  ns = gnc_commodity_table_find_namespace(table, name_space);
2218  if (!ns)
2219  return NULL;
2220 
2221  return g_hash_table_values(ns->cm_table);
2222 }
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 2136 of file gnc-commodity.c.

2137 {
2138  if (!table)
2139  return NULL;
2140 
2141  return g_hash_table_keys(table->ns_table);
2142 }

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

2146 {
2147  if (!table)
2148  return NULL;
2149 
2150  return table->ns_list;
2151 }

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

2257 {
2258  gnc_commodity_namespace * ns = NULL;
2259  const char *name_space;
2260  GList * nslist, * tmp;
2261  GList * l = NULL;
2262  regex_t pattern;
2263  const char *expression = gnc_prefs_get_namespace_regexp();
2264 
2265  ENTER("table=%p, expression=%s", table, expression);
2266  if (!table)
2267  return NULL;
2268 
2269  if (expression && *expression)
2270  {
2271  if (regcomp(&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
2272  {
2273  LEAVE("Cannot compile regex");
2274  return NULL;
2275  }
2276 
2278  for (tmp = nslist; tmp; tmp = tmp->next)
2279  {
2280  name_space = tmp->data;
2281  if (regexec(&pattern, name_space, 0, NULL, 0) == 0)
2282  {
2283  DEBUG("Running list of %s commodities", name_space);
2284  ns = gnc_commodity_table_find_namespace(table, name_space);
2285  if (ns)
2286  {
2287  g_hash_table_foreach(ns->cm_table, &get_quotables_helper1, (gpointer) &l);
2288  }
2289  }
2290  }
2291  g_list_free(nslist);
2292  regfree(&pattern);
2293  }
2294  else
2295  {
2296  gnc_commodity_table_foreach_commodity(table, get_quotables_helper2,
2297  (gpointer) &l);
2298  }
2299  LEAVE("list head %p", l);
2300  return l;
2301 }
gboolean gnc_commodity_table_foreach_commodity(const gnc_commodity_table *table, gboolean(*f)(gnc_commodity *cm, gpointer user_data), gpointer user_data)
Call a function once for each commodity in the commodity table.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
GList * gnc_commodity_table_get_namespaces(const gnc_commodity_table *table)
Return a list of all namespaces in the commodity table.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_commodity_table_get_size()

guint gnc_commodity_table_get_size ( const gnc_commodity_table *  tbl)

Returns the number of commodities in the commodity table.

Parameters
tblA pointer to the commodity table
Returns
The number of commodities in the table. 0 if there are no commodities, or the routine was passed a bad argument.

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

1841 {
1842  guint count = 0;
1843  g_return_val_if_fail(tbl, 0);
1844  g_return_val_if_fail(tbl->ns_table, 0);
1845 
1846  g_hash_table_foreach(tbl->ns_table, count_coms, (gpointer)&count);
1847 
1848  return count;
1849 }

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

2081 {
2082  gnc_commodity_namespace * nsp = NULL;
2083 
2084  if (!table || !name_space)
2085  {
2086  return 0;
2087  }
2088 
2089  nsp = gnc_commodity_table_find_namespace(table, name_space);
2090  if (nsp)
2091  {
2092  return 1;
2093  }
2094  else
2095  {
2096  return 0;
2097  }
2098 }
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 1966 of file gnc-commodity.c.

1968 {
1969  gnc_commodity_namespace * nsp = NULL;
1970  gnc_commodity *c;
1971  const char *ns_name;
1972  gnc_commodityPrivate* priv;
1973  QofBook *book;
1974 
1975  if (!table) return NULL;
1976  if (!comm) return NULL;
1977 
1978  priv = GET_PRIVATE(comm);
1979 
1980  ENTER ("(table=%p, comm=%p) %s %s", table, comm,
1981  (priv->mnemonic == NULL ? "(null)" : priv->mnemonic),
1982  (priv->fullname == NULL ? "(null)" : priv->fullname));
1983  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1984  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1985 
1986  if (c)
1987  {
1988  if (c == comm)
1989  {
1990  LEAVE("already in table");
1991  return c;
1992  }
1993 
1994  /* Backward compatibility support for currencies that have
1995  * recently changed. */
1996  if (priv->name_space->iso4217)
1997  {
1998  guint i;
1999  for (i = 0; i < GNC_NEW_ISO_CODES; i++)
2000  {
2001  if (!priv->mnemonic
2002  || !strcmp(priv->mnemonic, gnc_new_iso_codes[i].old_code))
2003  {
2004  gnc_commodity_set_mnemonic(comm, gnc_new_iso_codes[i].new_code);
2005  break;
2006  }
2007  }
2008  }
2009  gnc_commodity_copy (c, comm);
2010  gnc_commodity_destroy (comm);
2011  LEAVE("found at %p", c);
2012  return c;
2013  }
2014 
2015  /* Prevent setting anything except template in namespace template. */
2016  if (g_strcmp0 (ns_name, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
2017  g_strcmp0 (priv->mnemonic, "template") != 0)
2018  {
2019  PWARN("Converting commodity %s from namespace template to "
2020  "namespace User", priv->mnemonic);
2021  gnc_commodity_set_namespace (comm, "User");
2022  ns_name = "User";
2023  mark_commodity_dirty (comm);
2024  }
2025 
2026  book = qof_instance_get_book (&comm->inst);
2027  nsp = gnc_commodity_table_add_namespace(table, ns_name, book);
2028 
2029  PINFO ("insert %p %s into nsp=%p %s", priv->mnemonic, priv->mnemonic,
2030  nsp->cm_table, nsp->name);
2031  g_hash_table_insert(nsp->cm_table,
2032  (gpointer)CACHE_INSERT(priv->mnemonic),
2033  (gpointer)comm);
2034  nsp->cm_list = g_list_append(nsp->cm_list, comm);
2035 
2036  qof_event_gen (&comm->inst, QOF_EVENT_ADD, NULL);
2037  LEAVE ("(table=%p, comm=%p)", table, comm);
2038  return comm;
2039 }
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table *table, const char *name_space, QofBook *book)
This function adds a new string to the list of commodity namespaces.
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void gnc_commodity_set_mnemonic(gnc_commodity *cm, const char *mnemonic)
Set the mnemonic for the specified commodity.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
void gnc_commodity_set_namespace(gnc_commodity *cm, const char *name_space)
Set the namespace for the specified commodity.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
void gnc_commodity_copy(gnc_commodity *dest, const gnc_commodity *src)
Copy src into dest.
void gnc_commodity_destroy(gnc_commodity *cm)
Destroy a commodity.

◆ gnc_commodity_table_new()

gnc_commodity_table* gnc_commodity_table_new ( void  )

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

You should probably be using gnc_commodity_table_get_table()

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

1778 {
1779  gnc_commodity_table * retval = g_new0(gnc_commodity_table, 1);
1780  retval->ns_table = g_hash_table_new(&g_str_hash, &g_str_equal);
1781  retval->ns_list = NULL;
1782  return retval;
1783 }

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

2049 {
2050  gnc_commodity_namespace * nsp;
2051  gnc_commodity *c;
2052  gnc_commodityPrivate* priv;
2053  const char *ns_name;
2054 
2055  if (!table) return;
2056  if (!comm) return;
2057 
2058  priv = GET_PRIVATE(comm);
2059  ns_name = gnc_commodity_namespace_get_name(priv->name_space);
2060  c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
2061  if (c != comm) return;
2062 
2063  qof_event_gen (&comm->inst, QOF_EVENT_REMOVE, NULL);
2064 
2065  nsp = gnc_commodity_table_find_namespace(table, ns_name);
2066  if (!nsp) return;
2067 
2068  nsp->cm_list = g_list_remove(nsp->cm_list, comm);
2069  g_hash_table_remove (nsp->cm_table, priv->mnemonic);
2070  /* XXX minor mem leak, should remove the key as well */
2071 }
const char * gnc_commodity_namespace_get_name(const gnc_commodity_namespace *ns)
Return the textual name of a namespace data structure.
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table *table, const char *name_space)
This function finds a commodity namespace in the set of existing commodity namespaces.
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231

◆ gnc_commodity_user_set_quote_flag()

void gnc_commodity_user_set_quote_flag ( gnc_commodity *  cm,
const gboolean  flag 
)

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

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

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

Parameters
cmA pointer to a commodity data structure.
flagTRUE if quotes should be pulled for this commodity, FALSE otherwise.

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

1391 {
1392  gnc_commodityPrivate* priv;
1393 
1394  ENTER ("(cm=%p, flag=%d)", cm, flag);
1395 
1396  if (!cm)
1397  {
1398  LEAVE("");
1399  return;
1400  }
1401 
1402  priv = GET_PRIVATE(cm);
1403  gnc_commodity_begin_edit(cm);
1404  gnc_commodity_set_quote_flag(cm, flag);
1405  if (gnc_commodity_is_iso(cm))
1406  {
1407  /* For currencies, disable auto quote control if the quote flag is being
1408  * changed from its default value and enable it if the quote flag is being
1409  * reset to its default value. The defaults for the quote flag are
1410  * disabled if no accounts are using the currency, and true otherwise.
1411  * Thus enable auto quote control if flag is FALSE and there are not any
1412  * accounts using this currency OR flag is TRUE and there are accounts
1413  * using this currency; otherwise disable auto quote control */
1414  gnc_commodity_set_auto_quote_control_flag(cm,
1415  (!flag && (priv->usage_count == 0)) || (flag && (priv->usage_count != 0)));
1416  }
1417  gnc_commodity_commit_edit(cm);
1418  LEAVE("");
1419 }
void gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
Set the automatic price quote flag for the specified commodity.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
gboolean gnc_commodity_is_iso(const gnc_commodity *cm)
Checks to see if the specified commodity is an ISO 4217 recognized currency.

◆ gnc_monetary_list_delete_zeros()

MonetaryList* gnc_monetary_list_delete_zeros ( MonetaryList *  list)

Delete all the zero-value entries from a list.

Delete all the zero-value entries from a list.

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

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

2667 {
2668  MonetaryList *node, *next;
2669  for (node = list; node; node = next)
2670  {
2671  gnc_monetary *mon = node->data;
2672  next = node->next;
2673  if (gnc_numeric_zero_p(mon->value))
2674  {
2675  g_free(mon);
2676  list = g_list_delete_link(list, node);
2677  }
2678  }
2679  return list;
2680 }
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 2684 of file gnc-commodity.c.

2685 {
2686  MonetaryList *tmp;
2687  for (tmp = list; tmp; tmp = tmp->next)
2688  {
2689  g_free(tmp->data);
2690  }
2691 
2692  g_list_free(list);
2693 }

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

355 {
356  gnc_quote_source *new_source;
357 
358  DEBUG("Creating new source %s", (source_name == NULL ? "(null)" : source_name));
359  new_source = malloc(sizeof(gnc_quote_source));
360  new_source->supported = supported;
361  new_source->type = SOURCE_UNKNOWN;
362  new_source->index = g_list_length(new_quote_sources);
363 
364  /* This name can be changed if/when support for this price source is
365  * integrated into gnucash. */
366  new_source->user_name = g_strdup(source_name);
367 
368  /* This name is permanent and must be kept the same if/when support
369  * for this price source is integrated into gnucash (i.e. for a
370  * nice user name). */
371  new_source->old_internal_name = g_strdup(source_name);
372  new_source->internal_name = g_strdup(source_name);
373  new_quote_sources = g_list_append(new_quote_sources, new_source);
374  return new_source;
375 }
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
This is a locally installed quote source that gnucash knows nothing about.

◆ gnc_quote_source_fq_installed()

gboolean gnc_quote_source_fq_installed ( void  )

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

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

Returns
TRUE is F::Q is installed properly.

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

282 {
283  return (fq_version != NULL);
284 }

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

295 {
296  return fq_version;
297 }

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

495 {
496  ENTER("%p", source);
497  if (!source)
498  {
499  LEAVE("bad source");
500  return 0;
501  }
502 
503  LEAVE("index is %d", source->index);
504  return source->index;
505 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

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

536 {
537  ENTER("%p", source);
538  if (!source)
539  {
540  LEAVE("bad source");
541  return NULL;
542  }
543  LEAVE("internal name %s", source->internal_name);
544  return source->internal_name;
545 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_quote_source_get_supported()

gboolean gnc_quote_source_get_supported ( const gnc_quote_source *  source)

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

Parameters
sourceThe quote source in question.
Returns
TRUE if the user's computer supports this quote source.

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

509 {
510  ENTER("%p", source);
511  if (!source)
512  {
513  LEAVE("bad source");
514  return FALSE;
515  }
516 
517  LEAVE("%ssupported", source && source->supported ? "" : "not ");
518  return source->supported;
519 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_quote_source_get_type()

QuoteSourceType gnc_quote_source_get_type ( const gnc_quote_source *  source)

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

(SINGLE, MULTI, UNKNOWN)

Parameters
sourceThe quote source in question.
Returns
The type of this quote source.

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

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

◆ gnc_quote_source_get_user_name()

const char* gnc_quote_source_get_user_name ( const gnc_quote_source *  source)

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

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

Parameters
sourceThe quote source in question.
Returns
The user friendly name.

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

523 {
524  ENTER("%p", source);
525  if (!source)
526  {
527  LEAVE("bad source");
528  return NULL;
529  }
530  LEAVE("user name %s", source->user_name);
531  return source->user_name;
532 }
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282

◆ gnc_quote_source_lookup_by_internal()

gnc_quote_source* gnc_quote_source_lookup_by_internal ( const char *  internal_name)

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

Parameters
internal_nameThe name of this quote source.
Returns
A pointer to the price quote source that has the specified internal name.

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

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

◆ gnc_quote_source_lookup_by_ti()

gnc_quote_source* gnc_quote_source_lookup_by_ti ( QuoteSourceType  type,
gint  index 
)

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

Parameters
typeThe type of this quote source.
indexThe index of this quote source within its type.
Returns
A pointer to the price quote source that has the specified type/index.

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

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

◆ gnc_quote_source_num_entries()

gint gnc_quote_source_num_entries ( QuoteSourceType  type)

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

Parameters
typeThe quote source type whose count should be returned.
Returns
The number of entries for this type of quote source.

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

305 {
306  if (type == SOURCE_CURRENCY)
307  return 1;
308 
309  if (type == SOURCE_SINGLE)
310  return num_single_quote_sources;
311 
312  if (type == SOURCE_MULTI)
313  return num_multiple_quote_sources;
314 
315  return g_list_length(new_quote_sources);
316 }
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 555 of file gnc-commodity.c.

557 {
558  gnc_quote_source *source;
559  char *source_name;
560  const GList *node;
561 
562  ENTER(" ");
563 
564  if (!sources_list)
565  return;
566 
567  if (fq_version)
568  {
569  g_free (fq_version);
570  fq_version = NULL;
571  }
572 
573  if (version_string)
574  fq_version = g_strdup (version_string);
575 
576  for (node = sources_list; node; node = node->next)
577  {
578  source_name = node->data;
579 
580  source = gnc_quote_source_lookup_by_internal(source_name);
581  if (source != NULL)
582  {
583  DEBUG("Found source %s: %s", source_name, source->user_name);
584  source->supported = TRUE;
585  continue;
586  }
587 
588  gnc_quote_source_add_new(source_name, TRUE);
589  }
590  LEAVE(" ");
591 }
gnc_quote_source * gnc_quote_source_add_new(const char *source_name, gboolean supported)
Create a new quote source.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
gnc_quote_source * gnc_quote_source_lookup_by_internal(const char *name)
Given the internal (gnucash or F::Q) name of a quote source, find the data structure identified by th...
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282