Branch data Line data Source code
1 : : /********************************************************************\
2 : : * gnc-option.cpp -- Application options system *
3 : : * Copyright (C) 2020 John Ralls <jralls@ceridwen.us> *
4 : : * *
5 : : * This program is free software; you can redistribute it and/or *
6 : : * modify it under the terms of the GNU General Public License as *
7 : : * published by the Free Software Foundation; either version 2 of *
8 : : * the License, or (at your option) any later version. *
9 : : * *
10 : : * This program is distributed in the hope that it will be useful, *
11 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 : : * GNU General Public License for more details. *
14 : : * *
15 : : * You should have received a copy of the GNU General Public License*
16 : : * along with this program; if not, contact: *
17 : : * *
18 : : * Free Software Foundation Voice: +1-617-542-5942 *
19 : : * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
20 : : * Boston, MA 02110-1301, USA gnu@gnu.org *
21 : : * *
22 : : \********************************************************************/
23 : :
24 : : #include "gnc-option.hpp"
25 : : #include "gnc-option-impl.hpp"
26 : : #include "gnc-option-uitype.hpp"
27 : : #include "gnc-option-ui.hpp"
28 : : #include "gncOwner.h"
29 : : #include "kvp-value.hpp"
30 : :
31 : : static const char* log_module{"gnc.engine.gnc-option"};
32 : :
33 : : #include "qoflog.h"
34 : :
35 : : template <typename ValueType,
36 : : typename std::enable_if_t<!is_OptionClassifier_v<ValueType>,
37 : : int>>
38 : 48338 : GncOption::GncOption(const char* section, const char* name,
39 : : const char* key, const char* doc_string,
40 : : ValueType value, GncOptionUIType ui_type) :
41 : 48338 : m_option{std::make_unique<GncOptionVariant>(
42 : : std::in_place_type<GncOptionValue<ValueType>>,
43 : 48338 : section, name, key, doc_string, value, ui_type)}
44 : : {
45 : 48338 : }
46 : :
47 : : template <typename ValueType> ValueType
48 : 80 : GncOption::get_value() const
49 : : {
50 : 48 : return std::visit(
51 : 160 : [](const auto& option)->ValueType {
52 : : if constexpr (is_same_decayed_v<decltype(option.get_value()),
53 : : ValueType>)
54 : 0 : return option.get_value();
55 : : if constexpr (is_same_decayed_v<decltype(option),
56 : : GncOptionDateValue>)
57 : : {
58 : : if constexpr (is_same_decayed_v<ValueType,
59 : : RelativeDatePeriod>)
60 : 8 : return option.get_period();
61 : : if constexpr (std::is_same_v<ValueType, time64>)
62 : : return option.get_value();
63 : : if constexpr (std::is_same_v<ValueType, uint16_t>)
64 : 4 : return option.get_period_index();
65 : 0 : return ValueType{};
66 : : }
67 : : if constexpr (is_same_decayed_v<decltype(option),
68 : : GncOptionMultichoiceValue>)
69 : : {
70 : : if constexpr (std::is_same_v<ValueType, uint16_t>)
71 : 2 : return option.get_index();
72 : : if constexpr (is_same_decayed_v<ValueType,
73 : : GncMultichoiceOptionIndexVec>)
74 : 2 : return option.get_multiple();
75 : : }
76 : 0 : return ValueType {};
77 : 208 : }, *m_option);
78 : : }
79 : :
80 : : template <typename ValueType> ValueType
81 : 7 : GncOption::get_default_value() const
82 : : {
83 : 4 : return std::visit(
84 : 14 : [](const auto& option)->ValueType {
85 : : if constexpr (is_same_decayed_v<decltype(option.get_value()),
86 : : ValueType>)
87 : 0 : return option.get_default_value();
88 : : if constexpr (is_same_decayed_v<decltype(option),
89 : : GncOptionDateValue>)
90 : : {
91 : : if constexpr (is_same_decayed_v<ValueType,
92 : : RelativeDatePeriod>)
93 : 0 : return option.get_default_period();
94 : : if constexpr (std::is_same_v<ValueType, time64>)
95 : : return option.get_value();
96 : : if constexpr (std::is_same_v<ValueType, uint16_t>)
97 : : return option.get_default_period_index();
98 : 0 : return ValueType{};
99 : : }
100 : : if constexpr
101 : : (is_same_decayed_v<decltype(option),
102 : : GncOptionMultichoiceValue> &&
103 : : is_same_decayed_v<ValueType,
104 : : GncMultichoiceOptionIndexVec>)
105 : 0 : return option.get_default_multiple();
106 : 0 : return ValueType {};
107 : 18 : }, *m_option);
108 : :
109 : : }
110 : :
111 : : template <typename ValueType> void
112 : 45 : GncOption::set_value(ValueType value)
113 : : {
114 : 45 : std::visit(
115 : 140 : [value](auto& option) {
116 : : if constexpr
117 : : (is_same_decayed_v<decltype(option.get_value()), ValueType> ||
118 : : is_same_decayed_v<decltype(option), GncOptionDateFormat> ||
119 : : (is_same_decayed_v<decltype(option),
120 : : GncOptionDateValue> &&
121 : : (is_same_decayed_v<ValueType, RelativeDatePeriod> ||
122 : : std::is_same_v<ValueType, time64> ||
123 : : std::is_same_v<ValueType, uint16_t>)))
124 : 42 : option.set_value(value);
125 : : else if constexpr (is_same_decayed_v<decltype(option),
126 : : GncOptionMultichoiceValue>)
127 : : {
128 : : if constexpr (is_same_decayed_v<ValueType,
129 : : GncMultichoiceOptionIndexVec>)
130 : 2 : option.set_multiple(value);
131 : : else if constexpr
132 : : (std::is_same_v<ValueType, uint16_t> ||
133 : : is_same_decayed_v<ValueType, std::string> ||
134 : : std::is_same_v<std::remove_cv<ValueType>, char*>)
135 : 0 : option.set_value(value);
136 : : }
137 : : else
138 : 0 : PWARN("No set_value handler: get_value returns %s, value_type is %s",
139 : : typeid(option.get_value()).name(), typeid(value).name());
140 : 45 : }, *m_option);
141 : 40 : }
142 : :
143 : : template <typename ValueType> void
144 : 3 : GncOption::set_default_value(ValueType value)
145 : : {
146 : 3 : std::visit(
147 : 9 : [value](auto& option) {
148 : : if constexpr
149 : : (is_same_decayed_v<decltype(option.get_value()), ValueType>||
150 : : is_same_decayed_v<decltype(option), GncOptionDateFormat> ||
151 : : (is_same_decayed_v<decltype(option), GncOptionDateValue> &&
152 : : (is_same_decayed_v<ValueType, RelativeDatePeriod> ||
153 : : std::is_same_v<ValueType, time64> ||
154 : : std::is_same_v<ValueType, uint16_t>)))
155 : 3 : option.set_default_value(value);
156 : : if constexpr (is_same_decayed_v<decltype(option),
157 : : GncOptionMultichoiceValue>)
158 : : {
159 : : if constexpr (is_same_decayed_v<ValueType,
160 : : GncMultichoiceOptionIndexVec>)
161 : 0 : option.set_default_multiple(value);
162 : : else if constexpr
163 : : (std::is_same_v<ValueType, uint16_t> ||
164 : : is_same_decayed_v<ValueType, std::string> ||
165 : : std::is_same_v<std::remove_cv<ValueType>, char*>)
166 : 0 : option.set_default_value(value);
167 : : }
168 : 3 : }, *m_option);
169 : 3 : }
170 : : void
171 : 0 : GncOption::reset_default_value()
172 : : {
173 : 0 : std::visit([](auto& option) { option.reset_default_value(); }, *m_option);
174 : 0 : }
175 : :
176 : : template <typename ValueType> void
177 : 2 : GncOption::get_limits(ValueType& max, ValueType& min, ValueType& step) const noexcept
178 : : {
179 : 6 : std::visit([&max, &min, &step](const auto& option) {
180 : : if constexpr
181 : : (is_same_decayed_v<decltype(option),
182 : : GncOptionRangeValue<ValueType>>)
183 : 2 : option.get_limits(max, min, step);
184 : 2 : }, *m_option);
185 : 2 : }
186 : :
187 : : const std::string&
188 : 51779 : GncOption::get_section() const
189 : : {
190 : 155337 : return std::visit([](const auto& option)->const std::string& {
191 : 51779 : return option.m_section;
192 : 155337 : }, *m_option);
193 : : }
194 : :
195 : : const std::string&
196 : 883779 : GncOption::get_name() const
197 : : {
198 : 2651337 : return std::visit([](const auto& option)->const std::string& {
199 : 883779 : return option.m_name;
200 : 2651337 : }, *m_option);
201 : : }
202 : :
203 : : const std::string&
204 : 2599685 : GncOption::get_key() const
205 : : {
206 : 7799055 : return std::visit([](const auto& option)->const std::string& {
207 : 2599685 : return option.m_sort_tag;
208 : 7799055 : }, *m_option);
209 : : }
210 : :
211 : : const std::string&
212 : 1 : GncOption::get_docstring() const
213 : : {
214 : 3 : return std::visit([](const auto& option)->const std::string& {
215 : 1 : return option.m_doc_string;
216 : 3 : }, *m_option);
217 : : }
218 : :
219 : : void
220 : 3 : GncOption::set_ui_item(GncOptionUIItemPtr&& ui_item)
221 : : {
222 : :
223 : 6 : auto opt_ui_type = std::visit([](const auto& option)->GncOptionUIType {
224 : 3 : return option.get_ui_type();
225 : 3 : }, *m_option);
226 : :
227 : : //ui_item may be nullptr to free the old m_ui_item.
228 : 3 : if (ui_item && ui_item->get_ui_type() != opt_ui_type)
229 : : {
230 : 0 : PERR("Setting option %s:%s UI element failed, mismatched UI types.",
231 : : get_section().c_str(), get_name().c_str());
232 : 0 : return;
233 : : }
234 : :
235 : 3 : m_ui_item = std::move(ui_item);
236 : : }
237 : :
238 : : void
239 : 0 : GncOption::set_ui_item_selectable(bool selectable) const noexcept
240 : : {
241 : 0 : if (m_ui_item)
242 : 0 : m_ui_item->set_selectable(selectable);
243 : 0 : }
244 : :
245 : : const GncOptionUIType
246 : 37 : GncOption::get_ui_type() const
247 : : {
248 : 111 : return std::visit([](const auto& option)->GncOptionUIType {
249 : 37 : return option.get_ui_type();
250 : 111 : }, *m_option);
251 : : }
252 : :
253 : : GncOptionUIItem* const
254 : 2 : GncOption::get_ui_item() const
255 : : {
256 : 2 : return m_ui_item.get();
257 : : }
258 : :
259 : : void
260 : 1 : GncOption::set_ui_item_from_option()
261 : : {
262 : 1 : if (!m_ui_item)
263 : 0 : return;
264 : 1 : m_ui_item->set_ui_item_from_option(*this);
265 : : }
266 : :
267 : : void
268 : 1 : GncOption::set_option_from_ui_item()
269 : : {
270 : 1 : if (!m_ui_item)
271 : 0 : return;
272 : 1 : m_ui_item->set_option_from_ui_item(*this);
273 : : }
274 : :
275 : : void
276 : 82 : GncOption::make_internal()
277 : : {
278 : 82 : if (m_ui_item)
279 : : {
280 : 0 : PERR("Option %s:%s has a UI Element, can't be INTERNAL.",
281 : : get_section().c_str(), get_name().c_str());
282 : 0 : return;
283 : : }
284 : 164 : std::visit([](auto& option) {
285 : 82 : option.make_internal();
286 : 164 : }, *m_option);
287 : : }
288 : :
289 : : bool
290 : 3466 : GncOption::is_internal()
291 : : {
292 : 10398 : return std::visit([](auto& option)->bool {
293 : 3466 : return option.is_internal();
294 : 10398 : }, *m_option);
295 : : }
296 : :
297 : : void
298 : 1 : GncOption::mark_saved() noexcept
299 : : {
300 : 2 : std::visit([](auto& option)->void {
301 : 1 : option.mark_saved();
302 : 2 : }, *m_option);
303 : 1 : }
304 : :
305 : : bool
306 : 12 : GncOption::is_dirty() const noexcept
307 : : {
308 : 36 : return std::visit([](const auto& option)->bool {
309 : 12 : return option.is_dirty();
310 : 24 : }, *m_option);
311 : : }
312 : :
313 : : bool
314 : 10503 : GncOption::is_changed() const noexcept
315 : : {
316 : 31509 : return std::visit([](const auto& option)->bool {
317 : 10503 : return option.is_changed();
318 : 21006 : }, *m_option);
319 : : }
320 : :
321 : : bool
322 : 0 : GncOption::is_multiselect() const noexcept
323 : : {
324 : 0 : return std::visit(
325 : 0 : [](const auto& option)->bool {
326 : : if constexpr (is_same_decayed_v<decltype(option),
327 : : GncOptionAccountListValue>)
328 : 0 : return option.is_multiselect();
329 : : else
330 : 0 : return false;
331 : 0 : }, *m_option);
332 : : }
333 : :
334 : : template<typename ValueType> bool
335 : 7 : GncOption::validate(ValueType value) const
336 : : {
337 : 9 : return std::visit(
338 : 21 : [value] (const auto& option) -> bool {
339 : : if constexpr ((is_same_decayed_v<decltype(option),
340 : : GncOptionMultichoiceValue> &&
341 : : is_same_decayed_v<ValueType, std::string>) ||
342 : : (is_same_decayed_v<decltype(option),
343 : : GncOptionMultichoiceValue> &&
344 : : is_same_decayed_v<ValueType,
345 : : GncMultichoiceOptionIndexVec>) ||
346 : : (is_same_decayed_v<decltype(option),
347 : : GncOptionCommodityValue> &&
348 : : is_same_decayed_v<ValueType, gnc_commodity*>))
349 : 7 : return option.validate(value);
350 : : else
351 : 0 : return false;
352 : 21 : }, *m_option);
353 : : }
354 : :
355 : : std::uint16_t
356 : 476 : GncOption::num_permissible_values() const
357 : : {
358 : 476 : return std::visit(
359 : 952 : [] (const auto& option) -> uint16_t {
360 : : if constexpr (is_same_decayed_v<decltype(option),
361 : : GncOptionMultichoiceValue> ||
362 : : is_same_decayed_v<decltype(option),
363 : : GncOptionDateValue>)
364 : 476 : return option.num_permissible_values();
365 : : else
366 : 0 : return uint16_t_max;
367 : 1428 : }, *m_option);
368 : : }
369 : :
370 : : std::uint16_t
371 : 2 : GncOption::permissible_value_index(const char* value) const
372 : : {
373 : 4 : return std::visit(
374 : 6 : [&value] (const auto& option) -> uint16_t {
375 : : if constexpr (is_same_decayed_v<decltype(option),
376 : : GncOptionMultichoiceValue> ||
377 : : is_same_decayed_v<decltype(option),
378 : : GncOptionDateValue>)
379 : 2 : return option.permissible_value_index(value);
380 : : else
381 : 0 : return uint16_t_max;
382 : 6 : }, *m_option);
383 : : }
384 : :
385 : : const char*
386 : 1113 : GncOption::permissible_value(std::uint16_t index) const
387 : : {
388 : 3338 : return std::visit([index] (const auto& option) -> const char* {
389 : : if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
390 : : GncOptionMultichoiceValue> ||
391 : : std::is_same_v<std::decay_t<decltype(option)>,
392 : : GncOptionDateValue>)
393 : 1113 : return option.permissible_value(index);
394 : : else
395 : 0 : return "";
396 : 3337 : }, *m_option);
397 : : }
398 : :
399 : : const char*
400 : 2 : GncOption::permissible_value_name(std::uint16_t index) const
401 : : {
402 : 5 : return std::visit([index] (const auto& option) -> const char* {
403 : : if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
404 : : GncOptionMultichoiceValue> ||
405 : : std::is_same_v<std::decay_t<decltype(option)>,
406 : : GncOptionDateValue>)
407 : 2 : return option.permissible_value_name(index);
408 : : else
409 : 0 : return "";
410 : 4 : }, *m_option);
411 : : }
412 : :
413 : : GList*
414 : 0 : GncOption::account_type_list() const noexcept
415 : : {
416 : 0 : return std::visit([] (const auto& option) -> GList* {
417 : : if constexpr (std::is_same_v<std::decay_t<decltype(option)>,
418 : : GncOptionAccountListValue>)
419 : 0 : return option.account_type_list();
420 : : else
421 : 0 : return nullptr;
422 : 0 : }, *m_option);
423 : : }
424 : :
425 : : bool
426 : 0 : GncOption::is_alternate() const noexcept
427 : : {
428 : 0 : return std::visit([](auto& option) -> bool {
429 : : if constexpr(is_RangeValue_v<decltype(option)>)
430 : 0 : return option.is_alternate();
431 : 0 : return false;
432 : 0 : }, *m_option);
433 : : }
434 : :
435 : : void
436 : 0 : GncOption::set_alternate(bool alt) noexcept
437 : : {
438 : 0 : std::visit([alt](auto& option) {
439 : : if constexpr(is_RangeValue_v<decltype(option)>)
440 : 0 : option.set_alternate(alt);
441 : 0 : }, *m_option);
442 : 0 : }
443 : :
444 : : std::string
445 : 46 : GncOption::serialize() const
446 : : {
447 : 46 : if (m_option->valueless_by_exception())
448 : 0 : return "Valueless Option";
449 : 92 : return std::visit([&](auto& option) -> std::string {
450 : 46 : return option.serialize();
451 : 46 : }, *m_option);
452 : : }
453 : :
454 : : bool
455 : 0 : GncOption::deserialize(const std::string& str)
456 : : {
457 : 0 : return std::visit([&str](auto& option) -> bool {
458 : 0 : return option.deserialize(str);
459 : 0 : }, *m_option);
460 : : }
461 : :
462 : : std::istream&
463 : 33 : GncOption::in_stream(std::istream& iss)
464 : : {
465 : 94 : return std::visit([&iss](auto& option) -> std::istream& {
466 : 33 : iss >> option;
467 : 28 : return iss;
468 : 89 : }, *m_option);
469 : : }
470 : :
471 : : /* We must instantiate all of the templates we need here because we don't expose
472 : : * the template implementation in the public header.
473 : : */
474 : :
475 : :
476 : : template GncOption::GncOption(const char*, const char*, const char*,
477 : : const char*, bool, GncOptionUIType);
478 : : //template GncOption::GncOption(const char*, const char*, const char*,
479 : : // const char*, int, GncOptionUIType);
480 : : template GncOption::GncOption(const char*, const char*, const char*,
481 : : const char*, int64_t, GncOptionUIType);
482 : : //template GncOption::GncOption(const char*, const char*, const char*,
483 : : // const char*, const char*, GncOptionUIType);
484 : : //template GncOption::GncOption(const char*, const char*, const char*,
485 : : // const char*, double, GncOptionUIType);
486 : : template GncOption::GncOption(const char*, const char*, const char*,
487 : : const char*, std::string, GncOptionUIType);
488 : : template GncOption::GncOption(const char*, const char*, const char*,
489 : : const char*, const QofQuery*, GncOptionUIType);
490 : :
491 : : template GncOption::GncOption(const char *, const char*, const char*,
492 : : const char *, GncOptionDateFormat,
493 : : GncOptionUIType);
494 : :
495 : : template bool GncOption::get_value<bool>() const;
496 : : template int GncOption::get_value<int>() const;
497 : : template int64_t GncOption::get_value<int64_t>() const;
498 : : template double GncOption::get_value<double>() const;
499 : : template uint16_t GncOption::get_value<uint16_t>() const;
500 : : template const char* GncOption::get_value<const char*>() const;
501 : : template std::string GncOption::get_value<std::string>() const;
502 : : template const QofInstance* GncOption::get_value<const QofInstance*>() const;
503 : : template const GncOwner* GncOption::get_value<const GncOwner*>() const;
504 : : template gnc_commodity* GncOption::get_value<gnc_commodity*>() const;
505 : : template const Account* GncOption::get_value<const Account*>() const;
506 : : template RelativeDatePeriod GncOption::get_value<RelativeDatePeriod>() const;
507 : : template GncOptionAccountList GncOption::get_value<GncOptionAccountList>() const;
508 : : template GncMultichoiceOptionIndexVec GncOption::get_value<GncMultichoiceOptionIndexVec>() const;
509 : : template GncOptionReportPlacementVec GncOption::get_value<GncOptionReportPlacementVec>() const;
510 : : template GncOptionDateFormat GncOption::get_value<GncOptionDateFormat>() const;
511 : :
512 : : template bool GncOption::get_default_value<bool>() const;
513 : : template int GncOption::get_default_value<int>() const;
514 : : template int64_t GncOption::get_default_value<int64_t>() const;
515 : : template double GncOption::get_default_value<double>() const;
516 : : template const char* GncOption::get_default_value<const char*>() const;
517 : : template std::string GncOption::get_default_value<std::string>() const;
518 : : template const QofInstance* GncOption::get_default_value<const QofInstance*>() const;
519 : : template gnc_commodity* GncOption::get_default_value<gnc_commodity*>() const;
520 : : template const Account* GncOption::get_default_value<const Account*>() const;
521 : : template RelativeDatePeriod GncOption::get_default_value<RelativeDatePeriod>() const;
522 : : template GncOptionAccountList GncOption::get_default_value<GncOptionAccountList>() const;
523 : : template GncMultichoiceOptionIndexVec GncOption::get_default_value<GncMultichoiceOptionIndexVec>() const;
524 : : template GncOptionReportPlacementVec GncOption::get_default_value<GncOptionReportPlacementVec>() const;
525 : : template GncOptionDateFormat GncOption::get_default_value<GncOptionDateFormat>() const;
526 : :
527 : : template void GncOption::set_value(bool);
528 : : template void GncOption::set_value(int);
529 : : template void GncOption::set_value(int64_t);
530 : : template void GncOption::set_value(double);
531 : : template void GncOption::set_value(char*);
532 : : template void GncOption::set_value(const char*);
533 : : template void GncOption::set_value(std::string);
534 : : template void GncOption::set_value(const QofInstance*);
535 : : template void GncOption::set_value(const GncOwner*);
536 : : template void GncOption::set_value(gnc_commodity*);
537 : : template void GncOption::set_value(const Account*);
538 : : template void GncOption::set_value(RelativeDatePeriod);
539 : : template void GncOption::set_value(uint16_t);
540 : : template void GncOption::set_value(GncOptionAccountList);
541 : : template void GncOption::set_value(GncMultichoiceOptionIndexVec);
542 : : template void GncOption::set_value(GncOptionReportPlacementVec);
543 : : template void GncOption::set_value(GncOptionDateFormat);
544 : :
545 : : template void GncOption::set_default_value(bool);
546 : : template void GncOption::set_default_value(int);
547 : : template void GncOption::set_default_value(int64_t);
548 : : template void GncOption::set_default_value(double);
549 : : template void GncOption::set_default_value(char*);
550 : : template void GncOption::set_default_value(const char*);
551 : : template void GncOption::set_default_value(std::string);
552 : : template void GncOption::set_default_value(const QofInstance*);
553 : : template void GncOption::set_default_value(const Account*);
554 : : template void GncOption::set_default_value(RelativeDatePeriod);
555 : : template void GncOption::set_default_value(uint16_t);
556 : : template void GncOption::set_default_value(GncOptionAccountList);
557 : : template void GncOption::set_default_value(GncMultichoiceOptionIndexVec);
558 : : template void GncOption::set_default_value(GncOptionReportPlacementVec);
559 : : template void GncOption::set_default_value(GncOptionDateFormat);
560 : :
561 : : template void GncOption::get_limits(double&, double&, double&) const noexcept;
562 : : template void GncOption::get_limits(int&, int&, int&) const noexcept;
563 : : template bool GncOption::validate(bool) const;
564 : : template bool GncOption::validate(int) const;
565 : : template bool GncOption::validate(int64_t) const;
566 : : template bool GncOption::validate(double) const;
567 : : template bool GncOption::validate(const char*) const;
568 : : template bool GncOption::validate(std::string) const;
569 : : template bool GncOption::validate(const QofInstance*) const;
570 : : template bool GncOption::validate(gnc_commodity*) const;
571 : : template bool GncOption::validate(const Account*) const;
572 : : template bool GncOption::validate(const QofQuery*) const;
573 : : template bool GncOption::validate(RelativeDatePeriod) const;
574 : : template bool GncOption::validate(GncMultichoiceOptionIndexVec) const;
575 : : template bool GncOption::validate(GncOptionReportPlacementVec) const;
576 : : template bool GncOption::validate(GncOptionDateFormat) const;
577 : :
578 : : template GncOption* gnc_make_option<const std::string&>(const char*,
579 : : const char*,
580 : : const char*,
581 : : const char*,
582 : : const std::string&,
583 : : GncOptionUIType);
584 : : template GncOption* gnc_make_option<bool>(const char*, const char*, const char*,
585 : : const char*, bool, GncOptionUIType);
586 : : template GncOption* gnc_make_option<int64_t>(const char*, const char*,
587 : : const char*, const char*, int64_t,
588 : : GncOptionUIType);
|
