[engine.i] convert gnc_account_accumulate_at_dates to c++

traversal of account->splits through std::vector instead of scm_list

Author: christopherlam

bindings/engine.i

@@ -66,6 +66,9 @@ using AccountVec = std::vector<Account*>;
 SplitsVec gnc_get_match_commodity_splits (AccountVec accounts, bool use_end_date,
                                           time64 end_date, gnc_commodity *comm, bool sort);
 
+SCM gnc_account_accumulate_at_dates (const Account *acc, SCM dates, SCM last_result,
+                                     SCM split_to_date, SCM split_to_elt);
+
 AccountVec gnc_accounts_and_all_descendants (AccountVec accounts);
 
 extern "C"
@@ -160,6 +163,58 @@ SplitsVec gnc_get_match_commodity_splits (AccountVec accounts, bool use_end_date
     return rv;
 }
 
+SCM
+gnc_account_accumulate_at_dates (const Account *acc, SCM dates, SCM last_result,
+                                 SCM split_to_date, SCM split_to_elt)
+{
+    std::function<SCM(Split*)> get_date;
+    if (scm_is_false (split_to_date))
+        get_date = [&](auto s){ return scm_from_int64 (xaccTransGetDate (xaccSplitGetParent (s))); };
+    else
+        get_date = [&](auto s){ return scm_call_1 (split_to_date, gnc_split_to_scm (s)); };
+
+    // because the guile < function understands +inf.0
+    auto less_scm = [&](SCM a, SCM b){ return scm_is_true (scm_less_p (a, b)); };
+
+    // make a copy of splits vector
+    auto splits{xaccAccountGetSplits (acc)};
+    if (!scm_is_false (split_to_date))
+        std::sort (splits.begin(), splits.end(),
+                   [&](auto a, auto b){ return less_scm (get_date (a), get_date (b)); });
+
+    SCM rv = SCM_EOL;
+    for (auto splits_it = splits.begin(); !scm_is_null (dates); )
+    {
+        auto after_date = [&](auto s){ return less_scm (scm_car (dates), get_date (s)); };
+        auto get_result = [&]() { return scm_call_1 (split_to_elt, gnc_split_to_scm (*splits_it)); };
+        if (splits_it == splits.end())
+        {
+            rv = scm_cons (last_result, rv);
+            dates = scm_cdr (dates);
+        }
+        else if (auto nx_it = std::next (splits_it); nx_it != splits.end() && !after_date (*nx_it))
+        {
+            last_result = get_result();
+            splits_it++;
+        }
+        else if (after_date (*splits_it))
+        {
+            rv = scm_cons (last_result, rv);
+            dates = scm_cdr (dates);
+        }
+        else
+        {
+            last_result = get_result();
+            rv = scm_cons (last_result, rv);
+            dates = scm_cdr (dates);
+            splits_it++;
+        }
+    }
+
+    return scm_reverse (rv);
+}
+
+
 using AccountSet = std::unordered_set<Account*>;
 static void maybe_add_descendants (Account* acc, AccountSet* accset)
 {

gnucash/report/report-utilities.scm

@@ -472,41 +472,7 @@
           (nosplit->elt #f)
           (split->date #f)
           (split->elt xaccSplitGetBalance))
-  (define to-date (or split->date (compose xaccTransGetDate xaccSplitGetParent)))
-  (define (less? a b) (< (to-date a) (to-date b)))
-
-  (let lp ((splits (if split->date
-                       (sort (xaccAccountGetSplits acc) less?)
-                       (xaccAccountGetSplits acc)))
-           (dates (sort dates <))
-           (result '())
-           (last-result nosplit->elt))
-    (match dates
-
-      ;; end of dates. job done!
-      (() (reverse result))
-
-      ((date . rest)
-       (define (before-date? s) (<= (to-date s) date))
-       (define (after-date? s) (< date (to-date s)))
-       (cond
-
-        ;; end of splits, but still has dates. pad with last-result
-        ;; until end of dates.
-        ((null? splits) (lp '() rest (cons last-result result) last-result))
-
-        ;; the next split is still before date.
-        ((and (pair? (cdr splits)) (before-date? (cadr splits)))
-         (lp (cdr splits) dates result (split->elt (car splits))))
-
-        ;; head split after date, accumulate previous result
-        ((after-date? (car splits))
-         (lp splits rest (cons last-result result) last-result))
-
-        ;; head split before date, next split after date, or end.
-        (else
-         (let ((head-result (split->elt (car splits))))
-           (lp (cdr splits) rest (cons head-result result) head-result))))))))
+  (gnc-account-accumulate-at-dates acc dates nosplit->elt split->date split->elt))
 
 ;; This works similar as above but returns a commodity-collector,
 ;; thus takes care of children accounts with different currencies.