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;

#ifdef __cplusplus
extern "C++" {
#include <glib.h>
#include <glib/gi18n.h>
}
#endif

#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_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")
/* Delay translation of this one, we use it in both translated and untranslated form
   when presenting the currency related namespace to the user */
#define GNC_COMMODITY_NS_ISO_GUI N_("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);

void gnc_quote_source_set_fq_installed (const char* version_string,
                                        const GList *sources_list);

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);
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_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 */