gnc-commodity.h

Go to the documentation of this file.

/********************************************************************
 * gnc-commodity.h -- API for tradable commodities (incl. currency) *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
 *******************************************************************/
 
#ifndef GNC_COMMODITY_H
#define GNC_COMMODITY_H
 
typedef struct _GncCommodityClass gnc_commodityClass;
typedef struct _GncCommodityNamespaceClass gnc_commodity_namespaceClass;
 
#include <glib.h>
#include <glib/gi18n.h>
 
#include "gnc-engine.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* --- type 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))
GType gnc_commodity_get_type(void);
 
/* --- type macros --- */
#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))
GType gnc_commodity_namespace_get_type(void);
 
 
#define GNC_COMMODITY_TABLE "gnc_commodity_table"
 
#define GNC_COMMODITY_NS_LEGACY        "GNC_LEGACY_CURRENCIES"
#define GNC_COMMODITY_NS_TEMPLATE      "template"
/* The ISO define is deprecated in favor of CURRENCY */
#define GNC_COMMODITY_NS_ISO           "ISO4217"
#define GNC_COMMODITY_NS_CURRENCY      "CURRENCY"
#define GNC_COMMODITY_NS_NONCURRENCY "NONCURRENCY"
 
#define GNC_COMMODITY_NS_NONISO_GUI   NC_("Commodity Type", "All non-currency")
#define GNC_COMMODITY_NS_ISO_GUI       NC_("Commodity Type", "Currencies")
 
#define GNC_COMMODITY_MAX_FRACTION 1000000000
 
typedef GList CommodityList;
 
typedef enum
{
    SOURCE_SINGLE = 0,  
    SOURCE_MULTI,       
    SOURCE_UNKNOWN, 
    SOURCE_MAX,
    SOURCE_CURRENCY = SOURCE_MAX, 
} QuoteSourceType;
 
gboolean gnc_quote_source_fq_installed (void);
 
const char* gnc_quote_source_fq_version (void);
 
gint gnc_quote_source_num_entries(QuoteSourceType type);
 
gnc_quote_source *gnc_quote_source_add_new(const char * name, gboolean supported);
 
/*@ dependent @*/
gnc_quote_source *gnc_quote_source_lookup_by_internal(const char * internal_name);
 
gnc_quote_source *gnc_quote_source_lookup_by_ti(QuoteSourceType type, gint index);
 
gboolean gnc_quote_source_get_supported (const gnc_quote_source *source);
 
QuoteSourceType gnc_quote_source_get_type (const gnc_quote_source *source);
 
gint gnc_quote_source_get_index (const gnc_quote_source *source);
 
/*@ dependent @*/
const char *gnc_quote_source_get_user_name (const gnc_quote_source *source);
 
/*@ dependent @*/
const char *gnc_quote_source_get_internal_name (const gnc_quote_source *source);
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_new(QofBook *book,
                                  /*@ null @*/ const char * fullname,
                                  /*@ null @*/ const char * commodity_namespace,
                                  /*@ null @*/ const char * mnemonic,
                                  /*@ null @*/ const char * cusip,
                                  int fraction);
 
void  gnc_commodity_destroy(gnc_commodity * cm);
 
void  gnc_commodity_copy(gnc_commodity * dest, const gnc_commodity *src);
 
gnc_commodity * gnc_commodity_clone(const gnc_commodity *src, QofBook *dest_book);
gboolean gnc_commodity_get_auto_quote_control_flag (const gnc_commodity *cm);
 
const char * gnc_commodity_get_mnemonic(const gnc_commodity * cm);
 
const char * gnc_commodity_get_namespace(const gnc_commodity * cm);
 
gnc_commodity_namespace *gnc_commodity_get_namespace_ds(const gnc_commodity * cm);
 
const char * gnc_commodity_get_fullname(const gnc_commodity * cm);
 
const char * gnc_commodity_get_printname(const gnc_commodity * cm);
 
const char * gnc_commodity_get_cusip(const gnc_commodity * cm);
 
const char * gnc_commodity_get_unique_name(const gnc_commodity * cm);
 
int     gnc_commodity_get_fraction(const gnc_commodity * cm);
 
gboolean    gnc_commodity_get_quote_flag(const gnc_commodity *cm);
 
/*@ dependent @*/
gnc_quote_source* gnc_commodity_get_quote_source(const gnc_commodity *cm);
/*@ dependent @*/
gnc_quote_source* gnc_commodity_get_default_quote_source(const gnc_commodity *cm);
 
const char* gnc_commodity_get_quote_tz(const gnc_commodity *cm);
 
const char* gnc_commodity_get_user_symbol(const gnc_commodity *cm);
 
const char* gnc_commodity_get_default_symbol(const gnc_commodity *cm);
 
const char*gnc_commodity_get_nice_symbol(const gnc_commodity *cm);
void gnc_commodity_set_auto_quote_control_flag (gnc_commodity *cm, const gboolean flag);
 
void  gnc_commodity_set_mnemonic(gnc_commodity * cm, const char * mnemonic);
 
void  gnc_commodity_set_namespace(gnc_commodity * cm, const char * new_namespace);
 
void  gnc_commodity_set_fullname(gnc_commodity * cm, const char * fullname);
 
void  gnc_commodity_set_cusip(gnc_commodity * cm, const char * cusip);
 
void  gnc_commodity_set_fraction(gnc_commodity * cm, int smallest_fraction);
 
void  gnc_commodity_user_set_quote_flag(gnc_commodity *cm,
                                        const gboolean flag);
 
void  gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag);
 
void  gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src);
 
void  gnc_commodity_set_quote_tz(gnc_commodity *cm, const char *tz);
 
void  gnc_commodity_set_user_symbol(gnc_commodity *cm, const char *user_symbol);
void
gnc_commodity_increment_usage_count(gnc_commodity *cm);
 
void
gnc_commodity_decrement_usage_count(gnc_commodity *cm);
gboolean gnc_commodity_equiv(const gnc_commodity * a, const gnc_commodity * b);
 
gboolean gnc_commodity_equal(const gnc_commodity * a, const gnc_commodity * b);
 
int gnc_commodity_compare(const gnc_commodity * a, const gnc_commodity * b);
 
int gnc_commodity_compare_void(const void * a, const void * b);
gboolean gnc_commodity_namespace_is_iso(const char *commodity_namespace);
 
gboolean gnc_commodity_is_iso(const gnc_commodity * cm);
 
gboolean gnc_commodity_is_currency(const gnc_commodity *cm);
 
/* =============================================================== */
/*@ dependent @*/
gnc_commodity_table * gnc_commodity_table_get_table(QofBook *book);
 
/* ---------------------------------------------------------- */
gnc_commodity * gnc_commodity_table_lookup(const gnc_commodity_table * table,
        const char * commodity_namespace,
        const char * mnemonic);
gnc_commodity *
gnc_commodity_table_lookup_unique(const gnc_commodity_table *table,
                                  const char * unique_name);
gnc_commodity * gnc_commodity_table_find_full(const gnc_commodity_table * t,
        const char * commodity_namespace,
        const char * fullname);
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_find_commodity_by_guid(const GncGUID *guid,
        QofBook *book);
 
/* ---------------------------------------------------------- */
 
/*@ dependent @*/
gnc_commodity * gnc_commodity_table_insert(gnc_commodity_table * table,
        gnc_commodity * comm);
 
void gnc_commodity_table_remove(gnc_commodity_table * table,
                                gnc_commodity * comm);
 
gboolean gnc_commodity_table_add_default_data(gnc_commodity_table *table, QofBook *book);
 
/* ---------------------------------------------------------- */
const char * gnc_commodity_namespace_get_name (const gnc_commodity_namespace *ns) ;
 
const char * gnc_commodity_namespace_get_gui_name (const gnc_commodity_namespace *ns) ;
 
 
GList * gnc_commodity_namespace_get_commodity_list(const gnc_commodity_namespace * ns);
 
 
int gnc_commodity_table_has_namespace(const gnc_commodity_table * table,
                                      const char * commodity_namespace);
 
GList * gnc_commodity_table_get_namespaces(const gnc_commodity_table * t);
 
GList * gnc_commodity_table_get_namespaces_list(const gnc_commodity_table * t);
 
gnc_commodity_namespace * gnc_commodity_table_add_namespace(gnc_commodity_table * table,
        const char * commodity_namespace,
        QofBook *book);
 
gnc_commodity_namespace * gnc_commodity_table_find_namespace(const gnc_commodity_table * table,
        const char * commodity_namespace);
 
void      gnc_commodity_table_delete_namespace(gnc_commodity_table * table,
        const char * commodity_namespace);
/* ---------------------------------------------------------- */
guint gnc_commodity_table_get_size(const gnc_commodity_table* tbl);
 
CommodityList * gnc_commodity_table_get_commodities(
    const gnc_commodity_table * table, const char * commodity_namespace);
 
CommodityList * gnc_commodity_table_get_quotable_commodities(
    const gnc_commodity_table * table);
 
gboolean gnc_commodity_table_foreach_commodity(const gnc_commodity_table * table,
        gboolean (*f)(gnc_commodity *cm,
                      gpointer user_data),
        gpointer user_data);
/* ---------------------------------------------------------- */
gnc_commodity_table * gnc_commodity_table_new(void);
void          gnc_commodity_table_destroy(gnc_commodity_table * table);
 
gnc_commodity * gnc_commodity_obtain_twin (const gnc_commodity *findlike, QofBook *book);
 
gboolean gnc_commodity_table_register (void);
 
void gnc_commodity_begin_edit (gnc_commodity *cm);
void gnc_commodity_commit_edit (gnc_commodity *cm);
 
#define gnc_commodity_get_kvp_frame(cm) \
    qof_instance_get_slots(QOF_INSTANCE(cm))
 
struct _gnc_monetary
{
    gnc_commodity *commodity;
    gnc_numeric value;
};
 
typedef struct _gnc_monetary gnc_monetary;
 
/* A list of monetary values.  This could be a hash table, but as currently
* used it rarely contains more than one or two different commodities so
* it doesn't seem worth the trouble.
*/
typedef GList MonetaryList;
 
static inline
gnc_monetary gnc_monetary_create(gnc_commodity *commod, gnc_numeric val)
{
    gnc_monetary out;
    out.commodity = commod;
    out.value = val;
    return out;
}
static inline
gnc_commodity * gnc_monetary_commodity(gnc_monetary a)
{
    return a.commodity;
}
 
static inline
gnc_numeric gnc_monetary_value(gnc_monetary a)
{
    return a.value;
}
MonetaryList *gnc_monetary_list_add_monetary(MonetaryList *list, gnc_monetary mon);
 
static inline
MonetaryList *gnc_monetary_list_add_value(MonetaryList *list,
        gnc_commodity *commod,
        gnc_numeric value)
{
    return gnc_monetary_list_add_monetary(list,
                                          gnc_monetary_create(commod, value));
}
 
MonetaryList *gnc_monetary_list_delete_zeros(MonetaryList *list);
 
void gnc_monetary_list_free(MonetaryList *list);
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* GNC_COMMODITY_H */