Moved around most of the files so that source code is in src/, documentation

is in doc/, etc.

1 files changed, 116 insertions, 0 deletions

diff --git a/src/reconcile.cc b/src/reconcile.cc
new file mode 100644
index 00000000..aca1732e
--- /dev/null
+++ b/src/reconcile.cc
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2003-2008, John Wiegley.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of New Artisans LLC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "reconcile.h"
+
+namespace ledger {
+
+#define xact_next(x)     reinterpret_cast<xact_t *>(x->xdata().ptr)
+#define xact_next_ptr(x) reinterpret_cast<xact_t **>(&x->xdata().ptr)
+
+static bool search_for_balance(amount_t& amount,
+			       xact_t ** prev, xact_t * next)
+{
+  for (; next; next = xact_next(next)) {
+    xact_t * temp = *prev;
+    *prev = next;
+
+    amount -= next->amount;
+    if (! amount ||
+	search_for_balance(amount, xact_next_ptr(next), xact_next(next)))
+      return true;
+    amount += next->amount;
+
+    *prev = temp;
+  }
+  return false;
+}
+
+void reconcile_xacts::push_to_handler(xact_t * first)
+{
+  for (; first; first = xact_next(first))
+    item_handler<xact_t>::operator()(*first);
+
+  item_handler<xact_t>::flush();
+}
+
+void reconcile_xacts::flush()
+{
+  value_t cleared_balance;
+  value_t pending_balance;
+
+  xact_t *  first    = NULL;
+  xact_t ** last_ptr = &first;
+
+  foreach (xact_t * xact, xacts) {
+    if (! is_valid(cutoff) || xact->date() < cutoff) {
+      switch (xact->state) {
+      case xact_t::CLEARED:
+	cleared_balance += xact->amount;
+	break;
+      case xact_t::UNCLEARED:
+      case xact_t::PENDING:
+	pending_balance += xact->amount;
+	*last_ptr = xact;
+	last_ptr = xact_next_ptr(xact);
+	break;
+      }
+    }
+  }
+
+  if (cleared_balance.type() >= value_t::BALANCE)
+    throw std::runtime_error("Cannot reconcile accounts with multiple commodities");
+
+  cleared_balance.cast(value_t::AMOUNT);
+  balance.cast(value_t::AMOUNT);
+
+  commodity_t& cb_comm = cleared_balance.as_amount().commodity();
+  commodity_t& b_comm  = balance.as_amount().commodity();
+
+  balance -= cleared_balance;
+  if (balance.type() >= value_t::BALANCE)
+    throw_(std::runtime_error,
+	   "Reconcile balance is not of the same commodity ('"
+	   << b_comm.symbol() << "' != '" << cb_comm.symbol() << "')");
+
+  // If the amount to reconcile is the same as the pending balance,
+  // then assume an exact match and return the results right away.
+  amount_t& to_reconcile(balance.as_amount_lval());
+  pending_balance.cast(value_t::AMOUNT);
+  if (to_reconcile == pending_balance.as_amount() ||
+      search_for_balance(to_reconcile, &first, first)) {
+    push_to_handler(first);
+  } else {
+    throw std::runtime_error("Could not reconcile account!");
+  }
+}
+
+} // namespace ledger