Branch data Line data Source code
1 : : /********************************************************************
2 : : * gnc-commodity.c -- api for tradable commodities (incl. currency) *
3 : : * Copyright (C) 2000 Bill Gribble *
4 : : * Copyright (C) 2001,2003 Linas Vepstas <linas@linas.org> *
5 : : * Copyright (c) 2006 David Hampton <hampton@employees.org> *
6 : : * *
7 : : * This program is free software; you can redistribute it and/or *
8 : : * modify it under the terms of the GNU General Public License as *
9 : : * published by the Free Software Foundation; either version 2 of *
10 : : * the License, or (at your option) any later version. *
11 : : * *
12 : : * This program is distributed in the hope that it will be useful, *
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 : : * GNU General Public License for more details. *
16 : : * *
17 : : * You should have received a copy of the GNU General Public License*
18 : : * along with this program; if not, contact: *
19 : : * *
20 : : * Free Software Foundation Voice: +1-617-542-5942 *
21 : : * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
22 : : * Boston, MA 02110-1301, USA gnu@gnu.org *
23 : : * *
24 : : *******************************************************************/
25 : :
26 : : #include <config.h>
27 : :
28 : : #include <glib.h>
29 : : #include <glib/gi18n.h>
30 : : #include <ctype.h>
31 : : #include <limits.h>
32 : : #include <string.h>
33 : : #include <stdio.h>
34 : : #include <stdlib.h>
35 : : #include <regex.h>
36 : : #include <qofinstance-p.h>
37 : :
38 : : #include "gnc-commodity.hpp"
39 : : #include "gnc-commodity.h"
40 : : #include "gnc-locale-utils.h"
41 : : #include "gnc-prefs.h"
42 : : #include "guid.h"
43 : : #include "qofinstance.h"
44 : :
45 : : #include <list>
46 : : #include <unordered_map>
47 : :
48 : : static QofLogModule log_module = GNC_MOD_COMMODITY;
49 : :
50 : : /* Parts per unit is nominal, i.e. number of 'partname' units in
51 : : * a 'unitname' unit. fraction is transactional, i.e. how many
52 : : * of the smallest-transactional-units of the currency are there
53 : : * in a 'unitname' unit. */
54 : :
55 : : enum
56 : : {
57 : : PROP_0,
58 : : PROP_NAMESPACE, /* Table */
59 : : PROP_FULL_NAME, /* Table */
60 : : PROP_MNEMONIC, /* Table */
61 : : PROP_PRINTNAME, /* Constructed */
62 : : PROP_CUSIP, /* Table */
63 : : PROP_FRACTION, /* Table */
64 : : PROP_UNIQUE_NAME, /* Constructed */
65 : : PROP_QUOTE_FLAG, /* Table */
66 : : PROP_QUOTE_SOURCE, /* Table */
67 : : PROP_QUOTE_TZ, /* Table */
68 : : };
69 : :
70 : : struct gnc_commodity_s
71 : : {
72 : : QofInstance inst;
73 : : };
74 : :
75 : : typedef struct gnc_commodityPrivate
76 : : {
77 : : gnc_commodity_namespace *name_space;
78 : :
79 : : const char *fullname;
80 : : const char *mnemonic;
81 : : char *printname;
82 : : const char *cusip; /* CUSIP or other identifying code */
83 : : int fraction;
84 : : char *unique_name;
85 : : char *user_symbol;
86 : :
87 : : gboolean quote_flag; /* user wants price quotes */
88 : : gnc_quote_source *quote_source; /* current/old source of quotes */
89 : : const char *quote_tz;
90 : :
91 : : /* the number of accounts using this commodity - this field is not
92 : : * persisted */
93 : : int usage_count;
94 : :
95 : : /* the default display_symbol, set in iso-4217-currencies at start-up */
96 : : const char *default_symbol;
97 : : } gnc_commodityPrivate;
98 : :
99 : : #define GET_PRIVATE(o) \
100 : : ((gnc_commodityPrivate*)gnc_commodity_get_instance_private((gnc_commodity*)o))
101 : :
102 : : struct _GncCommodityClass
103 : : {
104 : : QofInstanceClass parent_class;
105 : : };
106 : :
107 : : static void commodity_free(gnc_commodity * cm);
108 : : static void gnc_commodity_set_default_symbol(gnc_commodity *, const char *);
109 : :
110 : : struct gnc_commodity_namespace_s
111 : : {
112 : : QofInstance inst;
113 : :
114 : : const gchar *name;
115 : : gboolean iso4217;
116 : : GHashTable * cm_table;
117 : : GList * cm_list;
118 : : };
119 : :
120 : : struct _GncCommodityNamespaceClass
121 : : {
122 : : QofInstanceClass parent_class;
123 : : };
124 : :
125 : : struct gnc_commodity_table_s
126 : : {
127 : : GHashTable * ns_table;
128 : : GList * ns_list;
129 : : };
130 : :
131 : : static const std::unordered_map<std::string,std::string> gnc_new_iso_codes =
132 : : {
133 : : {"RUR", "RUB"}, /* Russian Ruble: RUR through 1997-12, RUB from 1998-01 onwards; see bug #393185 */
134 : : {"PLZ", "PLN"}, /* Polish Zloty */
135 : : {"UAG", "UAH"}, /* Ukraine Hryvnia */
136 : : {"NIS", "ILS"}, /* New Israeli Shekel: The informal abbreviation may be "NIS", but
137 : : its iso-4217 is clearly ILS and only this! Incorrectly changed
138 : : due to bug#152755 (Nov 2004) and changed back again by bug#492417
139 : : (Oct 2008). */
140 : : {"MXP", "MXN"}, /* Mexican (Nuevo) Peso */
141 : : {"TRL", "TRY"}, /* New Turkish Lira: changed 2005 */
142 : :
143 : : /* Only add currencies to this table when the old currency no longer
144 : : * exists in the file iso-4217-currencies.xml */
145 : : };
146 : :
147 : : static std::string fq_version;
148 : :
149 : : struct gnc_quote_source_s
150 : : {
151 : : private:
152 : : gboolean m_supported;
153 : : QuoteSourceType m_type;
154 : : std::string m_user_name; /* User friendly name incl. region code*/
155 : : std::string m_internal_name; /* Name used internally and by finance::quote. */
156 : : public:
157 : 23 : bool get_supported () const { return m_supported; }
158 : 15 : void set_supported (bool supported) { m_supported = supported; }
159 : 0 : QuoteSourceType get_type () const { return m_type; }
160 : 2 : const char* get_user_name () const { return m_user_name.c_str(); }
161 : 126760 : const char* get_internal_name () const { return m_internal_name.c_str(); }
162 : 5937 : gnc_quote_source_s (gboolean supported, QuoteSourceType type,
163 : : const char* username, const char* int_name)
164 : 5937 : : m_supported{supported}
165 : 5937 : , m_type{type}
166 : 11874 : , m_user_name{username ? username : ""}
167 : 17811 : , m_internal_name{int_name ? int_name: ""} { };
168 : : };
169 : :
170 : : using QuoteSourceList = std::list<gnc_quote_source>;
171 : :
172 : : /* To update the following lists scan
173 : : * from github.com/finance-quote/finance-quote
174 : : * in lib/Finance/Quote/ all *.pm for "methods"
175 : : * because many of them have more than one -
176 : : * ideally after each release of them.
177 : : *
178 : : * Apply changes here also to the FQ appendix of help.
179 : : */
180 : : static QuoteSourceList currency_quote_sources =
181 : : {
182 : : { true, SOURCE_CURRENCY, "Currency", "currency" }
183 : : };
184 : :
185 : : /* The single quote method is usually the module name, but
186 : : * sometimes it gets the suffix "_direct"
187 : : * and the failover method is without suffix.
188 : : */
189 : : static QuoteSourceList single_quote_sources =
190 : : {
191 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Alphavantage"), "alphavantage" },
192 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Amsterdam Euronext eXchange, NL"), "aex" },
193 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Association of Mutual Funds in India"), "amfiindia" },
194 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Athens Exchange Group, GR"), "asegr" },
195 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Australian Stock Exchange, AU"), "asx" },
196 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Italian Stock Exchange, IT"), "borsa_italiana" },
197 : : { false, SOURCE_SINGLE, NC_("FQ Source", "BSE India, IN"), "bseindia" },
198 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Bucharest Stock Exchange, RO"), "bvb" },
199 : : { false, SOURCE_SINGLE, NC_("FQ Source", "China Merchants Bank, CN"), "cmbchina" },
200 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Colombo Stock Exchange, LK"), "cse" },
201 : : { false, SOURCE_SINGLE, NC_("FQ Source", "comdirect, DE"), "comdirect" },
202 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Consors Bank, DE"), "consorsbank" },
203 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Deka Investments, DE"), "deka" },
204 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Financial Times Funds service, GB"), "ftfunds" },
205 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Finanzpartner, DE"), "finanzpartner" },
206 : : { false, SOURCE_SINGLE, NC_("FQ Source", "FondsWeb, DE"), "fondsweb" },
207 : : { false, SOURCE_SINGLE, NC_("FQ Source", "GoldMoney precious metals"), "goldmoney" },
208 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Google Web, US Stocks"), "googleweb" },
209 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Market Watch"), "marketwatch" },
210 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Morningstar, CH"), "morningstarch" },
211 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Morningstar, GB"), "morningstaruk" },
212 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Morningstar, JP"), "morningstarjp" },
213 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Motley Fool"), "fool" },
214 : : { false, SOURCE_SINGLE, NC_("FQ Source", "New Zealand stock eXchange, NZ"), "nzx" },
215 : : { false, SOURCE_SINGLE, NC_("FQ Source", "NSE (National Stock Exchange), IN"), "nseindia" },
216 : : { false, SOURCE_SINGLE, NC_("FQ Source", "OnVista, DE"), "onvista"},
217 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Paris Stock Exchange/Boursorama, FR"), "bourso" },
218 : : { false, SOURCE_SINGLE, NC_("FQ Source", "S-Investor, DE"), "sinvestor"},
219 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Sharenet, ZA"), "za" },
220 : : { false, SOURCE_SINGLE, NC_("FQ Source", "SIX Swiss Exchange shares, CH"), "six" },
221 : : { false, SOURCE_SINGLE, NC_("FQ Source", "StockData"), "stockdata" },
222 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Stooq, PL"), "stooq" },
223 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Tesouro Direto bonds, BR"), "tesouro_direto" },
224 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Toronto Stock eXchange, CA"), "tsx" },
225 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Tradegate, DE"), "tradegate" },
226 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Treasury Direct bonds, US"), "treasurydirect" },
227 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Twelve Data"), "twelvedata" },
228 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Union Investment, DE"), "unionfunds" },
229 : : { false, SOURCE_SINGLE, NC_("FQ Source", "US Govt. Thrift Savings Plan"), "tsp" },
230 : : { false, SOURCE_SINGLE, NC_("FQ Source", "XETRA, DE"), "xetra" },
231 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Yahoo as JSON"), "yahoo_json" },
232 : : { false, SOURCE_SINGLE, NC_("FQ Source", "Yahoo Web"), "yahooweb" },
233 : : { false, SOURCE_SINGLE, NC_("FQ Source", "YH Finance (FinanceAPI)"), "financeapi" },
234 : : };
235 : :
236 : : // Finance::Quote defines these as failover methods
237 : : static QuoteSourceList multiple_quote_sources =
238 : : {
239 : : { false, SOURCE_MULTI, NC_("FQ Source", "Canada (Alphavantage, TMX)"), "canada" },
240 : : { false, SOURCE_MULTI, NC_("FQ Source", "Europe (ASEGR, Bourso, …)"), "europe" },
241 : : { false, SOURCE_MULTI, NC_("FQ Source", "India (BSEIndia, NSEIndia)"), "india"},
242 : : { false, SOURCE_MULTI, NC_("FQ Source", "Nasdaq (Alphavantage, FinanceAPI, …)"), "nasdaq" },
243 : : { false, SOURCE_MULTI, NC_("FQ Source", "NYSE (Alphavantage, FinanceAPI, …)"), "nyse" },
244 : : { false, SOURCE_MULTI, NC_("FQ Source", "U.K. Funds (FTfunds, MorningstarUK)"), "ukfunds" },
245 : : { false, SOURCE_MULTI, NC_("FQ Source", "USA (Alphavantage, FinanceAPI, …)"), "usa" },
246 : : };
247 : :
248 : : static QuoteSourceList new_quote_sources;
249 : :
250 : : // cannot use map or unordered_map because order must be preserved
251 : : static const std::vector<std::pair<QuoteSourceType,QuoteSourceList&>> quote_sources_map =
252 : : {
253 : : { SOURCE_CURRENCY, currency_quote_sources },
254 : : { SOURCE_SINGLE, single_quote_sources },
255 : : { SOURCE_MULTI, multiple_quote_sources },
256 : : { SOURCE_UNKNOWN, new_quote_sources }
257 : : };
258 : :
259 : : /********************************************************************
260 : : * gnc_quote_source_fq_installed
261 : : *
262 : : * This function indicates whether or not the Finance::Quote module
263 : : * is installed on a users computer.
264 : : ********************************************************************/
265 : : gboolean
266 : 0 : gnc_quote_source_fq_installed (void)
267 : : {
268 : 0 : return (!fq_version.empty());
269 : : }
270 : :
271 : :
272 : : /********************************************************************
273 : : * gnc_quote_source_fq_version
274 : : *
275 : : * This function the version of the Finance::Quote module installed
276 : : * on a user's computer or nullptr if no installation is found.
277 : : ********************************************************************/
278 : : const char*
279 : 0 : gnc_quote_source_fq_version (void)
280 : : {
281 : 0 : return fq_version.c_str();
282 : : }
283 : :
284 : : static QuoteSourceList&
285 : 11 : get_quote_source_from_type (QuoteSourceType type)
286 : : {
287 : 11 : auto quote_sources_it = std::find_if (quote_sources_map.begin(), quote_sources_map.end(),
288 : 38 : [type] (const auto& qs) { return type == qs.first; });
289 : :
290 : 11 : if (quote_sources_it != quote_sources_map.end())
291 : 7 : return quote_sources_it->second;
292 : :
293 : 4 : PWARN ("Invalid Quote Source %d, returning new_quote_sources", type);
294 : 4 : return new_quote_sources;
295 : : }
296 : :
297 : : /********************************************************************
298 : : * gnc_quote_source_num_entries
299 : : *
300 : : * Return the number of entries for a given type of price source.
301 : : ********************************************************************/
302 : 5 : gint gnc_quote_source_num_entries(QuoteSourceType type)
303 : : {
304 : 5 : auto source{get_quote_source_from_type(type)};
305 : 15 : return std::distance(source.begin(), source.end());
306 : 5 : }
307 : :
308 : :
309 : :
310 : : /********************************************************************
311 : : * gnc_quote_source_add_new
312 : : *
313 : : * Add a new price source. Called when unknown source names are found
314 : : * either in the F::Q installation (a newly available source) or in
315 : : * the user's data file (a source that has vanished but needs to be
316 : : * tracked.)
317 : : ********************************************************************/
318 : : gnc_quote_source *
319 : 21 : gnc_quote_source_add_new (const char *source_name, gboolean supported)
320 : : {
321 : 21 : DEBUG("Creating new source %s", (!source_name ? "(null)" : source_name));
322 : : /* This name can be changed if/when support for this price source is
323 : : * integrated into gnucash. */
324 : : /* This name is permanent and must be kept the same if/when support
325 : : * for this price source is integrated into gnucash (i.e. for a
326 : : * nice user name). */
327 : 21 : return &new_quote_sources.emplace_back (supported, SOURCE_UNKNOWN, source_name, source_name);
328 : : }
329 : :
330 : : /********************************************************************
331 : : * gnc_quote_source_lookup_by_xxx
332 : : *
333 : : * Lookup a price source data structure based upon various criteria.
334 : : ********************************************************************/
335 : : gnc_quote_source *
336 : 6 : gnc_quote_source_lookup_by_ti (QuoteSourceType type, gint index)
337 : : {
338 : 6 : ENTER("type/index is %d/%d", type, index);
339 : 6 : auto& sources = get_quote_source_from_type (type);
340 : 6 : if ((size_t) index < sources.size())
341 : : {
342 : 4 : auto it = std::next(sources.begin(), index);
343 : 4 : LEAVE("found %s", it->get_user_name());
344 : 4 : return &*it;
345 : : }
346 : :
347 : 2 : LEAVE("not found");
348 : 2 : return nullptr;
349 : : }
350 : :
351 : : gnc_quote_source *
352 : 126103 : gnc_quote_source_lookup_by_internal(const char * name)
353 : : {
354 : 126103 : if (!name || !*name)
355 : 1 : return nullptr;
356 : :
357 : 126140 : for (const auto& [_, sources] : quote_sources_map)
358 : : {
359 : 126139 : auto source_it = std::find_if (sources.begin(), sources.end(),
360 : 126227 : [name] (const auto& qs)
361 : 126227 : { return (g_strcmp0(name, qs.get_internal_name()) == 0); });
362 : 126139 : if (source_it != sources.end())
363 : 126101 : return &(*source_it);
364 : : }
365 : :
366 : 1 : DEBUG("gnc_quote_source_lookup_by_internal: Unknown source %s", name);
367 : 1 : return nullptr;
368 : : }
369 : :
370 : : /********************************************************************
371 : : * gnc_quote_source_get_xxx
372 : : *
373 : : * Accessor functions - get functions only. There are no set functions.
374 : : ********************************************************************/
375 : : QuoteSourceType
376 : 0 : gnc_quote_source_get_type (const gnc_quote_source *source)
377 : : {
378 : 0 : ENTER("%p", source);
379 : 0 : if (!source)
380 : : {
381 : 0 : LEAVE("bad source");
382 : 0 : return SOURCE_SINGLE;
383 : : }
384 : :
385 : 0 : LEAVE("type is %d", source->get_type());
386 : 0 : return source->get_type();
387 : : }
388 : :
389 : : gint
390 : 0 : gnc_quote_source_get_index (const gnc_quote_source *source)
391 : : {
392 : 0 : if (!source)
393 : : {
394 : 0 : PWARN ("bad source");
395 : 0 : return 0;
396 : : }
397 : :
398 : 0 : auto& sources = get_quote_source_from_type (source->get_type());
399 : 0 : auto is_source = [&source](const auto& findif_source)
400 : 0 : { return &findif_source == source; };
401 : :
402 : 0 : auto iter = std::find_if (sources.begin(), sources.end(), is_source);
403 : 0 : if (iter != sources.end())
404 : 0 : return std::distance (sources.begin(), iter);
405 : :
406 : 0 : PWARN ("couldn't locate source");
407 : 0 : return 0;
408 : : }
409 : :
410 : : gboolean
411 : 23 : gnc_quote_source_get_supported (const gnc_quote_source *source)
412 : : {
413 : 23 : ENTER("%p", source);
414 : 23 : if (!source)
415 : : {
416 : 0 : LEAVE("bad source");
417 : 0 : return FALSE;
418 : : }
419 : :
420 : 23 : LEAVE("%s supported", source && source->get_supported() ? "" : "not ");
421 : 23 : return source->get_supported();
422 : : }
423 : :
424 : : const char *
425 : 2 : gnc_quote_source_get_user_name (const gnc_quote_source *source)
426 : : {
427 : 2 : ENTER("%p", source);
428 : 2 : if (!source)
429 : : {
430 : 0 : LEAVE("bad source");
431 : 0 : return nullptr;
432 : : }
433 : 2 : LEAVE("user name %s", source->get_user_name());
434 : 2 : return source->get_user_name();
435 : : }
436 : :
437 : : const char *
438 : 83 : gnc_quote_source_get_internal_name (const gnc_quote_source *source)
439 : : {
440 : 83 : ENTER("%p", source);
441 : 83 : if (!source)
442 : : {
443 : 6 : LEAVE("bad source");
444 : 6 : return nullptr;
445 : : }
446 : 77 : LEAVE("internal name %s", source->get_internal_name());
447 : 77 : return source->get_internal_name();
448 : : }
449 : :
450 : :
451 : : /********************************************************************
452 : : * gnc_quote_source_set_fq_installed
453 : : *
454 : : * Update gnucash internal tables on what Finance::Quote sources are
455 : : * installed.
456 : : ********************************************************************/
457 : : void
458 : 15 : gnc_quote_source_set_fq_installed (const char* version_string,
459 : : const std::vector<std::string>& sources_list)
460 : : {
461 : 15 : ENTER(" ");
462 : :
463 : 15 : if (sources_list.empty())
464 : 0 : return;
465 : :
466 : 15 : if (version_string)
467 : 15 : fq_version = version_string;
468 : : else
469 : 0 : fq_version.clear();
470 : :
471 : 30 : for (const auto& source_name_str : sources_list)
472 : : {
473 : 15 : auto source_name = source_name_str.c_str();
474 : 15 : auto source = gnc_quote_source_lookup_by_internal(source_name);
475 : :
476 : 15 : if (source)
477 : : {
478 : 15 : DEBUG("Found source %s: %s", source_name, source->get_user_name());
479 : 15 : source->set_supported (true);
480 : 15 : continue;
481 : : }
482 : :
483 : 0 : gnc_quote_source_add_new(source_name, TRUE);
484 : : }
485 : 15 : LEAVE(" ");
486 : : }
487 : :
488 : : /********************************************************************
489 : : * QoF Helpers
490 : : ********************************************************************/
491 : :
492 : : void
493 : 506807 : gnc_commodity_begin_edit (gnc_commodity *cm)
494 : : {
495 : 506807 : qof_begin_edit(&cm->inst);
496 : 506807 : }
497 : :
498 : 0 : static void commit_err (QofInstance *inst, QofBackendError errcode)
499 : : {
500 : 0 : PERR ("Failed to commit: %d", errcode);
501 : 0 : gnc_engine_signal_commit_error( errcode );
502 : 0 : }
503 : :
504 : 67888 : static void noop (QofInstance *inst) {}
505 : :
506 : : static void
507 : 41825 : comm_free(QofInstance* inst)
508 : : {
509 : 41825 : commodity_free( GNC_COMMODITY(inst) );
510 : 41825 : }
511 : :
512 : : void
513 : 506807 : gnc_commodity_commit_edit (gnc_commodity *cm)
514 : : {
515 : 506807 : if (!qof_commit_edit (QOF_INSTANCE(cm))) return;
516 : 109713 : qof_commit_edit_part2 (&cm->inst, commit_err, noop, comm_free);
517 : : }
518 : :
519 : : /********************************************************************
520 : : * gnc_commodity_new
521 : : ********************************************************************/
522 : :
523 : : static void
524 : 464768 : mark_commodity_dirty (gnc_commodity *cm)
525 : : {
526 : 464768 : qof_instance_set_dirty(&cm->inst);
527 : 464768 : qof_event_gen (&cm->inst, QOF_EVENT_MODIFY, nullptr);
528 : 464768 : }
529 : :
530 : : static void
531 : 267101 : reset_printname(gnc_commodityPrivate *priv)
532 : : {
533 : 267101 : g_free(priv->printname);
534 : 534202 : priv->printname = g_strdup_printf("%s (%s)",
535 : 267101 : priv->mnemonic ? priv->mnemonic : "",
536 : 267101 : priv->fullname ? priv->fullname : "");
537 : 267101 : }
538 : :
539 : : static void
540 : 200177 : reset_unique_name(gnc_commodityPrivate *priv)
541 : : {
542 : : gnc_commodity_namespace *ns;
543 : :
544 : 200177 : g_free(priv->unique_name);
545 : 200177 : ns = priv->name_space;
546 : 200177 : priv->unique_name = g_strdup_printf("%s::%s",
547 : : ns ? ns->name : "",
548 : 200177 : priv->mnemonic ? priv->mnemonic : "");
549 : 200177 : }
550 : :
551 : : /* GObject Initialization */
552 : 1700450 : G_DEFINE_TYPE_WITH_PRIVATE(gnc_commodity, gnc_commodity, QOF_TYPE_INSTANCE)
553 : :
554 : : static void
555 : 66793 : gnc_commodity_init(gnc_commodity* com)
556 : : {
557 : : gnc_commodityPrivate* priv;
558 : :
559 : 66793 : priv = GET_PRIVATE(com);
560 : :
561 : 66793 : priv->name_space = nullptr;
562 : 66793 : priv->fullname = CACHE_INSERT("");
563 : 66793 : priv->mnemonic = CACHE_INSERT("");
564 : 66793 : priv->cusip = CACHE_INSERT("");
565 : 66793 : priv->fraction = 10000;
566 : 66793 : priv->quote_flag = 0;
567 : 66793 : priv->quote_source = nullptr;
568 : 66793 : priv->quote_tz = CACHE_INSERT("");
569 : :
570 : 66793 : reset_printname(priv);
571 : 66793 : reset_unique_name(priv);
572 : 66793 : }
573 : :
574 : : static void
575 : 41983 : gnc_commodity_dispose(GObject *comp)
576 : : {
577 : 41983 : G_OBJECT_CLASS(gnc_commodity_parent_class)->dispose(comp);
578 : 41983 : }
579 : :
580 : : static void
581 : 41983 : gnc_commodity_finalize(GObject* comp)
582 : : {
583 : 41983 : G_OBJECT_CLASS(gnc_commodity_parent_class)->finalize(comp);
584 : 41983 : }
585 : : /* Note that g_value_set_object() refs the object, as does
586 : : * g_object_get(). But g_object_get() only unrefs once when it disgorges
587 : : * the object, leaving an unbalanced ref, which leaks. So instead of
588 : : * using g_value_set_object(), use g_value_take_object() which doesn't
589 : : * ref the object when used in get_property().
590 : : */
591 : : static void
592 : 318 : gnc_commodity_get_property (GObject *object,
593 : : guint prop_id,
594 : : GValue *value,
595 : : GParamSpec *pspec)
596 : : {
597 : : gnc_commodity *commodity;
598 : : gnc_commodityPrivate* priv;
599 : :
600 : 318 : g_return_if_fail(GNC_IS_COMMODITY(object));
601 : :
602 : 318 : commodity = GNC_COMMODITY(object);
603 : 318 : priv = GET_PRIVATE(commodity);
604 : 318 : switch (prop_id)
605 : : {
606 : 0 : case PROP_NAMESPACE:
607 : 0 : g_value_take_object(value, priv->name_space);
608 : 0 : break;
609 : 53 : case PROP_FULL_NAME:
610 : 53 : g_value_set_string(value, priv->fullname);
611 : 53 : break;
612 : 53 : case PROP_MNEMONIC:
613 : 53 : g_value_set_string(value, priv->mnemonic);
614 : 53 : break;
615 : 0 : case PROP_PRINTNAME:
616 : 0 : g_value_set_string(value, priv->printname);
617 : 0 : break;
618 : 53 : case PROP_CUSIP:
619 : 53 : g_value_set_string(value, priv->cusip);
620 : 53 : break;
621 : 53 : case PROP_FRACTION:
622 : 53 : g_value_set_int(value, priv->fraction);
623 : 53 : break;
624 : 0 : case PROP_UNIQUE_NAME:
625 : 0 : g_value_set_string(value, priv->unique_name);
626 : 0 : break;
627 : 53 : case PROP_QUOTE_FLAG:
628 : 53 : g_value_set_boolean(value, priv->quote_flag);
629 : 53 : break;
630 : 0 : case PROP_QUOTE_SOURCE:
631 : 0 : g_value_set_pointer(value, priv->quote_source);
632 : 0 : break;
633 : 53 : case PROP_QUOTE_TZ:
634 : 53 : g_value_set_string(value, priv->quote_tz);
635 : 53 : break;
636 : 0 : default:
637 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
638 : 0 : break;
639 : : }
640 : : }
641 : :
642 : : static void
643 : 48 : gnc_commodity_set_property (GObject *object,
644 : : guint prop_id,
645 : : const GValue *value,
646 : : GParamSpec *pspec)
647 : : {
648 : : gnc_commodity *commodity;
649 : :
650 : 48 : g_return_if_fail(GNC_IS_COMMODITY(object));
651 : :
652 : 48 : commodity = GNC_COMMODITY(object);
653 : 48 : g_assert (qof_instance_get_editlevel(commodity));
654 : :
655 : 48 : switch (prop_id)
656 : : {
657 : 0 : case PROP_NAMESPACE:
658 : 0 : gnc_commodity_set_namespace(commodity, static_cast<const char*>(g_value_get_object(value)));
659 : 0 : break;
660 : 8 : case PROP_FULL_NAME:
661 : 8 : gnc_commodity_set_fullname(commodity, g_value_get_string(value));
662 : 8 : break;
663 : 8 : case PROP_MNEMONIC:
664 : 8 : gnc_commodity_set_mnemonic(commodity, g_value_get_string(value));
665 : 8 : break;
666 : 8 : case PROP_CUSIP:
667 : 8 : gnc_commodity_set_cusip(commodity, g_value_get_string(value));
668 : 8 : break;
669 : 8 : case PROP_FRACTION:
670 : 8 : gnc_commodity_set_fraction(commodity, g_value_get_int(value));
671 : 8 : break;
672 : 8 : case PROP_QUOTE_FLAG:
673 : 8 : gnc_commodity_set_quote_flag(commodity, g_value_get_boolean(value));
674 : 8 : break;
675 : 0 : case PROP_QUOTE_SOURCE:
676 : 0 : gnc_commodity_set_quote_source(commodity, static_cast<gnc_quote_source*>(g_value_get_pointer(value)));
677 : 0 : break;
678 : 8 : case PROP_QUOTE_TZ:
679 : 8 : gnc_commodity_set_quote_tz(commodity, g_value_get_string(value));
680 : 8 : break;
681 : 0 : default:
682 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
683 : 0 : break;
684 : : }
685 : : }
686 : : static void
687 : 63 : gnc_commodity_class_init(struct _GncCommodityClass* klass)
688 : : {
689 : 63 : GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
690 : :
691 : 63 : gobject_class->dispose = gnc_commodity_dispose;
692 : 63 : gobject_class->finalize = gnc_commodity_finalize;
693 : 63 : gobject_class->set_property = gnc_commodity_set_property;
694 : 63 : gobject_class->get_property = gnc_commodity_get_property;
695 : :
696 : 63 : g_object_class_install_property(gobject_class,
697 : : PROP_NAMESPACE,
698 : : g_param_spec_object ("namespace",
699 : : "Namespace",
700 : : "The namespace field denotes the "
701 : : "namespace for this commodity, either "
702 : : "a currency or symbol from a quote source.",
703 : : GNC_TYPE_COMMODITY_NAMESPACE,
704 : : G_PARAM_READWRITE));
705 : 63 : g_object_class_install_property(gobject_class,
706 : : PROP_FULL_NAME,
707 : : g_param_spec_string ("fullname",
708 : : "Full Commodity Name",
709 : : "The fullname is the official full name of"
710 : : "the currency.",
711 : : nullptr,
712 : : G_PARAM_READWRITE));
713 : 63 : g_object_class_install_property(gobject_class,
714 : : PROP_MNEMONIC,
715 : : g_param_spec_string ("mnemonic",
716 : : "Commodity Mnemonic",
717 : : "The mnemonic is the official abbreviated"
718 : : "designation for the currency.",
719 : : nullptr,
720 : : G_PARAM_READWRITE));
721 : 63 : g_object_class_install_property(gobject_class,
722 : : PROP_PRINTNAME,
723 : : g_param_spec_string ("printname",
724 : : "Commodity Print Name",
725 : : "Printable form of the commodity name.",
726 : : nullptr,
727 : : G_PARAM_READABLE));
728 : 63 : g_object_class_install_property(gobject_class,
729 : : PROP_CUSIP,
730 : : g_param_spec_string ("cusip",
731 : : "Commodity CUSIP Code",
732 : : "?????",
733 : : nullptr,
734 : : G_PARAM_READWRITE));
735 : 63 : g_object_class_install_property(gobject_class,
736 : : PROP_FRACTION,
737 : : g_param_spec_int ("fraction",
738 : : "Fraction",
739 : : "The fraction is the number of sub-units that "
740 : : "the basic commodity can be divided into.",
741 : : 1,
742 : : GNC_COMMODITY_MAX_FRACTION,
743 : : 1,
744 : : G_PARAM_READWRITE));
745 : 63 : g_object_class_install_property(gobject_class,
746 : : PROP_UNIQUE_NAME,
747 : : g_param_spec_string ("unique-name",
748 : : "Commodity Unique Name",
749 : : "Unique form of the commodity name which combines "
750 : : "the namespace name and the commodity name.",
751 : : nullptr,
752 : : G_PARAM_READABLE));
753 : 63 : g_object_class_install_property(gobject_class,
754 : : PROP_QUOTE_FLAG,
755 : : g_param_spec_boolean ("quote_flag",
756 : : "Quote Flag",
757 : : "TRUE if prices are to be downloaded for this "
758 : : "commodity from a quote source.",
759 : : FALSE,
760 : : G_PARAM_READWRITE));
761 : 63 : g_object_class_install_property(gobject_class,
762 : : PROP_QUOTE_SOURCE,
763 : : g_param_spec_pointer("quote-source",
764 : : "Quote Source",
765 : : "The quote source from which prices are downloaded.",
766 : : G_PARAM_READWRITE));
767 : 63 : g_object_class_install_property(gobject_class,
768 : : PROP_QUOTE_TZ,
769 : : g_param_spec_string ("quote-tz",
770 : : "Commodity Quote Timezone",
771 : : "?????",
772 : : nullptr,
773 : : G_PARAM_READWRITE));
774 : 63 : }
775 : :
776 : : gnc_commodity *
777 : 66793 : gnc_commodity_new(QofBook *book, const char * fullname,
778 : : const char * name_space, const char * mnemonic,
779 : : const char * cusip, int fraction)
780 : : {
781 : 66793 : auto retval = GNC_COMMODITY(g_object_new(GNC_TYPE_COMMODITY, nullptr));
782 : :
783 : 66793 : qof_instance_init_data (&retval->inst, GNC_ID_COMMODITY, book);
784 : 66793 : gnc_commodity_begin_edit(retval);
785 : :
786 : 66793 : if ( name_space != nullptr )
787 : : {
788 : : /* Prevent setting anything except template in namespace template. */
789 : 66936 : if (g_strcmp0 (name_space, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
790 : 275 : g_strcmp0 (mnemonic, "template") != 0)
791 : : {
792 : 0 : PWARN("Converting commodity %s from namespace template to "
793 : : "namespace User", mnemonic);
794 : 0 : name_space = "User";
795 : : }
796 : 66661 : gnc_commodity_set_namespace(retval, name_space);
797 : 66661 : if (gnc_commodity_namespace_is_iso(name_space))
798 : : {
799 : 63117 : gnc_commodity_set_quote_source(retval,
800 : : gnc_quote_source_lookup_by_internal("currency") );
801 : : }
802 : : }
803 : 66793 : gnc_commodity_set_fullname(retval, fullname);
804 : 66793 : gnc_commodity_set_mnemonic(retval, mnemonic);
805 : 66793 : gnc_commodity_set_cusip(retval, cusip);
806 : 66793 : gnc_commodity_set_fraction(retval, fraction);
807 : 66793 : mark_commodity_dirty (retval);
808 : 66793 : gnc_commodity_commit_edit(retval);
809 : :
810 : 66793 : qof_event_gen (&retval->inst, QOF_EVENT_CREATE, nullptr);
811 : :
812 : 66793 : return retval;
813 : : }
814 : :
815 : :
816 : : /********************************************************************
817 : : * gnc_commodity_destroy
818 : : ********************************************************************/
819 : :
820 : : static void
821 : 41825 : commodity_free(gnc_commodity * cm)
822 : : {
823 : : QofBook *book;
824 : : gnc_commodity_table *table;
825 : : gnc_commodityPrivate* priv;
826 : :
827 : 41825 : if (!cm) return;
828 : :
829 : 41825 : book = qof_instance_get_book(&cm->inst);
830 : 41825 : table = gnc_commodity_table_get_table(book);
831 : 41825 : gnc_commodity_table_remove(table, cm);
832 : 41825 : priv = GET_PRIVATE(cm);
833 : :
834 : 41825 : qof_event_gen (&cm->inst, QOF_EVENT_DESTROY, nullptr);
835 : :
836 : : /* Set at creation */
837 : 41825 : CACHE_REMOVE (priv->fullname);
838 : 41825 : CACHE_REMOVE (priv->cusip);
839 : 41825 : CACHE_REMOVE (priv->mnemonic);
840 : 41825 : CACHE_REMOVE (priv->quote_tz);
841 : 41825 : priv->name_space = nullptr;
842 : :
843 : : /* Set through accessor functions */
844 : 41825 : priv->quote_source = nullptr;
845 : :
846 : : /* Automatically generated */
847 : 41825 : g_free(priv->printname);
848 : 41825 : priv->printname = nullptr;
849 : :
850 : 41825 : g_free(priv->unique_name);
851 : 41825 : priv->unique_name = nullptr;
852 : :
853 : : #ifdef ACCOUNTS_CLEANED_UP
854 : : /* Account objects are not actually cleaned up when a book is closed (in fact
855 : : * a memory leak), but commodities are, so in currently this warning gets hit
856 : : * quite frequently. Disable the check until cleaning up of accounts objects
857 : : * on close is implemented. */
858 : : if (priv->usage_count != 0)
859 : : {
860 : : PWARN("Destroying commodity (%p) with non-zero usage_count (%d).", cm,
861 : : priv->usage_count);
862 : : }
863 : : #endif
864 : :
865 : : /* qof_instance_release (&cm->inst); */
866 : 41825 : g_object_unref(cm);
867 : : }
868 : :
869 : : void
870 : 41825 : gnc_commodity_destroy(gnc_commodity * cm)
871 : : {
872 : 41825 : gnc_commodity_begin_edit(cm);
873 : 41825 : qof_instance_set_destroying(cm, TRUE);
874 : 41825 : gnc_commodity_commit_edit(cm);
875 : 41825 : }
876 : :
877 : : void
878 : 64 : gnc_commodity_copy(gnc_commodity * dest, const gnc_commodity *src)
879 : : {
880 : 64 : gnc_commodityPrivate* src_priv = GET_PRIVATE(src);
881 : 64 : gnc_commodityPrivate* dest_priv = GET_PRIVATE(dest);
882 : :
883 : 64 : gnc_commodity_set_fullname (dest, src_priv->fullname);
884 : 64 : gnc_commodity_set_mnemonic (dest, src_priv->mnemonic);
885 : 64 : dest_priv->name_space = src_priv->name_space;
886 : 64 : gnc_commodity_set_fraction (dest, src_priv->fraction);
887 : 64 : gnc_commodity_set_cusip (dest, src_priv->cusip);
888 : 64 : gnc_commodity_set_quote_flag (dest, src_priv->quote_flag);
889 : 64 : gnc_commodity_set_quote_source (dest, gnc_commodity_get_quote_source (src));
890 : 64 : gnc_commodity_set_quote_tz (dest, src_priv->quote_tz);
891 : 64 : qof_instance_copy_kvp (QOF_INSTANCE (dest), QOF_INSTANCE (src));
892 : 64 : }
893 : :
894 : : gnc_commodity *
895 : 0 : gnc_commodity_clone(const gnc_commodity *src, QofBook *dest_book)
896 : : {
897 : : gnc_commodityPrivate* src_priv;
898 : : gnc_commodityPrivate* dest_priv;
899 : :
900 : 0 : auto dest = GNC_COMMODITY (g_object_new(GNC_TYPE_COMMODITY, nullptr));
901 : 0 : qof_instance_init_data (&dest->inst, GNC_ID_COMMODITY, dest_book);
902 : 0 : src_priv = GET_PRIVATE(src);
903 : 0 : dest_priv = GET_PRIVATE(dest);
904 : :
905 : 0 : dest_priv->fullname = CACHE_INSERT(src_priv->fullname);
906 : 0 : dest_priv->mnemonic = CACHE_INSERT(src_priv->mnemonic);
907 : 0 : dest_priv->cusip = CACHE_INSERT(src_priv->cusip);
908 : 0 : dest_priv->quote_tz = CACHE_INSERT(src_priv->quote_tz);
909 : :
910 : 0 : dest_priv->name_space = src_priv->name_space;
911 : :
912 : 0 : dest_priv->fraction = src_priv->fraction;
913 : 0 : dest_priv->quote_flag = src_priv->quote_flag;
914 : :
915 : 0 : gnc_commodity_set_quote_source (dest, gnc_commodity_get_quote_source (src));
916 : :
917 : 0 : qof_instance_copy_kvp (QOF_INSTANCE (dest), QOF_INSTANCE (src));
918 : :
919 : 0 : reset_printname(dest_priv);
920 : 0 : reset_unique_name(dest_priv);
921 : :
922 : 0 : return dest;
923 : : }
924 : :
925 : : /********************************************************************
926 : : * gnc_commodity_get_mnemonic
927 : : ********************************************************************/
928 : :
929 : : const char *
930 : 130304 : gnc_commodity_get_mnemonic(const gnc_commodity * cm)
931 : : {
932 : 130304 : if (!cm) return nullptr;
933 : 130304 : return GET_PRIVATE(cm)->mnemonic;
934 : : }
935 : :
936 : : /********************************************************************
937 : : * gnc_commodity_get_printname
938 : : ********************************************************************/
939 : :
940 : : const char *
941 : 31024 : gnc_commodity_get_printname(const gnc_commodity * cm)
942 : : {
943 : 31024 : if (!cm) return nullptr;
944 : 31024 : return GET_PRIVATE(cm)->printname;
945 : : }
946 : :
947 : :
948 : : /********************************************************************
949 : : * gnc_commodity_get_namespace
950 : : ********************************************************************/
951 : :
952 : : const char *
953 : 12773 : gnc_commodity_get_namespace(const gnc_commodity * cm)
954 : : {
955 : 12773 : if (!cm) return nullptr;
956 : 12773 : return gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
957 : : }
958 : :
959 : : gnc_commodity_namespace *
960 : 0 : gnc_commodity_get_namespace_ds(const gnc_commodity * cm)
961 : : {
962 : 0 : if (!cm) return nullptr;
963 : 0 : return GET_PRIVATE(cm)->name_space;
964 : : }
965 : :
966 : : /********************************************************************
967 : : * gnc_commodity_get_fullname
968 : : ********************************************************************/
969 : :
970 : : const char *
971 : 70 : gnc_commodity_get_fullname(const gnc_commodity * cm)
972 : : {
973 : 70 : if (!cm) return nullptr;
974 : 70 : return GET_PRIVATE(cm)->fullname;
975 : : }
976 : :
977 : :
978 : : /********************************************************************
979 : : * gnc_commodity_get_unique_name
980 : : ********************************************************************/
981 : :
982 : : const char *
983 : 82 : gnc_commodity_get_unique_name(const gnc_commodity * cm)
984 : : {
985 : 82 : if (!cm) return nullptr;
986 : 76 : return GET_PRIVATE(cm)->unique_name;
987 : : }
988 : :
989 : :
990 : : /********************************************************************
991 : : * gnc_commodity_get_cusip
992 : : ********************************************************************/
993 : :
994 : : const char *
995 : 46 : gnc_commodity_get_cusip(const gnc_commodity * cm)
996 : : {
997 : 46 : if (!cm) return nullptr;
998 : 46 : return GET_PRIVATE(cm)->cusip;
999 : : }
1000 : :
1001 : : /********************************************************************
1002 : : * gnc_commodity_get_fraction
1003 : : ********************************************************************/
1004 : :
1005 : : int
1006 : 181395 : gnc_commodity_get_fraction(const gnc_commodity * cm)
1007 : : {
1008 : 181395 : if (!cm) return 0;
1009 : 181252 : return GET_PRIVATE(cm)->fraction;
1010 : : }
1011 : :
1012 : : /********************************************************************
1013 : : * gnc_commodity_get_auto_quote_control_flag
1014 : : ********************************************************************/
1015 : :
1016 : : gboolean
1017 : 870 : gnc_commodity_get_auto_quote_control_flag(const gnc_commodity *cm)
1018 : : {
1019 : 870 : if (!cm) return FALSE;
1020 : 1740 : auto str{qof_instance_get_path_kvp<const char*> (QOF_INSTANCE (cm), {"auto_quote_control"})};
1021 : 870 : return !str || g_strcmp0 (*str, "false");
1022 : : }
1023 : :
1024 : : /********************************************************************
1025 : : * gnc_commodity_get_quote_flag
1026 : : ********************************************************************/
1027 : :
1028 : : gboolean
1029 : 1042 : gnc_commodity_get_quote_flag(const gnc_commodity *cm)
1030 : : {
1031 : 1042 : if (!cm) return FALSE;
1032 : 1042 : return (GET_PRIVATE(cm)->quote_flag);
1033 : : }
1034 : :
1035 : : /********************************************************************
1036 : : * gnc_commodity_get_quote_source
1037 : : ********************************************************************/
1038 : :
1039 : : gnc_quote_source*
1040 : 167 : gnc_commodity_get_quote_source(const gnc_commodity *cm)
1041 : : {
1042 : : gnc_commodityPrivate* priv;
1043 : :
1044 : 167 : if (!cm) return nullptr;
1045 : 167 : priv = GET_PRIVATE(cm);
1046 : 167 : if (!priv->quote_source && gnc_commodity_is_iso(cm))
1047 : 0 : return ¤cy_quote_sources.front();
1048 : 167 : return priv->quote_source;
1049 : : }
1050 : :
1051 : : gnc_quote_source*
1052 : 146 : gnc_commodity_get_default_quote_source(const gnc_commodity *cm)
1053 : : {
1054 : 146 : if (cm && gnc_commodity_is_iso(cm))
1055 : 146 : return ¤cy_quote_sources.front();
1056 : : /* Should make this a user option at some point. */
1057 : 0 : return gnc_quote_source_lookup_by_internal("alphavantage");
1058 : : }
1059 : :
1060 : : /********************************************************************
1061 : : * gnc_commodity_get_quote_tz
1062 : : ********************************************************************/
1063 : :
1064 : : const char*
1065 : 4 : gnc_commodity_get_quote_tz(const gnc_commodity *cm)
1066 : : {
1067 : 4 : if (!cm) return nullptr;
1068 : 4 : return GET_PRIVATE(cm)->quote_tz;
1069 : : }
1070 : :
1071 : : /********************************************************************
1072 : : * gnc_commodity_get_user_symbol
1073 : : ********************************************************************/
1074 : : const char*
1075 : 61569 : gnc_commodity_get_user_symbol(const gnc_commodity *cm)
1076 : : {
1077 : 61569 : g_return_val_if_fail (GNC_IS_COMMODITY (cm), nullptr);
1078 : :
1079 : 123138 : auto sym{qof_instance_get_path_kvp<const char*> (QOF_INSTANCE(cm), {"user_symbol"})};
1080 : 61569 : return sym ? *sym : nullptr;
1081 : : }
1082 : :
1083 : : /********************************************************************
1084 : : * gnc_commodity_get_default_symbol
1085 : : *******************************************************************/
1086 : : const char*
1087 : 61110 : gnc_commodity_get_default_symbol(const gnc_commodity *cm)
1088 : : {
1089 : 61110 : if (!cm) return nullptr;
1090 : 61110 : return GET_PRIVATE(cm)->default_symbol;
1091 : : }
1092 : :
1093 : : /********************************************************************
1094 : : * gnc_commodity_get_nice_symbol
1095 : : *******************************************************************/
1096 : : const char*
1097 : 61567 : gnc_commodity_get_nice_symbol (const gnc_commodity *cm)
1098 : : {
1099 : : const char *nice_symbol;
1100 : : struct lconv *lc;
1101 : 61567 : if (!cm) return nullptr;
1102 : :
1103 : 61567 : nice_symbol = gnc_commodity_get_user_symbol(cm);
1104 : 61567 : if (nice_symbol && *nice_symbol)
1105 : 464 : return nice_symbol;
1106 : :
1107 : 61103 : lc = gnc_localeconv();
1108 : 61103 : nice_symbol = lc->currency_symbol;
1109 : 61103 : if (!g_strcmp0(gnc_commodity_get_mnemonic(cm), lc->int_curr_symbol))
1110 : 0 : return nice_symbol;
1111 : :
1112 : 61103 : nice_symbol = gnc_commodity_get_default_symbol(cm);
1113 : 61103 : if (nice_symbol && *nice_symbol)
1114 : 60855 : return nice_symbol;
1115 : :
1116 : 248 : return gnc_commodity_get_mnemonic(cm);
1117 : : }
1118 : :
1119 : : /********************************************************************
1120 : : * gnc_commodity_set_mnemonic
1121 : : ********************************************************************/
1122 : :
1123 : : void
1124 : 66988 : gnc_commodity_set_mnemonic(gnc_commodity * cm, const char * mnemonic)
1125 : : {
1126 : : gnc_commodityPrivate* priv;
1127 : :
1128 : 66988 : if (!cm) return;
1129 : 66988 : priv = GET_PRIVATE(cm);
1130 : 66988 : if (priv->mnemonic == mnemonic) return;
1131 : :
1132 : 66943 : gnc_commodity_begin_edit(cm);
1133 : 66943 : CACHE_REMOVE (priv->mnemonic);
1134 : 66943 : priv->mnemonic = CACHE_INSERT(mnemonic);
1135 : :
1136 : 66943 : mark_commodity_dirty (cm);
1137 : 66943 : reset_printname(priv);
1138 : 66943 : reset_unique_name(priv);
1139 : 66943 : gnc_commodity_commit_edit(cm);
1140 : : }
1141 : :
1142 : : /********************************************************************
1143 : : * gnc_commodity_set_namespace
1144 : : ********************************************************************/
1145 : :
1146 : : void
1147 : 66792 : gnc_commodity_set_namespace(gnc_commodity * cm, const char * name_space)
1148 : : {
1149 : : QofBook *book;
1150 : : gnc_commodity_table *table;
1151 : : gnc_commodity_namespace *nsp;
1152 : : gnc_commodityPrivate* priv;
1153 : :
1154 : 66792 : if (!cm) return;
1155 : 66792 : priv = GET_PRIVATE(cm);
1156 : 66792 : book = qof_instance_get_book (&cm->inst);
1157 : 66792 : table = gnc_commodity_table_get_table(book);
1158 : 66792 : nsp = gnc_commodity_table_add_namespace(table, name_space, book);
1159 : 66792 : if (priv->name_space == nsp)
1160 : 351 : return;
1161 : :
1162 : 66441 : gnc_commodity_begin_edit(cm);
1163 : 66441 : priv->name_space = nsp;
1164 : 66441 : if (nsp->iso4217)
1165 : 62908 : priv->quote_source = gnc_quote_source_lookup_by_internal("currency");
1166 : 66441 : mark_commodity_dirty(cm);
1167 : 66441 : reset_printname(priv);
1168 : 66441 : reset_unique_name(priv);
1169 : 66441 : gnc_commodity_commit_edit(cm);
1170 : : }
1171 : :
1172 : : /********************************************************************
1173 : : * gnc_commodity_set_fullname
1174 : : ********************************************************************/
1175 : :
1176 : : void
1177 : 66969 : gnc_commodity_set_fullname(gnc_commodity * cm, const char * fullname)
1178 : : {
1179 : : gnc_commodityPrivate* priv;
1180 : :
1181 : 66969 : if (!cm) return;
1182 : 66969 : priv = GET_PRIVATE(cm);
1183 : 66969 : if (priv->fullname == fullname) return;
1184 : :
1185 : 66924 : CACHE_REMOVE (priv->fullname);
1186 : 66924 : priv->fullname = CACHE_INSERT (fullname);
1187 : :
1188 : 66924 : gnc_commodity_begin_edit(cm);
1189 : 66924 : mark_commodity_dirty(cm);
1190 : 66924 : reset_printname(priv);
1191 : 66924 : gnc_commodity_commit_edit(cm);
1192 : : }
1193 : :
1194 : : /********************************************************************
1195 : : * gnc_commodity_set_cusip
1196 : : ********************************************************************/
1197 : :
1198 : : void
1199 : 66912 : gnc_commodity_set_cusip(gnc_commodity * cm,
1200 : : const char * cusip)
1201 : : {
1202 : : gnc_commodityPrivate* priv;
1203 : :
1204 : 66912 : if (!cm) return;
1205 : :
1206 : 66912 : priv = GET_PRIVATE(cm);
1207 : 66912 : if (priv->cusip == cusip) return;
1208 : :
1209 : 66867 : gnc_commodity_begin_edit(cm);
1210 : 66867 : CACHE_REMOVE (priv->cusip);
1211 : 66867 : priv->cusip = CACHE_INSERT (cusip);
1212 : 66867 : mark_commodity_dirty(cm);
1213 : 66867 : gnc_commodity_commit_edit(cm);
1214 : : }
1215 : :
1216 : : /********************************************************************
1217 : : * gnc_commodity_set_fraction
1218 : : ********************************************************************/
1219 : :
1220 : : void
1221 : 66969 : gnc_commodity_set_fraction(gnc_commodity * cm, int fraction)
1222 : : {
1223 : 66969 : if (!cm) return;
1224 : 66969 : gnc_commodity_begin_edit(cm);
1225 : 66969 : GET_PRIVATE(cm)->fraction = fraction;
1226 : 66969 : mark_commodity_dirty(cm);
1227 : 66969 : gnc_commodity_commit_edit(cm);
1228 : : }
1229 : :
1230 : : /********************************************************************
1231 : : * gnc_commodity_set_auto_quote_control_flag
1232 : : ********************************************************************/
1233 : :
1234 : : void
1235 : 2 : gnc_commodity_set_auto_quote_control_flag(gnc_commodity *cm,
1236 : : const gboolean flag)
1237 : : {
1238 : 2 : ENTER ("(cm=%p, flag=%d)", cm, flag);
1239 : :
1240 : 2 : if (!cm)
1241 : : {
1242 : 0 : LEAVE("");
1243 : 0 : return;
1244 : : }
1245 : 2 : gnc_commodity_begin_edit(cm);
1246 : 3 : auto val = flag ? std::nullopt : std::make_optional<const char*>(g_strdup("false"));
1247 : 4 : qof_instance_set_path_kvp<const char*> (QOF_INSTANCE (cm), val, {"auto_quote_control"});
1248 : 2 : mark_commodity_dirty(cm);
1249 : 2 : gnc_commodity_commit_edit(cm);
1250 : 2 : LEAVE("");
1251 : : }
1252 : :
1253 : : /********************************************************************
1254 : : * gnc_commodity_user_set_quote_flag
1255 : : ********************************************************************/
1256 : :
1257 : : void
1258 : 0 : gnc_commodity_user_set_quote_flag(gnc_commodity *cm, const gboolean flag)
1259 : : {
1260 : : gnc_commodityPrivate* priv;
1261 : :
1262 : 0 : ENTER ("(cm=%p, flag=%d)", cm, flag);
1263 : :
1264 : 0 : if (!cm)
1265 : : {
1266 : 0 : LEAVE("");
1267 : 0 : return;
1268 : : }
1269 : :
1270 : 0 : priv = GET_PRIVATE(cm);
1271 : 0 : gnc_commodity_begin_edit(cm);
1272 : 0 : gnc_commodity_set_quote_flag(cm, flag);
1273 : 0 : if (gnc_commodity_is_iso(cm))
1274 : : {
1275 : : /* For currencies, disable auto quote control if the quote flag is being
1276 : : * changed from its default value and enable it if the quote flag is being
1277 : : * reset to its default value. The defaults for the quote flag are
1278 : : * disabled if no accounts are using the currency, and true otherwise.
1279 : : * Thus enable auto quote control if flag is FALSE and there are not any
1280 : : * accounts using this currency OR flag is TRUE and there are accounts
1281 : : * using this currency; otherwise disable auto quote control */
1282 : 0 : gnc_commodity_set_auto_quote_control_flag(cm,
1283 : 0 : (!flag && (priv->usage_count == 0)) || (flag && (priv->usage_count != 0)));
1284 : : }
1285 : 0 : gnc_commodity_commit_edit(cm);
1286 : 0 : LEAVE("");
1287 : : }
1288 : :
1289 : : /********************************************************************
1290 : : * gnc_commodity_set_quote_flag
1291 : : ********************************************************************/
1292 : :
1293 : : void
1294 : 380 : gnc_commodity_set_quote_flag(gnc_commodity *cm, const gboolean flag)
1295 : : {
1296 : 380 : ENTER ("(cm=%p, flag=%d)", cm, flag);
1297 : :
1298 : 380 : if (!cm) return;
1299 : 380 : gnc_commodity_begin_edit(cm);
1300 : 380 : GET_PRIVATE(cm)->quote_flag = flag;
1301 : 380 : mark_commodity_dirty(cm);
1302 : 380 : gnc_commodity_commit_edit(cm);
1303 : 380 : LEAVE(" ");
1304 : : }
1305 : :
1306 : : /********************************************************************
1307 : : * gnc_commodity_set_quote_source
1308 : : ********************************************************************/
1309 : :
1310 : : void
1311 : 63415 : gnc_commodity_set_quote_source(gnc_commodity *cm, gnc_quote_source *src)
1312 : : {
1313 : 63415 : ENTER ("(cm=%p, src=%p(%s))", cm, src, src ? src->get_internal_name() : "unknown");
1314 : :
1315 : 63415 : if (!cm) return;
1316 : 63415 : gnc_commodity_begin_edit(cm);
1317 : 63415 : GET_PRIVATE(cm)->quote_source = src;
1318 : 63415 : mark_commodity_dirty(cm);
1319 : 63415 : gnc_commodity_commit_edit(cm);
1320 : 63415 : LEAVE(" ");
1321 : : }
1322 : :
1323 : : /********************************************************************
1324 : : * gnc_commodity_set_quote_tz
1325 : : ********************************************************************/
1326 : :
1327 : : void
1328 : 91 : gnc_commodity_set_quote_tz(gnc_commodity *cm, const char *tz)
1329 : : {
1330 : : gnc_commodityPrivate* priv;
1331 : :
1332 : 91 : if (!cm) return;
1333 : :
1334 : 91 : ENTER ("(cm=%p, tz=%s)", cm, tz ? tz : "(null)");
1335 : :
1336 : 91 : priv = GET_PRIVATE(cm);
1337 : :
1338 : 91 : if (tz == priv->quote_tz)
1339 : : {
1340 : 64 : LEAVE("Already correct TZ");
1341 : 64 : return;
1342 : : }
1343 : :
1344 : 27 : gnc_commodity_begin_edit(cm);
1345 : 27 : CACHE_REMOVE (priv->quote_tz);
1346 : 27 : priv->quote_tz = CACHE_INSERT (tz);
1347 : 27 : mark_commodity_dirty(cm);
1348 : 27 : gnc_commodity_commit_edit(cm);
1349 : 27 : LEAVE(" ");
1350 : : }
1351 : :
1352 : : /********************************************************************
1353 : : * gnc_commodity_set_user_symbol
1354 : : ********************************************************************/
1355 : :
1356 : : void
1357 : 7 : gnc_commodity_set_user_symbol(gnc_commodity * cm, const char * user_symbol)
1358 : : {
1359 : : struct lconv *lc;
1360 : :
1361 : 7 : if (!cm) return;
1362 : :
1363 : 7 : ENTER ("(cm=%p, symbol=%s)", cm, user_symbol ? user_symbol : "(null)");
1364 : :
1365 : 7 : lc = gnc_localeconv();
1366 : 7 : if (!user_symbol || !*user_symbol)
1367 : 0 : user_symbol = nullptr;
1368 : 7 : else if (!g_strcmp0(lc->int_curr_symbol, gnc_commodity_get_mnemonic(cm)) &&
1369 : 0 : !g_strcmp0(lc->currency_symbol, user_symbol))
1370 : : /* if the user gives the ISO symbol for the locale currency or the
1371 : : * default symbol, actually remove the user symbol */
1372 : 0 : user_symbol = nullptr;
1373 : 7 : else if (!g_strcmp0(user_symbol, gnc_commodity_get_default_symbol(cm)))
1374 : 0 : user_symbol = nullptr;
1375 : :
1376 : 7 : gnc_commodity_begin_edit (cm);
1377 : :
1378 : 14 : auto val = user_symbol ? std::make_optional<const char*>(g_strdup(user_symbol)) : std::nullopt;
1379 : 14 : qof_instance_set_path_kvp<const char*> (QOF_INSTANCE(cm), val, {"user_symbol"});
1380 : :
1381 : 7 : mark_commodity_dirty(cm);
1382 : 7 : gnc_commodity_commit_edit(cm);
1383 : :
1384 : 7 : LEAVE(" ");
1385 : : }
1386 : :
1387 : : /********************************************************************
1388 : : * gnc_commodity_set_default_symbol
1389 : : * Not made visible in gnc-commodity.h, it is only called from
1390 : : * iso-4217-currencies.c at startup.
1391 : : ********************************************************************/
1392 : : void
1393 : 60836 : gnc_commodity_set_default_symbol(gnc_commodity * cm,
1394 : : const char * default_symbol)
1395 : : {
1396 : 60836 : GET_PRIVATE(cm)->default_symbol = default_symbol;
1397 : 60836 : }
1398 : :
1399 : : /********************************************************************
1400 : : * gnc_commodity_increment_usage_count
1401 : : ********************************************************************/
1402 : :
1403 : : void
1404 : 3054 : gnc_commodity_increment_usage_count(gnc_commodity *cm)
1405 : : {
1406 : : gnc_commodityPrivate* priv;
1407 : :
1408 : 3054 : ENTER("(cm=%p)", cm);
1409 : :
1410 : 3054 : if (!cm)
1411 : : {
1412 : 1 : LEAVE("");
1413 : 1 : return;
1414 : : }
1415 : :
1416 : 3053 : priv = GET_PRIVATE(cm);
1417 : :
1418 : 809 : if ((priv->usage_count == 0) && !priv->quote_flag
1419 : 783 : && gnc_commodity_get_auto_quote_control_flag(cm)
1420 : 3862 : && gnc_commodity_is_iso(cm))
1421 : : {
1422 : : /* compatibility hack - Gnucash 1.8 gets currency quotes when a
1423 : : non-default currency is assigned to an account. */
1424 : 146 : gnc_commodity_begin_edit(cm);
1425 : 146 : gnc_commodity_set_quote_flag(cm, TRUE);
1426 : 146 : gnc_commodity_set_quote_source(cm,
1427 : : gnc_commodity_get_default_quote_source(cm));
1428 : 146 : gnc_commodity_commit_edit(cm);
1429 : : }
1430 : 3053 : priv->usage_count++;
1431 : 3053 : LEAVE("(usage_count=%d)", priv->usage_count);
1432 : : }
1433 : :
1434 : : /********************************************************************
1435 : : * gnc_commodity_decrement_usage_count
1436 : : ********************************************************************/
1437 : :
1438 : : void
1439 : 5154 : gnc_commodity_decrement_usage_count(gnc_commodity *cm)
1440 : : {
1441 : : gnc_commodityPrivate* priv;
1442 : :
1443 : 5154 : ENTER("(cm=%p)", cm);
1444 : :
1445 : 5154 : if (!cm)
1446 : : {
1447 : 3759 : LEAVE("");
1448 : 3759 : return;
1449 : : }
1450 : :
1451 : 1395 : priv = GET_PRIVATE(cm);
1452 : :
1453 : 1395 : if (priv->usage_count == 0)
1454 : : {
1455 : 0 : PWARN("usage_count already zero");
1456 : 0 : LEAVE("");
1457 : 0 : return;
1458 : : }
1459 : :
1460 : 1395 : priv->usage_count--;
1461 : 294 : if ((priv->usage_count == 0) && priv->quote_flag
1462 : 84 : && gnc_commodity_get_auto_quote_control_flag(cm)
1463 : 1689 : && gnc_commodity_is_iso(cm))
1464 : : {
1465 : : /* if this is a currency with auto quote control enabled and no more
1466 : : * accounts reference this currency, disable quote retrieval */
1467 : 82 : gnc_commodity_set_quote_flag(cm, FALSE);
1468 : : }
1469 : 1395 : LEAVE("(usage_count=%d)", priv->usage_count);
1470 : : }
1471 : :
1472 : : /********************************************************************\
1473 : : \********************************************************************/
1474 : :
1475 : :
1476 : : /********************************************************************
1477 : : * gnc_commodity_equiv
1478 : : * are two commodities the same?
1479 : : ********************************************************************/
1480 : :
1481 : : gboolean
1482 : 118600 : gnc_commodity_equiv(const gnc_commodity * a, const gnc_commodity * b)
1483 : : {
1484 : : gnc_commodityPrivate* priv_a;
1485 : : gnc_commodityPrivate* priv_b;
1486 : :
1487 : 118600 : if (a == b) return TRUE;
1488 : 48474 : if (!a || !b) return FALSE;
1489 : :
1490 : 21538 : priv_a = GET_PRIVATE(a);
1491 : 21538 : priv_b = GET_PRIVATE(b);
1492 : 21538 : if (priv_a->name_space != priv_b->name_space) return FALSE;
1493 : 17579 : if (g_strcmp0(priv_a->mnemonic, priv_b->mnemonic) != 0) return FALSE;
1494 : :
1495 : 69 : return TRUE;
1496 : : }
1497 : :
1498 : : gboolean
1499 : 14698 : gnc_commodity_equal(const gnc_commodity * a, const gnc_commodity * b)
1500 : : {
1501 : 14698 : return gnc_commodity_compare(a, b) == 0;
1502 : : }
1503 : :
1504 : : // Used as a sorting callback for deleting old prices, so it needs to be
1505 : : // stable but doesn't need to be in any particular order sensible to humans.
1506 : 14723 : int gnc_commodity_compare(const gnc_commodity * a, const gnc_commodity * b)
1507 : : {
1508 : 14723 : if (a == b) return 0;
1509 : 2453 : if (a && !b) return 1;
1510 : 2445 : if (b && !a) return -1;
1511 : 2421 : return qof_instance_guid_compare(a, b);
1512 : : }
1513 : :
1514 : : // Used as a callback to g_list_find_custom, it should return 0
1515 : : // when the commodities match.
1516 : 0 : int gnc_commodity_compare_void(const void * a, const void * b)
1517 : : {
1518 : 0 : return gnc_commodity_compare(GNC_COMMODITY (a), GNC_COMMODITY (b));
1519 : : }
1520 : :
1521 : : /************************************************************
1522 : : * Namespace functions *
1523 : : ************************************************************/
1524 : : const char *
1525 : 84163 : gnc_commodity_namespace_get_name (const gnc_commodity_namespace *ns)
1526 : : {
1527 : 84163 : if (ns == nullptr)
1528 : 24 : return nullptr;
1529 : 84139 : return ns->name;
1530 : : }
1531 : :
1532 : : const char *
1533 : 0 : gnc_commodity_namespace_get_gui_name (const gnc_commodity_namespace *ns)
1534 : : {
1535 : 0 : if (ns == nullptr)
1536 : 0 : return nullptr;
1537 : 0 : if (g_strcmp0 (ns->name, GNC_COMMODITY_NS_CURRENCY) == 0)
1538 : 0 : return GNC_COMMODITY_NS_ISO_GUI;
1539 : 0 : return ns->name;
1540 : : }
1541 : :
1542 : : GList *
1543 : 0 : gnc_commodity_namespace_get_commodity_list(const gnc_commodity_namespace *name_space)
1544 : : {
1545 : 0 : if (!name_space)
1546 : 0 : return nullptr;
1547 : :
1548 : 0 : return g_list_copy (name_space->cm_list);
1549 : : }
1550 : :
1551 : : gboolean
1552 : 67696 : gnc_commodity_namespace_is_iso(const char *name_space)
1553 : : {
1554 : 72630 : return ((g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0) ||
1555 : 72630 : (g_strcmp0(name_space, GNC_COMMODITY_NS_CURRENCY) == 0));
1556 : : }
1557 : :
1558 : : static const gchar *
1559 : 338367 : gnc_commodity_table_map_namespace(const char * name_space)
1560 : : {
1561 : 338367 : if (g_strcmp0(name_space, GNC_COMMODITY_NS_ISO) == 0)
1562 : 62669 : return GNC_COMMODITY_NS_CURRENCY;
1563 : 275698 : return name_space;
1564 : : }
1565 : :
1566 : : /********************************************************************
1567 : : * gnc_commodity_table_new
1568 : : * make a new commodity table
1569 : : ********************************************************************/
1570 : :
1571 : : gnc_commodity_table *
1572 : 292 : gnc_commodity_table_new(void)
1573 : : {
1574 : 292 : gnc_commodity_table * retval = g_new0(gnc_commodity_table, 1);
1575 : 292 : retval->ns_table = g_hash_table_new(&g_str_hash, &g_str_equal);
1576 : 292 : retval->ns_list = nullptr;
1577 : 292 : return retval;
1578 : : }
1579 : :
1580 : : /********************************************************************
1581 : : * book anchor functions
1582 : : ********************************************************************/
1583 : :
1584 : : gnc_commodity_table *
1585 : 119716 : gnc_commodity_table_get_table(QofBook *book)
1586 : : {
1587 : 119716 : if (!book) return nullptr;
1588 : 119716 : return static_cast<gnc_commodity_table*>(qof_book_get_data (book, GNC_COMMODITY_TABLE));
1589 : : }
1590 : :
1591 : : gnc_commodity *
1592 : 1 : gnc_commodity_obtain_twin (const gnc_commodity *from, QofBook *book)
1593 : : {
1594 : : gnc_commodity *twin;
1595 : : const char * ucom;
1596 : : gnc_commodity_table * comtbl;
1597 : :
1598 : 1 : if (!from) return nullptr;
1599 : 0 : comtbl = gnc_commodity_table_get_table (book);
1600 : 0 : if (!comtbl) return nullptr;
1601 : :
1602 : 0 : ucom = gnc_commodity_get_unique_name (from);
1603 : 0 : twin = gnc_commodity_table_lookup_unique (comtbl, ucom);
1604 : 0 : if (!twin)
1605 : : {
1606 : 0 : twin = gnc_commodity_clone (from, book);
1607 : 0 : twin = gnc_commodity_table_insert (comtbl, twin);
1608 : : }
1609 : 0 : return twin;
1610 : : }
1611 : :
1612 : : /********************************************************************
1613 : : * gnc_commodity_table_get_size
1614 : : * get the size of the commodity table
1615 : : ********************************************************************/
1616 : :
1617 : : static void
1618 : 172 : count_coms(gpointer key, gpointer value, gpointer user_data)
1619 : : {
1620 : 172 : GHashTable *tbl = ((gnc_commodity_namespace*)value)->cm_table;
1621 : 172 : guint *count = (guint*)user_data;
1622 : :
1623 : 172 : if (g_strcmp0((char*)key, GNC_COMMODITY_NS_CURRENCY) == 0)
1624 : : {
1625 : : /* don't count default commodities */
1626 : 8 : return;
1627 : : }
1628 : :
1629 : 164 : if (!value) return;
1630 : :
1631 : 164 : *count += g_hash_table_size(tbl);
1632 : : }
1633 : :
1634 : : guint
1635 : 49 : gnc_commodity_table_get_size(const gnc_commodity_table* tbl)
1636 : : {
1637 : 49 : guint count = 0;
1638 : 49 : g_return_val_if_fail(tbl, 0);
1639 : 49 : g_return_val_if_fail(tbl->ns_table, 0);
1640 : :
1641 : 49 : g_hash_table_foreach(tbl->ns_table, count_coms, (gpointer)&count);
1642 : :
1643 : 49 : return count;
1644 : : }
1645 : :
1646 : : /********************************************************************
1647 : : * gnc_commodity_table_lookup
1648 : : * locate a commodity by namespace and mnemonic.
1649 : : ********************************************************************/
1650 : :
1651 : : gnc_commodity *
1652 : 78342 : gnc_commodity_table_lookup(const gnc_commodity_table * table,
1653 : : const char * name_space, const char * mnemonic)
1654 : : {
1655 : 78342 : gnc_commodity_namespace * nsp = nullptr;
1656 : :
1657 : 78342 : if (!table || !name_space || !mnemonic) return nullptr;
1658 : :
1659 : 78300 : nsp = gnc_commodity_table_find_namespace(table, name_space);
1660 : :
1661 : 78300 : if (nsp)
1662 : : {
1663 : : /*
1664 : : * Backward compatibility support for currencies that have
1665 : : * recently changed.
1666 : : */
1667 : 77159 : if (nsp->iso4217)
1668 : : {
1669 : 69704 : auto it = gnc_new_iso_codes.find (mnemonic);
1670 : 69704 : if (it != gnc_new_iso_codes.end())
1671 : 0 : mnemonic = it->second.c_str();
1672 : : }
1673 : 77159 : return GNC_COMMODITY(g_hash_table_lookup(nsp->cm_table, (gpointer)mnemonic));
1674 : : }
1675 : : else
1676 : : {
1677 : 1141 : return nullptr;
1678 : : }
1679 : : }
1680 : :
1681 : : /********************************************************************
1682 : : * gnc_commodity_table_lookup
1683 : : * locate a commodity by unique name.
1684 : : ********************************************************************/
1685 : :
1686 : : gnc_commodity *
1687 : 0 : gnc_commodity_table_lookup_unique(const gnc_commodity_table *table,
1688 : : const char * unique_name)
1689 : : {
1690 : : char *name_space;
1691 : : char *mnemonic;
1692 : : gnc_commodity *commodity;
1693 : :
1694 : 0 : if (!table || !unique_name) return nullptr;
1695 : :
1696 : 0 : name_space = g_strdup (unique_name);
1697 : 0 : mnemonic = strstr (name_space, "::");
1698 : 0 : if (!mnemonic)
1699 : : {
1700 : 0 : g_free (name_space);
1701 : 0 : return nullptr;
1702 : : }
1703 : :
1704 : 0 : *mnemonic = '\0';
1705 : 0 : mnemonic += 2;
1706 : :
1707 : 0 : commodity = gnc_commodity_table_lookup (table, name_space, mnemonic);
1708 : :
1709 : 0 : g_free (name_space);
1710 : :
1711 : 0 : return commodity;
1712 : : }
1713 : :
1714 : : /********************************************************************
1715 : : * gnc_commodity_table_find_full
1716 : : * locate a commodity by namespace and printable name
1717 : : ********************************************************************/
1718 : :
1719 : : gnc_commodity *
1720 : 0 : gnc_commodity_table_find_full(const gnc_commodity_table * table,
1721 : : const char * name_space,
1722 : : const char * fullname)
1723 : : {
1724 : 0 : gnc_commodity * retval = nullptr;
1725 : : GList * all;
1726 : : GList * iterator;
1727 : :
1728 : 0 : if (!fullname || (fullname[0] == '\0'))
1729 : 0 : return nullptr;
1730 : :
1731 : 0 : all = gnc_commodity_table_get_commodities(table, name_space);
1732 : :
1733 : 0 : for (iterator = all; iterator; iterator = iterator->next)
1734 : : {
1735 : 0 : auto commodity = GNC_COMMODITY (iterator->data);
1736 : 0 : if (!strcmp(fullname,
1737 : : gnc_commodity_get_printname(commodity)))
1738 : : {
1739 : 0 : retval = commodity;
1740 : 0 : break;
1741 : : }
1742 : : }
1743 : :
1744 : 0 : g_list_free (all);
1745 : :
1746 : 0 : return retval;
1747 : : }
1748 : :
1749 : :
1750 : : /********************************************************************
1751 : : * gnc_commodity_table_insert
1752 : : * add a commodity to the table.
1753 : : ********************************************************************/
1754 : :
1755 : : gnc_commodity *
1756 : 62909 : gnc_commodity_table_insert(gnc_commodity_table * table,
1757 : : gnc_commodity * comm)
1758 : : {
1759 : 62909 : gnc_commodity_namespace * nsp = nullptr;
1760 : : gnc_commodity *c;
1761 : : const char *ns_name;
1762 : : gnc_commodityPrivate* priv;
1763 : : QofBook *book;
1764 : :
1765 : 62909 : if (!table) return nullptr;
1766 : 62909 : if (!comm) return nullptr;
1767 : :
1768 : 62909 : priv = GET_PRIVATE(comm);
1769 : :
1770 : 62909 : ENTER ("(table=%p, comm=%p) %s %s", table, comm,
1771 : : (priv->mnemonic == nullptr ? "(null)" : priv->mnemonic),
1772 : : (priv->fullname == nullptr ? "(null)" : priv->fullname));
1773 : 62909 : ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1774 : 62909 : c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1775 : :
1776 : 62909 : if (c)
1777 : : {
1778 : 48 : if (c == comm)
1779 : : {
1780 : 3 : LEAVE("already in table");
1781 : 3 : return c;
1782 : : }
1783 : :
1784 : : /* Backward compatibility support for currencies that have
1785 : : * recently changed. */
1786 : 45 : if (priv->name_space->iso4217)
1787 : : {
1788 : 25 : auto it = gnc_new_iso_codes.find (priv->mnemonic);
1789 : 25 : if (it != gnc_new_iso_codes.end())
1790 : 0 : gnc_commodity_set_mnemonic(comm, it->second.c_str());
1791 : : }
1792 : 45 : gnc_commodity_copy (c, comm);
1793 : 45 : gnc_commodity_destroy (comm);
1794 : 45 : LEAVE("found at %p", c);
1795 : 45 : return c;
1796 : : }
1797 : :
1798 : : /* Prevent setting anything except template in namespace template. */
1799 : 63129 : if (g_strcmp0 (ns_name, GNC_COMMODITY_NS_TEMPLATE) == 0 &&
1800 : 268 : g_strcmp0 (priv->mnemonic, "template") != 0)
1801 : : {
1802 : 0 : PWARN("Converting commodity %s from namespace template to "
1803 : : "namespace User", priv->mnemonic);
1804 : 0 : gnc_commodity_set_namespace (comm, "User");
1805 : 0 : ns_name = "User";
1806 : 0 : mark_commodity_dirty (comm);
1807 : : }
1808 : :
1809 : 62861 : book = qof_instance_get_book (&comm->inst);
1810 : 62861 : nsp = gnc_commodity_table_add_namespace(table, ns_name, book);
1811 : :
1812 : 62861 : PINFO ("insert %p %s into nsp=%p %s", priv->mnemonic, priv->mnemonic,
1813 : : nsp->cm_table, nsp->name);
1814 : 62861 : g_hash_table_insert(nsp->cm_table,
1815 : 62861 : (gpointer)CACHE_INSERT(priv->mnemonic),
1816 : : (gpointer)comm);
1817 : 62861 : nsp->cm_list = g_list_append(nsp->cm_list, comm);
1818 : :
1819 : 62861 : qof_event_gen (&comm->inst, QOF_EVENT_ADD, nullptr);
1820 : 62861 : LEAVE ("(table=%p, comm=%p)", table, comm);
1821 : 62861 : return comm;
1822 : : }
1823 : :
1824 : : /********************************************************************
1825 : : * gnc_commodity_table_remove
1826 : : * remove a commodity from the table.
1827 : : ********************************************************************/
1828 : :
1829 : : void
1830 : 41825 : gnc_commodity_table_remove(gnc_commodity_table * table,
1831 : : gnc_commodity * comm)
1832 : : {
1833 : : gnc_commodity_namespace * nsp;
1834 : : gnc_commodity *c;
1835 : : gnc_commodityPrivate* priv;
1836 : : const char *ns_name;
1837 : :
1838 : 41825 : if (!table) return;
1839 : 4593 : if (!comm) return;
1840 : :
1841 : 4593 : priv = GET_PRIVATE(comm);
1842 : 4593 : ns_name = gnc_commodity_namespace_get_name(priv->name_space);
1843 : 4593 : c = gnc_commodity_table_lookup (table, ns_name, priv->mnemonic);
1844 : 4593 : if (c != comm) return;
1845 : :
1846 : 65 : qof_event_gen (&comm->inst, QOF_EVENT_REMOVE, nullptr);
1847 : :
1848 : 65 : nsp = gnc_commodity_table_find_namespace(table, ns_name);
1849 : 65 : if (!nsp) return;
1850 : :
1851 : 65 : nsp->cm_list = g_list_remove(nsp->cm_list, comm);
1852 : 65 : g_hash_table_remove (nsp->cm_table, priv->mnemonic);
1853 : : /* XXX minor mem leak, should remove the key as well */
1854 : : }
1855 : :
1856 : : /********************************************************************
1857 : : * gnc_commodity_table_has_namespace
1858 : : * see if the commodities namespace exists. May have zero commodities.
1859 : : ********************************************************************/
1860 : :
1861 : : int
1862 : 20 : gnc_commodity_table_has_namespace(const gnc_commodity_table * table,
1863 : : const char * name_space)
1864 : : {
1865 : 20 : gnc_commodity_namespace * nsp = nullptr;
1866 : :
1867 : 20 : if (!table || !name_space)
1868 : : {
1869 : 0 : return 0;
1870 : : }
1871 : :
1872 : 20 : nsp = gnc_commodity_table_find_namespace(table, name_space);
1873 : 20 : if (nsp)
1874 : : {
1875 : 20 : return 1;
1876 : : }
1877 : : else
1878 : : {
1879 : 0 : return 0;
1880 : : }
1881 : : }
1882 : :
1883 : : static void
1884 : 1642 : hash_keys_helper(gpointer key, gpointer value, gpointer data)
1885 : : {
1886 : 1642 : auto l = (GList**)data;
1887 : 1642 : *l = g_list_prepend(*l, key);
1888 : 1642 : }
1889 : :
1890 : : static GList *
1891 : 241 : g_hash_table_keys(GHashTable * table)
1892 : : {
1893 : 241 : GList * l = nullptr;
1894 : 241 : g_hash_table_foreach(table, &hash_keys_helper, (gpointer) &l);
1895 : 241 : return l;
1896 : : }
1897 : :
1898 : : static void
1899 : 10164 : hash_values_helper(gpointer key, gpointer value, gpointer data)
1900 : : {
1901 : 10164 : auto l = (GList**)data;
1902 : 10164 : *l = g_list_prepend(*l, value);
1903 : 10164 : }
1904 : :
1905 : : static GList *
1906 : 240 : g_hash_table_values(GHashTable * table)
1907 : : {
1908 : 240 : GList * l = nullptr;
1909 : 240 : g_hash_table_foreach(table, &hash_values_helper, (gpointer) &l);
1910 : 240 : return l;
1911 : : }
1912 : :
1913 : : /********************************************************************
1914 : : * gnc_commodity_table_get_namespaces
1915 : : * see if any commodities in the namespace exist
1916 : : ********************************************************************/
1917 : :
1918 : : GList *
1919 : 241 : gnc_commodity_table_get_namespaces(const gnc_commodity_table * table)
1920 : : {
1921 : 241 : if (!table)
1922 : 0 : return nullptr;
1923 : :
1924 : 241 : return g_hash_table_keys(table->ns_table);
1925 : : }
1926 : :
1927 : : GList *
1928 : 2 : gnc_commodity_table_get_namespaces_list(const gnc_commodity_table * table)
1929 : : {
1930 : 2 : if (!table)
1931 : 0 : return nullptr;
1932 : :
1933 : 2 : return g_list_copy (table->ns_list);
1934 : : }
1935 : :
1936 : : /* Because gnc_commodity_table_add_namespace maps GNC_COMMODITY_NS_ISO to
1937 : : GNC_COMMODITY_NS_CURRENCY and then sets iso4217 if the namespace is
1938 : : either of these, the net result is that the iso4217 bit is set only
1939 : : for GNC_COMMODITY_NS_CURRENCY. This means that gnc_commodity_is_iso is
1940 : : a subset of gnc_commodity_is_currency. Most callers seem to use
1941 : : gnc_commodity_is_iso. */
1942 : : gboolean
1943 : 174868 : gnc_commodity_is_iso(const gnc_commodity * cm)
1944 : : {
1945 : : gnc_commodityPrivate* priv;
1946 : :
1947 : 174868 : if (!cm) return FALSE;
1948 : :
1949 : 174868 : priv = GET_PRIVATE(cm);
1950 : 174868 : if ( !priv->name_space) return FALSE;
1951 : 174680 : return priv->name_space->iso4217;
1952 : : }
1953 : :
1954 : : gboolean
1955 : 3887 : gnc_commodity_is_currency(const gnc_commodity *cm)
1956 : : {
1957 : : const char *ns_name;
1958 : 3887 : if (!cm) return FALSE;
1959 : :
1960 : 3884 : ns_name = gnc_commodity_namespace_get_name(GET_PRIVATE(cm)->name_space);
1961 : 7768 : return (!g_strcmp0(ns_name, GNC_COMMODITY_NS_LEGACY) ||
1962 : 7768 : !g_strcmp0(ns_name, GNC_COMMODITY_NS_CURRENCY));
1963 : : }
1964 : :
1965 : : /********************************************************************
1966 : : * gnc_commodity_table_get_commodities
1967 : : * list commodities in a given namespace
1968 : : ********************************************************************/
1969 : :
1970 : : static CommodityList*
1971 : 0 : commodity_table_get_all_noncurrency_commodities(const gnc_commodity_table* table)
1972 : : {
1973 : 0 : GList *node = nullptr, *nslist = gnc_commodity_table_get_namespaces(table);
1974 : 0 : CommodityList *retval = nullptr;
1975 : 0 : for (node = nslist; node; node=g_list_next(node))
1976 : : {
1977 : 0 : gnc_commodity_namespace *ns = nullptr;
1978 : 0 : if (g_strcmp0((char*)(node->data), GNC_COMMODITY_NS_CURRENCY) == 0
1979 : 0 : || g_strcmp0((char*)(node->data), GNC_COMMODITY_NS_TEMPLATE) == 0)
1980 : 0 : continue;
1981 : 0 : ns = gnc_commodity_table_find_namespace(table, (char*)(node->data));
1982 : 0 : if (!ns)
1983 : 0 : continue;
1984 : 0 : retval = g_list_concat(g_hash_table_values(ns->cm_table), retval);
1985 : : }
1986 : 0 : g_list_free(nslist);
1987 : 0 : return retval;
1988 : : }
1989 : :
1990 : : CommodityList *
1991 : 240 : gnc_commodity_table_get_commodities(const gnc_commodity_table * table,
1992 : : const char * name_space)
1993 : : {
1994 : 240 : gnc_commodity_namespace * ns = nullptr;
1995 : :
1996 : 240 : if (!table)
1997 : 0 : return nullptr;
1998 : 240 : if (g_strcmp0(name_space, GNC_COMMODITY_NS_NONISO_GUI) == 0)
1999 : 0 : return commodity_table_get_all_noncurrency_commodities(table);
2000 : 240 : ns = gnc_commodity_table_find_namespace(table, name_space);
2001 : 240 : if (!ns)
2002 : 0 : return nullptr;
2003 : :
2004 : 240 : return g_hash_table_values(ns->cm_table);
2005 : : }
2006 : :
2007 : : /********************************************************************
2008 : : * gnc_commodity_table_get_quotable_commodities
2009 : : * list commodities in a given namespace that get price quotes
2010 : : ********************************************************************/
2011 : :
2012 : : static void
2013 : 0 : get_quotables_helper1(gpointer key, gpointer value, gpointer data)
2014 : : {
2015 : 0 : auto comm = GNC_COMMODITY(value);
2016 : 0 : gnc_commodityPrivate* priv = GET_PRIVATE(comm);
2017 : 0 : auto l = static_cast<GList**>(data);
2018 : :
2019 : 0 : if (!priv->quote_flag || !priv->quote_source || !priv->quote_source->get_supported())
2020 : 0 : return;
2021 : 0 : *l = g_list_prepend(*l, value);
2022 : : }
2023 : :
2024 : : static gboolean
2025 : 0 : get_quotables_helper2 (gnc_commodity *comm, gpointer data)
2026 : : {
2027 : 0 : auto l = static_cast<GList**>(data);
2028 : 0 : gnc_commodityPrivate* priv = GET_PRIVATE(comm);
2029 : :
2030 : 0 : if (!priv->quote_flag || priv->quote_source || !priv->quote_source->get_supported())
2031 : 0 : return TRUE;
2032 : 0 : *l = g_list_prepend(*l, comm);
2033 : 0 : return TRUE;
2034 : : }
2035 : :
2036 : : CommodityList *
2037 : 0 : gnc_commodity_table_get_quotable_commodities(const gnc_commodity_table * table)
2038 : : {
2039 : 0 : gnc_commodity_namespace * ns = nullptr;
2040 : : const char *name_space;
2041 : : GList * nslist, * tmp;
2042 : 0 : GList * l = nullptr;
2043 : : regex_t pattern;
2044 : 0 : const char *expression = gnc_prefs_get_namespace_regexp();
2045 : :
2046 : 0 : ENTER("table=%p, expression=%s", table, expression);
2047 : 0 : if (!table)
2048 : 0 : return nullptr;
2049 : :
2050 : 0 : if (expression && *expression)
2051 : : {
2052 : 0 : if (regcomp(&pattern, expression, REG_EXTENDED | REG_ICASE) != 0)
2053 : : {
2054 : 0 : LEAVE("Cannot compile regex");
2055 : 0 : return nullptr;
2056 : : }
2057 : :
2058 : 0 : nslist = gnc_commodity_table_get_namespaces(table);
2059 : 0 : for (tmp = nslist; tmp; tmp = tmp->next)
2060 : : {
2061 : 0 : name_space = static_cast<const char*>(tmp->data);
2062 : 0 : if (regexec(&pattern, name_space, 0, nullptr, 0) == 0)
2063 : : {
2064 : 0 : DEBUG("Running list of %s commodities", name_space);
2065 : 0 : ns = gnc_commodity_table_find_namespace(table, name_space);
2066 : 0 : if (ns)
2067 : : {
2068 : 0 : g_hash_table_foreach(ns->cm_table, &get_quotables_helper1, (gpointer) &l);
2069 : : }
2070 : : }
2071 : : }
2072 : 0 : g_list_free(nslist);
2073 : 0 : regfree(&pattern);
2074 : : }
2075 : : else
2076 : : {
2077 : 0 : gnc_commodity_table_foreach_commodity(table, get_quotables_helper2,
2078 : : (gpointer) &l);
2079 : : }
2080 : 0 : LEAVE("list head %p", l);
2081 : 0 : return l;
2082 : : }
2083 : :
2084 : : /********************************************************************
2085 : : * gnc_commodity_table_add_namespace
2086 : : * add an empty namespace if it does not exist
2087 : : ********************************************************************/
2088 : :
2089 : : /* GObject Initialization */
2090 : 2292 : QOF_GOBJECT_IMPL(gnc_commodity_namespace, gnc_commodity_namespace, QOF_TYPE_INSTANCE)
2091 : :
2092 : : static void
2093 : 913 : gnc_commodity_namespace_init(gnc_commodity_namespace* ns)
2094 : : {
2095 : 913 : }
2096 : :
2097 : : static void
2098 : 564 : gnc_commodity_namespace_dispose_real (GObject *nsp)
2099 : : {
2100 : 564 : }
2101 : :
2102 : : static void
2103 : 564 : gnc_commodity_namespace_finalize_real(GObject* nsp)
2104 : : {
2105 : 564 : }
2106 : :
2107 : : gnc_commodity_namespace *
2108 : 129921 : gnc_commodity_table_add_namespace(gnc_commodity_table * table,
2109 : : const char * name_space,
2110 : : QofBook *book)
2111 : : {
2112 : 129921 : gnc_commodity_namespace * ns = nullptr;
2113 : :
2114 : 129921 : if (!table) return nullptr;
2115 : :
2116 : 129589 : name_space = gnc_commodity_table_map_namespace(name_space);
2117 : 129589 : ns = gnc_commodity_table_find_namespace(table, name_space);
2118 : 129589 : if (!ns)
2119 : : {
2120 : 913 : ns = static_cast<gnc_commodity_namespace*>(g_object_new(GNC_TYPE_COMMODITY_NAMESPACE, nullptr));
2121 : 913 : ns->cm_table = g_hash_table_new(g_str_hash, g_str_equal);
2122 : 913 : ns->name = CACHE_INSERT(static_cast<const char*>(name_space));
2123 : 913 : ns->iso4217 = gnc_commodity_namespace_is_iso(name_space);
2124 : 913 : qof_instance_init_data (&ns->inst, GNC_ID_COMMODITY_NAMESPACE, book);
2125 : 913 : qof_event_gen (&ns->inst, QOF_EVENT_CREATE, nullptr);
2126 : :
2127 : 913 : g_hash_table_insert(table->ns_table,
2128 : 913 : (gpointer) ns->name,
2129 : : (gpointer) ns);
2130 : 913 : table->ns_list = g_list_append(table->ns_list, ns);
2131 : 913 : qof_event_gen (&ns->inst, QOF_EVENT_ADD, nullptr);
2132 : : }
2133 : 129589 : return ns;
2134 : : }
2135 : :
2136 : :
2137 : : gnc_commodity_namespace *
2138 : 208778 : gnc_commodity_table_find_namespace(const gnc_commodity_table * table,
2139 : : const char * name_space)
2140 : : {
2141 : 208778 : if (!table || !name_space)
2142 : 0 : return nullptr;
2143 : :
2144 : 208778 : name_space = gnc_commodity_table_map_namespace(name_space);
2145 : 208778 : return static_cast<gnc_commodity_namespace*>(g_hash_table_lookup(table->ns_table, (gpointer)name_space));
2146 : : }
2147 : :
2148 : :
2149 : : gnc_commodity *
2150 : 38 : gnc_commodity_find_commodity_by_guid(const GncGUID *guid, QofBook *book)
2151 : : {
2152 : : QofCollection *col;
2153 : 38 : if (!guid || !book) return nullptr;
2154 : 38 : col = qof_book_get_collection (book, GNC_ID_COMMODITY);
2155 : 38 : return (gnc_commodity *) qof_collection_lookup_entity (col, guid);
2156 : : }
2157 : :
2158 : : /********************************************************************
2159 : : * gnc_commodity_table_delete_namespace
2160 : : * delete a namespace
2161 : : ********************************************************************/
2162 : :
2163 : : static int
2164 : 38141 : ns_helper(gpointer key, gpointer value, gpointer user_data)
2165 : : {
2166 : 38141 : auto c = GNC_COMMODITY(value);
2167 : 38141 : gnc_commodity_destroy(c);
2168 : 38141 : CACHE_REMOVE(static_cast<char*>(key)); /* key is commodity mnemonic */
2169 : 38141 : return TRUE;
2170 : : }
2171 : :
2172 : : void
2173 : 564 : gnc_commodity_table_delete_namespace(gnc_commodity_table * table,
2174 : : const char * name_space)
2175 : : {
2176 : : gnc_commodity_namespace * ns;
2177 : :
2178 : 564 : if (!table) return;
2179 : :
2180 : 564 : ns = gnc_commodity_table_find_namespace(table, name_space);
2181 : 564 : if (!ns)
2182 : 0 : return;
2183 : :
2184 : 564 : qof_event_gen (&ns->inst, QOF_EVENT_REMOVE, nullptr);
2185 : 564 : g_hash_table_remove(table->ns_table, name_space);
2186 : 564 : table->ns_list = g_list_remove(table->ns_list, ns);
2187 : :
2188 : 564 : g_list_free(ns->cm_list);
2189 : 564 : ns->cm_list = nullptr;
2190 : :
2191 : 564 : g_hash_table_foreach_remove(ns->cm_table, ns_helper, nullptr);
2192 : 564 : g_hash_table_destroy(ns->cm_table);
2193 : 564 : CACHE_REMOVE(ns->name);
2194 : :
2195 : 564 : qof_event_gen (&ns->inst, QOF_EVENT_DESTROY, nullptr);
2196 : : /* qof_instance_release(&ns->inst); */
2197 : 564 : g_object_unref(ns);
2198 : : }
2199 : :
2200 : : /********************************************************************
2201 : : * gnc_commodity_table_foreach_commodity
2202 : : * call user-defined function once for every commodity in every
2203 : : * namespace
2204 : : ********************************************************************/
2205 : :
2206 : : typedef struct
2207 : : {
2208 : : gboolean ok;
2209 : : gboolean (*func)(gnc_commodity *, gpointer);
2210 : : gpointer user_data;
2211 : : } IterData;
2212 : :
2213 : : static void
2214 : 5100 : iter_commodity (gpointer key, gpointer value, gpointer user_data)
2215 : : {
2216 : 5100 : IterData *iter_data = (IterData *) user_data;
2217 : 5100 : gnc_commodity *cm = (gnc_commodity *) value;
2218 : :
2219 : 5100 : if (iter_data->ok)
2220 : : {
2221 : 5100 : iter_data->ok = (iter_data->func)(cm, iter_data->user_data);
2222 : : }
2223 : 5100 : }
2224 : :
2225 : : static void
2226 : 67 : iter_namespace (gpointer key, gpointer value, gpointer user_data)
2227 : : {
2228 : 67 : GHashTable *namespace_hash = ((gnc_commodity_namespace *) value)->cm_table;
2229 : 67 : g_hash_table_foreach (namespace_hash, iter_commodity, user_data);
2230 : 67 : }
2231 : :
2232 : : gboolean
2233 : 26 : gnc_commodity_table_foreach_commodity (const gnc_commodity_table * tbl,
2234 : : gboolean (*f)(gnc_commodity *, gpointer),
2235 : : gpointer user_data)
2236 : : {
2237 : : IterData iter_data;
2238 : :
2239 : 26 : if (!tbl || !f) return FALSE;
2240 : :
2241 : 26 : iter_data.ok = TRUE;
2242 : 26 : iter_data.func = f;
2243 : 26 : iter_data.user_data = user_data;
2244 : :
2245 : 26 : g_hash_table_foreach(tbl->ns_table, iter_namespace, (gpointer)&iter_data);
2246 : :
2247 : 26 : return iter_data.ok;
2248 : : }
2249 : :
2250 : : /********************************************************************
2251 : : * gnc_commodity_table_destroy
2252 : : * cleanup and free.
2253 : : ********************************************************************/
2254 : :
2255 : : void
2256 : 188 : gnc_commodity_table_destroy(gnc_commodity_table * t)
2257 : : {
2258 : : gnc_commodity_namespace * ns;
2259 : : GList *item, *next;
2260 : :
2261 : 188 : if (!t) return;
2262 : 188 : ENTER ("table=%p", t);
2263 : :
2264 : 752 : for (item = t->ns_list; item; item = next)
2265 : : {
2266 : 564 : next = g_list_next(item);
2267 : 564 : ns = static_cast<gnc_commodity_namespace*>(item->data);
2268 : 564 : gnc_commodity_table_delete_namespace(t, ns->name);
2269 : : }
2270 : :
2271 : 188 : g_list_free(t->ns_list);
2272 : 188 : t->ns_list = nullptr;
2273 : 188 : g_hash_table_destroy(t->ns_table);
2274 : 188 : t->ns_table = nullptr;
2275 : 188 : LEAVE ("table=%p", t);
2276 : 188 : g_free(t);
2277 : : }
2278 : :
2279 : : /* =========================================================== */
2280 : :
2281 : : /********************************************************************
2282 : : * gnc_commodity_table_add_default_data
2283 : : ********************************************************************/
2284 : :
2285 : : #define CUR_I18N(String) dgettext ("iso_4217", String)
2286 : :
2287 : : gboolean
2288 : 268 : gnc_commodity_table_add_default_data(gnc_commodity_table *table, QofBook *book)
2289 : : {
2290 : : QofCollection *col;
2291 : : gnc_commodity* c;
2292 : :
2293 : 268 : ENTER ("table=%p", table);
2294 : 268 : gnc_commodity_table_add_namespace(table, GNC_COMMODITY_NS_TEMPLATE, book);
2295 : 268 : c = gnc_commodity_new(book, "template", GNC_COMMODITY_NS_TEMPLATE, "template", "template", 1);
2296 : 268 : gnc_commodity_table_insert(table, c);
2297 : :
2298 : : #include "iso-4217-currencies.c"
2299 : :
2300 : : /* We've just created the default namespaces and currencies. Mark
2301 : : * these collections as clean because there is no USER entered data
2302 : : * in these collections as of yet. */
2303 : 268 : col = qof_book_get_collection(book, GNC_ID_COMMODITY);
2304 : 268 : qof_collection_mark_clean(col);
2305 : 268 : col = qof_book_get_collection(book, GNC_ID_COMMODITY_NAMESPACE);
2306 : 268 : qof_collection_mark_clean(col);
2307 : :
2308 : 268 : LEAVE ("table=%p", table);
2309 : 268 : return TRUE;
2310 : : }
2311 : :
2312 : : /********************************************************************
2313 : : ********************************************************************/
2314 : : /* QofObject function implementation and registration */
2315 : :
2316 : : #ifdef _MSC_VER
2317 : : /* MSVC compiler doesn't have C99 "designated initializers"
2318 : : * so we wrap them in a macro that is empty on MSVC. */
2319 : : # define DI(x) /* */
2320 : : #else
2321 : : # define DI(x) x
2322 : : #endif
2323 : : static QofObject commodity_object_def =
2324 : : {
2325 : : DI(.interface_version = ) QOF_OBJECT_VERSION,
2326 : : DI(.e_type = ) GNC_ID_COMMODITY,
2327 : : DI(.type_label = ) "Commodity",
2328 : : DI(.create = ) nullptr,
2329 : : DI(.book_begin = ) nullptr,
2330 : : DI(.book_end = ) nullptr,
2331 : : DI(.is_dirty = ) qof_collection_is_dirty,
2332 : : DI(.mark_clean = ) qof_collection_mark_clean,
2333 : : DI(.foreach = ) qof_collection_foreach,
2334 : : DI(.printable = ) (const char * (*)(gpointer)) gnc_commodity_get_fullname,
2335 : : };
2336 : :
2337 : : static QofObject namespace_object_def =
2338 : : {
2339 : : DI(.interface_version = ) QOF_OBJECT_VERSION,
2340 : : DI(.e_type = ) GNC_ID_COMMODITY_NAMESPACE,
2341 : : DI(.type_label = ) "Namespace",
2342 : : DI(.create = ) nullptr,
2343 : : DI(.book_begin = ) nullptr,
2344 : : DI(.book_end = ) nullptr,
2345 : : DI(.is_dirty = ) nullptr,
2346 : : DI(.mark_clean = ) nullptr,
2347 : : DI(.foreach = ) nullptr,
2348 : : DI(.printable = ) nullptr,
2349 : : };
2350 : :
2351 : : static void
2352 : 279 : commodity_table_book_begin (QofBook *book)
2353 : : {
2354 : : gnc_commodity_table *ct;
2355 : 279 : ENTER ("book=%p", book);
2356 : :
2357 : 279 : if (gnc_commodity_table_get_table(book))
2358 : 15 : return;
2359 : :
2360 : 264 : ct = gnc_commodity_table_new ();
2361 : 264 : qof_book_set_data (book, GNC_COMMODITY_TABLE, ct);
2362 : :
2363 : 264 : if (!gnc_commodity_table_add_default_data(ct, book))
2364 : : {
2365 : 0 : PWARN("unable to initialize book's commodity_table");
2366 : : }
2367 : :
2368 : 264 : LEAVE ("book=%p", book);
2369 : : }
2370 : :
2371 : : static void
2372 : 175 : commodity_table_book_end (QofBook *book)
2373 : : {
2374 : : gnc_commodity_table *ct;
2375 : :
2376 : 175 : ct = gnc_commodity_table_get_table (book);
2377 : 175 : qof_book_set_data (book, GNC_COMMODITY_TABLE, nullptr);
2378 : 175 : gnc_commodity_table_destroy (ct);
2379 : 175 : }
2380 : :
2381 : : static QofObject commodity_table_object_def =
2382 : : {
2383 : : DI(.interface_version = ) QOF_OBJECT_VERSION,
2384 : : DI(.e_type = ) GNC_ID_COMMODITY_TABLE,
2385 : : DI(.type_label = ) "CommodityTable",
2386 : : DI(.create = ) nullptr,
2387 : : DI(.book_begin = ) commodity_table_book_begin,
2388 : : DI(.book_end = ) commodity_table_book_end,
2389 : : DI(.is_dirty = ) qof_collection_is_dirty,
2390 : : DI(.mark_clean = ) qof_collection_mark_clean,
2391 : : DI(.foreach = ) nullptr,
2392 : : DI(.printable = ) nullptr,
2393 : : DI(.version_cmp = ) nullptr,
2394 : : };
2395 : :
2396 : : gboolean
2397 : 100 : gnc_commodity_table_register (void)
2398 : : {
2399 : 100 : if (!qof_object_register (&commodity_object_def))
2400 : 1 : return FALSE;
2401 : 99 : if (!qof_object_register (&namespace_object_def))
2402 : 0 : return FALSE;
2403 : 99 : return qof_object_register (&commodity_table_object_def);
2404 : : }
2405 : :
2406 : : /* *******************************************************************
2407 : : * gnc_monetary methods
2408 : : ********************************************************************/
2409 : :
2410 : : /** Add a gnc_monetary to the list */
2411 : : MonetaryList *
2412 : 44 : gnc_monetary_list_add_monetary(MonetaryList *list, gnc_monetary add_mon)
2413 : : {
2414 : 44 : MonetaryList *l = list, *tmp;
2415 : 70 : for (tmp = list; tmp; tmp = tmp->next)
2416 : : {
2417 : 49 : auto list_mon = static_cast<gnc_monetary*>(tmp->data);
2418 : 49 : if (gnc_commodity_equiv(list_mon->commodity, add_mon.commodity))
2419 : : {
2420 : 23 : list_mon->value = gnc_numeric_add(list_mon->value, add_mon.value,
2421 : : GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
2422 : 23 : break;
2423 : : }
2424 : : }
2425 : :
2426 : : /* See if we found an entry, and add one if not */
2427 : 44 : if (tmp == nullptr)
2428 : : {
2429 : 21 : auto new_mon = static_cast<gnc_monetary*>(g_new0(gnc_monetary, 1));
2430 : 21 : *new_mon = add_mon;
2431 : 21 : l = g_list_prepend(l, new_mon);
2432 : : }
2433 : :
2434 : 44 : return l;
2435 : : }
2436 : :
2437 : : /** Delete all entries in the list that have zero value. Return list
2438 : : pointer will be a null pointer if there are no non-zero entries **/
2439 : : MonetaryList *
2440 : 12 : gnc_monetary_list_delete_zeros(MonetaryList *list)
2441 : : {
2442 : : MonetaryList *node, *next;
2443 : 33 : for (node = list; node; node = next)
2444 : : {
2445 : 21 : auto mon = static_cast<gnc_monetary*>(node->data);
2446 : 21 : next = node->next;
2447 : 21 : if (gnc_numeric_zero_p(mon->value))
2448 : : {
2449 : 10 : g_free(mon);
2450 : 10 : list = g_list_delete_link(list, node);
2451 : : }
2452 : : }
2453 : 12 : return list;
2454 : : }
2455 : :
2456 : : /** Free a MonetaryList and all the monetaries it points to */
2457 : : void
2458 : 11 : gnc_monetary_list_free(MonetaryList *list)
2459 : : {
2460 : : MonetaryList *tmp;
2461 : 22 : for (tmp = list; tmp; tmp = tmp->next)
2462 : : {
2463 : 11 : g_free(tmp->data);
2464 : : }
2465 : :
2466 : 11 : g_list_free(list);
2467 : 11 : }
2468 : :
2469 : : /* ========================= END OF FILE ============================== */
|
