diff options
Diffstat (limited to 'walk.h')
| -rw-r--r-- | walk.h | 717 |
1 files changed, 524 insertions, 193 deletions
@@ -2,48 +2,53 @@ #define _WALK_H #include "journal.h" -#include "balance.h" -#include "valexpr.h" -#include "datetime.h" - -#include <iostream> -#include <fstream> -#include <deque> namespace ledger { template <typename T> -struct item_handler { - item_handler * handler; +struct item_handler : public noncopyable +{ + shared_ptr<item_handler> handler; - public: - item_handler() : handler(NULL) { - DEBUG_PRINT("ledger.memory.ctors", "ctor item_handler<T>"); +public: + item_handler() { + TRACE_CTOR(item_handler, ""); } - item_handler(item_handler * _handler) : handler(_handler) { - DEBUG_PRINT("ledger.memory.ctors", "ctor item_handler<T>"); + item_handler(shared_ptr<item_handler> _handler) : handler(_handler) { + TRACE_CTOR(item_handler, "shared_ptr<item_handler>"); } virtual ~item_handler() { - DEBUG_PRINT("ledger.memory.dtors", "dtor item_handler<T>"); + TRACE_DTOR(item_handler); } virtual void flush() { - if (handler) + if (handler.get()) handler->flush(); } virtual void operator()(T& item) { - if (handler) - (*handler)(item); + if (handler.get()) + (*handler.get())(item); } }; +typedef shared_ptr<item_handler<transaction_t> > xact_handler_ptr; + template <typename T> -class compare_items { - const value_expr_t * sort_order; - public: - compare_items(const value_expr_t * _sort_order) - : sort_order(_sort_order) { - assert(sort_order); +class compare_items +{ + value_expr sort_order; + + compare_items(); + +public: + compare_items(const compare_items& other) : sort_order(other.sort_order) { + TRACE_CTOR(compare_items, "copy"); + } + compare_items(const value_expr& _sort_order) : sort_order(_sort_order) { + TRACE_CTOR(compare_items, "const value_expr&"); + } + ~compare_items() throw() { + TRACE_DTOR(compare_items); } bool operator()(const T * left, const T * right); }; @@ -56,8 +61,8 @@ bool compare_items<T>::operator()(const T * left, const T * right) value_t left_result; value_t right_result; - guarded_compute(sort_order, left_result, details_t(*left)); - guarded_compute(sort_order, right_result, details_t(*right)); + sort_order.compute(left_result, details_t(*left)); + sort_order.compute(right_result, details_t(*right)); return left_result < right_result; } @@ -83,7 +88,7 @@ bool compare_items<account_t>::operator()(const account_t * left, #define TRANSACTION_COMPOUND 0x0040 #define TRANSACTION_MATCHES 0x0080 -struct transaction_xdata_t +struct transaction_xdata_t : public noncopyable { value_t total; value_t sort_value; @@ -99,13 +104,12 @@ struct transaction_xdata_t transaction_xdata_t() : index(0), dflags(0), account(NULL), ptr(NULL), component_xacts(NULL) { - DEBUG_PRINT("ledger.memory.ctors", "ctor transaction_xdata_t " << this); + TRACE_CTOR(transaction_xdata_t, ""); } - ~transaction_xdata_t() { - DEBUG_PRINT("ledger.memory.dtors", "dtor transaction_xdata_t " << this); + TRACE_DTOR(transaction_xdata_t); if (component_xacts) - delete component_xacts; + checked_delete(component_xacts); } void remember_xact(transaction_t& xact) { @@ -159,49 +163,137 @@ inline const account_t * xact_account(const transaction_t& xact) { ////////////////////////////////////////////////////////////////////// -inline void walk_transactions(transactions_list::iterator begin, - transactions_list::iterator end, - item_handler<transaction_t>& handler) { - for (transactions_list::iterator i = begin; i != end; i++) - handler(**i); -} +class entries_iterator : public noncopyable +{ + ptr_list<journal_t>::iterator journals_i; + ptr_list<journal_t>::iterator journals_end; -inline void walk_transactions(transactions_list& list, - item_handler<transaction_t>& handler) { - walk_transactions(list.begin(), list.end(), handler); -} + bool journals_uninitialized; -inline void walk_entries(entries_list::iterator begin, - entries_list::iterator end, - item_handler<transaction_t>& handler) { - for (entries_list::iterator i = begin; i != end; i++) - walk_transactions((*i)->transactions, handler); -} + entries_list::iterator entries_i; + entries_list::iterator entries_end; -inline void walk_entries(entries_list& list, - item_handler<transaction_t>& handler) { - walk_entries(list.begin(), list.end(), handler); -} + bool entries_uninitialized; + +public: + entries_iterator() + : journals_uninitialized(true), entries_uninitialized(true) { + TRACE_CTOR(entries_iterator, ""); + } + entries_iterator(session_t& session) + : journals_uninitialized(true), entries_uninitialized(true) { + TRACE_CTOR(entries_iterator, "session_t&"); + reset(session); + } + ~entries_iterator() throw() { + TRACE_DTOR(entries_iterator); + } + + void reset(session_t& session); + + entry_t * operator()(); +}; + +class transactions_iterator : public noncopyable +{ +public: + virtual transaction_t * operator()() = 0; +}; + +class entry_transactions_iterator : public transactions_iterator +{ + transactions_list::iterator xacts_i; + transactions_list::iterator xacts_end; + + bool xacts_uninitialized; + +public: + entry_transactions_iterator() : xacts_uninitialized(true) { + TRACE_CTOR(entry_transactions_iterator, ""); + } + entry_transactions_iterator(entry_t& entry) + : xacts_uninitialized(true) { + TRACE_CTOR(entry_transactions_iterator, "entry_t&"); + reset(entry); + } + virtual ~entry_transactions_iterator() throw() { + TRACE_DTOR(entry_transactions_iterator); + } + + void reset(entry_t& entry) { + xacts_i = entry.transactions.begin(); + xacts_end = entry.transactions.end(); + + xacts_uninitialized = false; + } + + virtual transaction_t * operator()() { + if (xacts_i == xacts_end || xacts_uninitialized) + return NULL; + return *xacts_i++; + } +}; + +class session_transactions_iterator : public transactions_iterator +{ + entries_iterator entries; + entry_transactions_iterator xacts; + +public: + session_transactions_iterator() { + TRACE_CTOR(session_transactions_iterator, ""); + } + session_transactions_iterator(session_t& session) { + TRACE_CTOR(session_transactions_iterator, "session_t&"); + reset(session); + } + virtual ~session_transactions_iterator() throw() { + TRACE_DTOR(session_transactions_iterator); + } + + void reset(session_t& session); + + virtual transaction_t * operator()(); +}; ////////////////////////////////////////////////////////////////////// class ignore_transactions : public item_handler<transaction_t> { - public: +public: virtual void operator()(transaction_t& xact) {} }; class clear_transaction_xdata : public item_handler<transaction_t> { - public: +public: virtual void operator()(transaction_t& xact) { if (xact.data) { - delete (transaction_xdata_t *) xact.data; + checked_delete((transaction_xdata_t *) xact.data); xact.data = NULL; } } }; +class pass_down_transactions : public item_handler<transaction_t> +{ + pass_down_transactions(); + +public: + pass_down_transactions(xact_handler_ptr handler, + transactions_iterator& iter) + : item_handler<transaction_t>(handler) { + TRACE_CTOR(pass_down_transactions, + "xact_handler_ptr, transactions_iterator"); + for (transaction_t * xact = iter(); xact; xact = iter()) + item_handler<transaction_t>::operator()(*xact); + } + + virtual ~pass_down_transactions() { + TRACE_DTOR(pass_down_transactions); + } +}; + class truncate_entries : public item_handler<transaction_t> { int head_count; @@ -209,11 +301,18 @@ class truncate_entries : public item_handler<transaction_t> transactions_list xacts; - public: - truncate_entries(item_handler<transaction_t> * handler, + truncate_entries(); + +public: + truncate_entries(xact_handler_ptr handler, int _head_count, int _tail_count) : item_handler<transaction_t>(handler), - head_count(_head_count), tail_count(_tail_count) {} + head_count(_head_count), tail_count(_tail_count) { + TRACE_CTOR(truncate_entries, "xact_handler_ptr, int, int"); + } + virtual ~truncate_entries() { + TRACE_DTOR(truncate_entries); + } virtual void flush(); virtual void operator()(transaction_t& xact) { @@ -223,8 +322,8 @@ class truncate_entries : public item_handler<transaction_t> class set_account_value : public item_handler<transaction_t> { - public: - set_account_value(item_handler<transaction_t> * handler = NULL) +public: + set_account_value(xact_handler_ptr handler = xact_handler_ptr()) : item_handler<transaction_t>(handler) {} virtual void operator()(transaction_t& xact); @@ -232,11 +331,18 @@ class set_account_value : public item_handler<transaction_t> class push_to_transactions_list : public item_handler<transaction_t> { - public: + push_to_transactions_list(); + +public: transactions_list& xact_list; push_to_transactions_list(transactions_list& _xact_list) - : xact_list(_xact_list) {} + : xact_list(_xact_list) { + TRACE_CTOR(push_to_transactions_list, "transactions_list&"); + } + virtual ~push_to_transactions_list() { + TRACE_DTOR(push_to_transactions_list); + } virtual void operator()(transaction_t& xact) { xact_list.push_back(&xact); @@ -247,25 +353,28 @@ class sort_transactions : public item_handler<transaction_t> { typedef std::deque<transaction_t *> transactions_deque; - transactions_deque transactions; - const value_expr_t * sort_order; + transactions_deque transactions; + const value_expr sort_order; - public: - sort_transactions(item_handler<transaction_t> * handler, - const value_expr_t * _sort_order) - : item_handler<transaction_t>(handler), - sort_order(_sort_order->acquire()) {} + sort_transactions(); - sort_transactions(item_handler<transaction_t> * handler, - const std::string& _sort_order) - : item_handler<transaction_t>(handler) { - assert(! _sort_order.empty()); - sort_order = parse_value_expr(_sort_order)->acquire(); +public: + sort_transactions(xact_handler_ptr handler, + const value_expr& _sort_order) + : item_handler<transaction_t>(handler), + sort_order(_sort_order) { + TRACE_CTOR(sort_transactions, + "xact_handler_ptr, const value_expr&"); + } + sort_transactions(xact_handler_ptr handler, + const string& _sort_order) + : item_handler<transaction_t>(handler), + sort_order(_sort_order) { + TRACE_CTOR(sort_transactions, + "xact_handler_ptr, const string&"); } - virtual ~sort_transactions() { - assert(sort_order); - sort_order->release(); + TRACE_DTOR(sort_transactions); } virtual void post_accumulated_xacts(); @@ -283,16 +392,26 @@ class sort_transactions : public item_handler<transaction_t> class sort_entries : public item_handler<transaction_t> { sort_transactions sorter; - entry_t * last_entry; + entry_t * last_entry; - public: - sort_entries(item_handler<transaction_t> * handler, - const value_expr_t * _sort_order) - : sorter(handler, _sort_order) {} + sort_entries(); - sort_entries(item_handler<transaction_t> * handler, - const std::string& _sort_order) - : sorter(handler, _sort_order) {} +public: + sort_entries(xact_handler_ptr handler, + const value_expr& _sort_order) + : sorter(handler, _sort_order) { + TRACE_CTOR(sort_entries, + "xact_handler_ptr, const value_expr&"); + } + sort_entries(xact_handler_ptr handler, + const string& _sort_order) + : sorter(handler, _sort_order) { + TRACE_CTOR(sort_entries, + "xact_handler_ptr, const string&"); + } + virtual ~sort_entries() { + TRACE_DTOR(sort_entries); + } virtual void flush() { sorter.flush(); @@ -313,14 +432,25 @@ class filter_transactions : public item_handler<transaction_t> { item_predicate<transaction_t> pred; - public: - filter_transactions(item_handler<transaction_t> * handler, - const value_expr_t * predicate) - : item_handler<transaction_t>(handler), pred(predicate) {} + filter_transactions(); + +public: + filter_transactions(xact_handler_ptr handler, + const value_expr& predicate) + : item_handler<transaction_t>(handler), pred(predicate) { + TRACE_CTOR(filter_transactions, + "xact_handler_ptr, const value_expr&"); + } - filter_transactions(item_handler<transaction_t> * handler, - const std::string& predicate) - : item_handler<transaction_t>(handler), pred(predicate) {} + filter_transactions(xact_handler_ptr handler, + const string& predicate) + : item_handler<transaction_t>(handler), pred(predicate) { + TRACE_CTOR(filter_transactions, + "xact_handler_ptr, const string&"); + } + virtual ~filter_transactions() { + TRACE_DTOR(filter_transactions); + } virtual void operator()(transaction_t& xact) { if (pred(xact)) { @@ -334,17 +464,26 @@ class calc_transactions : public item_handler<transaction_t> { transaction_t * last_xact; - public: - calc_transactions(item_handler<transaction_t> * handler) - : item_handler<transaction_t>(handler), last_xact(NULL) {} + calc_transactions(); + +public: + calc_transactions(xact_handler_ptr handler) + : item_handler<transaction_t>(handler), last_xact(NULL) { + TRACE_CTOR(calc_transactions, "xact_handler_ptr"); + } + virtual ~calc_transactions() { + TRACE_DTOR(calc_transactions); + } virtual void operator()(transaction_t& xact); }; class invert_transactions : public item_handler<transaction_t> { - public: - invert_transactions(item_handler<transaction_t> * handler) + invert_transactions(); + +public: + invert_transactions(xact_handler_ptr handler) : item_handler<transaction_t>(handler) {} virtual void operator()(transaction_t& xact); @@ -368,13 +507,17 @@ class collapse_transactions : public item_handler<transaction_t> std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: - collapse_transactions(item_handler<transaction_t> * handler) + collapse_transactions(); + +public: + collapse_transactions(xact_handler_ptr handler) : item_handler<transaction_t>(handler), count(0), last_entry(NULL), last_xact(NULL), - totals_account(NULL, "<Total>") {} - - ~collapse_transactions() { + totals_account(NULL, "<Total>") { + TRACE_CTOR(collapse_transactions, "xact_handler_ptr"); + } + virtual ~collapse_transactions() { + TRACE_DTOR(collapse_transactions); clear_entries_transactions(entry_temps); } @@ -393,14 +536,24 @@ class component_transactions : public item_handler<transaction_t> { item_predicate<transaction_t> pred; - public: - component_transactions(item_handler<transaction_t> * handler, - const value_expr_t * predicate) - : item_handler<transaction_t>(handler), pred(predicate) {} + component_transactions(); - component_transactions(item_handler<transaction_t> * handler, - const std::string& predicate) - : item_handler<transaction_t>(handler), pred(predicate) {} +public: + component_transactions(xact_handler_ptr handler, + const value_expr& predicate) + : item_handler<transaction_t>(handler), pred(predicate) { + TRACE_CTOR(component_transactions, + "xact_handler_ptr, const value_expr&"); + } + component_transactions(xact_handler_ptr handler, + const string& predicate) + : item_handler<transaction_t>(handler), pred(predicate) { + TRACE_CTOR(component_transactions, + "xact_handler_ptr, const string&"); + } + virtual ~component_transactions() throw() { + TRACE_DTOR(component_transactions); + } virtual void operator()(transaction_t& xact); }; @@ -410,11 +563,19 @@ class related_transactions : public item_handler<transaction_t> transactions_list transactions; bool also_matching; - public: - related_transactions(item_handler<transaction_t> * handler, + related_transactions(); + +public: + related_transactions(xact_handler_ptr handler, const bool _also_matching = false) : item_handler<transaction_t>(handler), - also_matching(_also_matching) {} + also_matching(_also_matching) { + TRACE_CTOR(related_transactions, + "xact_handler_ptr, const bool"); + } + virtual ~related_transactions() throw() { + TRACE_DTOR(related_transactions); + } virtual void flush(); virtual void operator()(transaction_t& xact) { @@ -435,19 +596,24 @@ class changed_value_transactions : public item_handler<transaction_t> std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: - changed_value_transactions(item_handler<transaction_t> * handler, + changed_value_transactions(); + +public: + changed_value_transactions(xact_handler_ptr handler, bool _changed_values_only) : item_handler<transaction_t>(handler), - changed_values_only(_changed_values_only), last_xact(NULL) {} - - ~changed_value_transactions() { + changed_values_only(_changed_values_only), last_xact(NULL) { + TRACE_CTOR(changed_value_transactions, + "xact_handler_ptr, bool"); + } + virtual ~changed_value_transactions() { + TRACE_DTOR(changed_value_transactions); clear_entries_transactions(entry_temps); } virtual void flush() { if (last_xact) { - output_diff(datetime_t::now); + output_diff(current_moment); last_xact = NULL; } item_handler<transaction_t>::flush(); @@ -460,42 +626,57 @@ class changed_value_transactions : public item_handler<transaction_t> class subtotal_transactions : public item_handler<transaction_t> { - struct acct_value_t { + class acct_value_t + { + acct_value_t(); + + public: account_t * account; value_t value; transactions_list components; - acct_value_t(account_t * a) : account(a) {} - acct_value_t(account_t * a, value_t& v) : account(a), value(v) {} + acct_value_t(account_t * a) : account(a) { + TRACE_CTOR(acct_value_t, "acount_t *"); + } + acct_value_t(account_t * a, value_t& v) : account(a), value(v) { + TRACE_CTOR(acct_value_t, "acount_t *, value_t&"); + } acct_value_t(const acct_value_t& av) - : account(av.account), value(av.value) {} + : account(av.account), value(av.value), + components(av.components) { + TRACE_CTOR(acct_value_t, "copy"); + } + ~acct_value_t() throw() { + TRACE_DTOR(acct_value_t); + } }; - typedef std::map<std::string, acct_value_t> values_map; - typedef std::pair<std::string, acct_value_t> values_pair; + typedef std::map<string, acct_value_t> values_map; + typedef std::pair<string, acct_value_t> values_pair; + + subtotal_transactions(); - protected: +protected: values_map values; bool remember_components; std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: +public: datetime_t start; datetime_t finish; - subtotal_transactions(item_handler<transaction_t> * handler, + subtotal_transactions(xact_handler_ptr handler, bool _remember_components = false) : item_handler<transaction_t>(handler), - remember_components(_remember_components) {} -#ifdef DEBUG_ENABLED - subtotal_transactions(const subtotal_transactions&) { - assert(0); + remember_components(_remember_components) { + TRACE_CTOR(subtotal_transactions, + "xact_handler_ptr, bool"); } -#endif virtual ~subtotal_transactions() { + TRACE_DTOR(subtotal_transactions); clear_entries_transactions(entry_temps); } @@ -511,7 +692,7 @@ class subtotal_transactions : public item_handler<transaction_t> class interval_expr_error : public error { public: - interval_expr_error(const std::string& reason, + interval_expr_error(const string& reason, error_context * ctxt = NULL) throw() : error(reason, ctxt) {} virtual ~interval_expr_error() throw() {} @@ -523,18 +704,28 @@ class interval_transactions : public subtotal_transactions transaction_t * last_xact; bool started; - public: - interval_transactions(item_handler<transaction_t> * _handler, + interval_transactions(); + +public: + interval_transactions(xact_handler_ptr _handler, const interval_t& _interval, bool remember_components = false) : subtotal_transactions(_handler, remember_components), - interval(_interval), last_xact(NULL), started(false) {} - - interval_transactions(item_handler<transaction_t> * _handler, - const std::string& _interval, + interval(_interval), last_xact(NULL), started(false) { + TRACE_CTOR(interval_transactions, + "xact_handler_ptr, const interval_t&, bool"); + } + interval_transactions(xact_handler_ptr _handler, + const string& _interval, bool remember_components = false) : subtotal_transactions(_handler, remember_components), - interval(_interval), last_xact(NULL), started(false) {} + interval(_interval), last_xact(NULL), started(false) { + TRACE_CTOR(interval_transactions, + "xact_handler_ptr, const string&, bool"); + } + virtual ~interval_transactions() throw() { + TRACE_DTOR(interval_transactions); + } void report_subtotal(const datetime_t& moment = datetime_t()); @@ -548,17 +739,22 @@ class interval_transactions : public subtotal_transactions class by_payee_transactions : public item_handler<transaction_t> { - typedef std::map<std::string, subtotal_transactions *> payee_subtotals_map; - typedef std::pair<std::string, subtotal_transactions *> payee_subtotals_pair; + typedef std::map<string, subtotal_transactions *> payee_subtotals_map; + typedef std::pair<string, subtotal_transactions *> payee_subtotals_pair; payee_subtotals_map payee_subtotals; - bool remember_components; + bool remember_components; + + by_payee_transactions(); public: - by_payee_transactions(item_handler<transaction_t> * handler, + by_payee_transactions(xact_handler_ptr handler, bool _remember_components = false) : item_handler<transaction_t>(handler), - remember_components(_remember_components) {} + remember_components(_remember_components) { + TRACE_CTOR(by_payee_transactions, + "xact_handler_ptr, bool"); + } virtual ~by_payee_transactions(); virtual void flush(); @@ -570,11 +766,15 @@ class set_comm_as_payee : public item_handler<transaction_t> std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: - set_comm_as_payee(item_handler<transaction_t> * handler) - : item_handler<transaction_t>(handler) {} + set_comm_as_payee(); - ~set_comm_as_payee() { +public: + set_comm_as_payee(xact_handler_ptr handler) + : item_handler<transaction_t>(handler) { + TRACE_CTOR(set_comm_as_payee, "xact_handler_ptr"); + } + virtual ~set_comm_as_payee() { + TRACE_DTOR(set_comm_as_payee); clear_entries_transactions(entry_temps); } @@ -586,11 +786,15 @@ class set_code_as_payee : public item_handler<transaction_t> std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: - set_code_as_payee(item_handler<transaction_t> * handler) - : item_handler<transaction_t>(handler) {} + set_code_as_payee(); - ~set_code_as_payee() { +public: + set_code_as_payee(xact_handler_ptr handler) + : item_handler<transaction_t>(handler) { + TRACE_CTOR(set_code_as_payee, "xact_handler_ptr"); + } + virtual ~set_code_as_payee() { + TRACE_DTOR(set_code_as_payee); clear_entries_transactions(entry_temps); } @@ -601,20 +805,29 @@ class dow_transactions : public subtotal_transactions { transactions_list days_of_the_week[7]; - public: - dow_transactions(item_handler<transaction_t> * handler, + dow_transactions(); + +public: + dow_transactions(xact_handler_ptr handler, bool remember_components = false) - : subtotal_transactions(handler, remember_components) {} + : subtotal_transactions(handler, remember_components) { + TRACE_CTOR(dow_transactions, "xact_handler_ptr, bool"); + } + virtual ~dow_transactions() throw() { + TRACE_DTOR(dow_transactions); + } virtual void flush(); virtual void operator()(transaction_t& xact) { - days_of_the_week[xact.date().wday()].push_back(&xact); + days_of_the_week[xact.date().date().day_of_week()].push_back(&xact); } }; class generate_transactions : public item_handler<transaction_t> { - protected: + generate_transactions(); + +protected: typedef std::pair<interval_t, transaction_t *> pending_xacts_pair; typedef std::list<pending_xacts_pair> pending_xacts_list; @@ -622,11 +835,14 @@ class generate_transactions : public item_handler<transaction_t> std::list<entry_t> entry_temps; std::list<transaction_t> xact_temps; - public: - generate_transactions(item_handler<transaction_t> * handler) - : item_handler<transaction_t>(handler) {} +public: + generate_transactions(xact_handler_ptr handler) + : item_handler<transaction_t>(handler) { + TRACE_CTOR(dow_transactions, "xact_handler_ptr"); + } - ~generate_transactions() { + virtual ~generate_transactions() { + TRACE_DTOR(generate_transactions); clear_entries_transactions(entry_temps); } @@ -643,10 +859,18 @@ class budget_transactions : public generate_transactions { unsigned short flags; - public: - budget_transactions(item_handler<transaction_t> * handler, + budget_transactions(); + +public: + budget_transactions(xact_handler_ptr handler, unsigned long _flags = BUDGET_BUDGETED) - : generate_transactions(handler), flags(_flags) {} + : generate_transactions(handler), flags(_flags) { + TRACE_CTOR(budget_transactions, + "xact_handler_ptr, unsigned long"); + } + virtual ~budget_transactions() throw() { + TRACE_DTOR(budget_transactions); + } void report_budget_items(const datetime_t& moment); @@ -658,13 +882,19 @@ class forecast_transactions : public generate_transactions item_predicate<transaction_t> pred; public: - forecast_transactions(item_handler<transaction_t> * handler, - const value_expr_t * predicate) - : generate_transactions(handler), pred(predicate) {} - - forecast_transactions(item_handler<transaction_t> * handler, - const std::string& predicate) - : generate_transactions(handler), pred(predicate) {} + forecast_transactions(xact_handler_ptr handler, + const value_expr& predicate) + : generate_transactions(handler), pred(predicate) { + TRACE_CTOR(forecast_transactions, "xact_handler_ptr, const value_expr&"); + } + forecast_transactions(xact_handler_ptr handler, + const string& predicate) + : generate_transactions(handler), pred(predicate) { + TRACE_CTOR(forecast_transactions, "xact_handler_ptr, const string&"); + } + virtual ~forecast_transactions() throw() { + TRACE_DTOR(forecast_transactions); + } virtual void add_transaction(const interval_t& period, transaction_t& xact); @@ -683,7 +913,7 @@ class forecast_transactions : public generate_transactions #define ACCOUNT_HAS_NON_VIRTUALS 0x0008 #define ACCOUNT_HAS_UNB_VIRTUALS 0x0010 -struct account_xdata_t +struct account_xdata_t : public noncopyable { value_t value; value_t total; @@ -693,7 +923,12 @@ struct account_xdata_t unsigned int virtuals; unsigned short dflags; - account_xdata_t() : count(0), total_count(0), virtuals(0), dflags(0) {} + account_xdata_t() : count(0), total_count(0), virtuals(0), dflags(0) { + TRACE_CTOR(account_xdata_t, ""); + } + ~account_xdata_t() throw() { + TRACE_DTOR(account_xdata_t); + } }; inline bool account_has_xdata(const account_t& account) { @@ -706,45 +941,141 @@ inline account_xdata_t& account_xdata_(const account_t& account) { account_xdata_t& account_xdata(const account_t& account); +void sum_accounts(account_t& account); + ////////////////////////////////////////////////////////////////////// +class accounts_iterator : public noncopyable +{ + std::list<accounts_map::const_iterator> accounts_i; + std::list<accounts_map::const_iterator> accounts_end; + +public: + accounts_iterator() { + TRACE_CTOR(accounts_iterator, ""); + } + accounts_iterator(account_t& account) { + TRACE_CTOR(accounts_iterator, "account_t&"); + push_back(account); + } + virtual ~accounts_iterator() throw() { + TRACE_DTOR(accounts_iterator); + } + + void push_back(account_t& account) { + accounts_i.push_back(account.accounts.begin()); + accounts_end.push_back(account.accounts.end()); + } + + virtual account_t * operator()(); +}; + +class sorted_accounts_iterator : public noncopyable +{ + value_expr sort_cmp; + + typedef std::deque<account_t *> accounts_deque_t; + + std::list<accounts_deque_t> accounts_list; + std::list<accounts_deque_t::const_iterator> sorted_accounts_i; + std::list<accounts_deque_t::const_iterator> sorted_accounts_end; + +public: + sorted_accounts_iterator(const string& sort_order) { + TRACE_CTOR(sorted_accounts_iterator, "const string&"); + sort_cmp = value_expr(sort_order); + } + sorted_accounts_iterator(account_t& account, const string& sort_order) { + TRACE_CTOR(sorted_accounts_iterator, "account_t&, const string&"); + sort_cmp = value_expr(sort_order); + push_back(account); + } + virtual ~sorted_accounts_iterator() throw() { + TRACE_DTOR(sorted_accounts_iterator); + } + + void sort_accounts(account_t& account, accounts_deque_t& deque); + + void push_back(account_t& account) { + accounts_list.push_back(accounts_deque_t()); + sort_accounts(account, accounts_list.back()); + + sorted_accounts_i.push_back(accounts_list.back().begin()); + sorted_accounts_end.push_back(accounts_list.back().end()); + } + + virtual account_t * operator()(); +}; + +////////////////////////////////////////////////////////////////////// + +typedef shared_ptr<item_handler<account_t> > acct_handler_ptr; + class clear_account_xdata : public item_handler<account_t> { - public: +public: virtual void operator()(account_t& acct) { if (acct.data) { - delete (account_xdata_t *) acct.data; + checked_delete((account_xdata_t *) acct.data); acct.data = NULL; } } }; -void sum_accounts(account_t& account); - -typedef std::deque<account_t *> accounts_deque; +template <typename Iterator> +class pass_down_accounts : public item_handler<account_t> +{ + pass_down_accounts(); + +public: + pass_down_accounts(acct_handler_ptr handler, Iterator& iter) + : item_handler<account_t>(handler) { + TRACE_CTOR(pass_down_accounts, + "acct_handler_ptr, accounts_iterator"); + for (account_t * account = iter(); account; account = iter()) + item_handler<account_t>::operator()(*account); + } -void sort_accounts(account_t& account, - const value_expr_t * sort_order, - accounts_deque& accounts); -void walk_accounts(account_t& account, - item_handler<account_t>& handler, - const value_expr_t * sort_order = NULL); -void walk_accounts(account_t& account, - item_handler<account_t>& handler, - const std::string& sort_string); + virtual ~pass_down_accounts() { + TRACE_DTOR(pass_down_accounts); + } +}; ////////////////////////////////////////////////////////////////////// -void walk_commodities(commodities_map& commodities, - item_handler<transaction_t>& handler); - -inline void clear_journal_xdata(journal_t * journal) { +#if 0 +inline void clear_journal_xdata(journal_t& journal) { clear_transaction_xdata xact_cleaner; - walk_entries(journal->entries, xact_cleaner); + walk_entries(journal.entries, xact_cleaner); clear_account_xdata acct_cleaner; - walk_accounts(*journal->master, acct_cleaner); + walk_accounts(*journal.master, acct_cleaner); } +#endif + +////////////////////////////////////////////////////////////////////// + +class journals_iterator : public noncopyable +{ + ptr_list<journal_t>::iterator journals_i; + ptr_list<journal_t>::iterator journals_end; + +public: + journals_iterator() { + TRACE_CTOR(journals_iterator, ""); + } + journals_iterator(session_t& session) { + TRACE_CTOR(journals_iterator, "session_t&"); + reset(session); + } + virtual ~journals_iterator() throw() { + TRACE_DTOR(journals_iterator); + } + + void reset(session_t& session); + + virtual journal_t * operator()(); +}; } // namespace ledger |