1 files changed, 79 insertions, 66 deletions

diff --git a/src/iterators.h b/src/iterators.h
index 5113d3b2..93782400 100644
--- a/src/iterators.h
+++ b/src/iterators.h
@@ -51,14 +51,35 @@ namespace ledger {
 
 class journal_t;
 
-class posts_iterator : public noncopyable
+template <typename Derived, typename Value, typename CategoryOrTraversal>
+class iterator_facade_base
+  : public boost::iterator_facade<Derived, Value, CategoryOrTraversal>
 {
+  typedef Value node_base;
+
 public:
-  virtual ~posts_iterator() throw() {}
-  virtual post_t * operator()() = 0;
+  iterator_facade_base() : m_node(NULL) {}
+
+  explicit iterator_facade_base(node_base p) : m_node(p) {}
+
+  void increment();
+
+private:
+  friend class boost::iterator_core_access;
+
+  bool equal(iterator_facade_base const& other) const {
+    return this->m_node == other.m_node;
+  }
+
+  node_base& dereference() const { return const_cast<node_base&>(m_node); }
+
+protected:
+  node_base m_node;
 };
 
-class xact_posts_iterator : public posts_iterator
+class xact_posts_iterator
+  : public iterator_facade_base<xact_posts_iterator, post_t *,
+                                boost::forward_traversal_tag>
 {
   posts_list::iterator posts_i;
   posts_list::iterator posts_end;
@@ -66,33 +87,33 @@ class xact_posts_iterator : public posts_iterator
   bool posts_uninitialized;
 
 public:
-  xact_posts_iterator() : posts_uninitialized(true) {
-    TRACE_CTOR(xact_posts_iterator, "");
-  }
+  xact_posts_iterator() : posts_uninitialized(true) {}
   xact_posts_iterator(xact_t& xact)
     : posts_uninitialized(true) {
-    TRACE_CTOR(xact_posts_iterator, "xact_t&");
     reset(xact);
   }
-  virtual ~xact_posts_iterator() throw() {
-    TRACE_DTOR(xact_posts_iterator);
-  }
+  ~xact_posts_iterator() throw() {}
 
   void reset(xact_t& xact) {
     posts_i   = xact.posts.begin();
     posts_end = xact.posts.end();
 
     posts_uninitialized = false;
+
+    increment();
   }
 
-  virtual post_t * operator()() {
+  void increment() {
     if (posts_uninitialized || posts_i == posts_end)
-      return NULL;
-    return *posts_i++;
+      m_node = NULL;
+    else
+      m_node = *posts_i++;
   }
 };
 
-class xacts_iterator : public noncopyable
+class xacts_iterator
+  : public iterator_facade_base<xacts_iterator, xact_t *,
+                                boost::forward_traversal_tag>
 {
 public:
   xacts_list::iterator xacts_i;
@@ -100,45 +121,49 @@ public:
 
   bool xacts_uninitialized;
 
-  xacts_iterator() : xacts_uninitialized(true) {
-    TRACE_CTOR(xacts_iterator, "");
-  }
-  xacts_iterator(journal_t& journal) : xacts_uninitialized(true) {
-    TRACE_CTOR(xacts_iterator, "journal_t&");
+  xacts_iterator() : xacts_uninitialized(true) {}
+  xacts_iterator(journal_t& journal) : xacts_uninitialized(false) {
     reset(journal);
   }
-  virtual ~xacts_iterator() throw() {
-    TRACE_DTOR(xacts_iterator);
+  xacts_iterator(xacts_list::iterator beg,
+                 xacts_list::iterator end) : xacts_uninitialized(false) {
+    reset(beg, end);
   }
+  ~xacts_iterator() throw() {}
 
   void reset(journal_t& journal);
 
-  xact_t * operator()();
+  void reset(xacts_list::iterator beg, xacts_list::iterator end) {
+    xacts_i   = beg;
+    xacts_end = end;
+    increment();
+  }
+
+  void increment();
 };
 
-class journal_posts_iterator : public posts_iterator
+class journal_posts_iterator
+  : public iterator_facade_base<journal_posts_iterator, post_t *,
+                                boost::forward_traversal_tag>
 {
-  xacts_iterator     xacts;
+  xacts_iterator      xacts;
   xact_posts_iterator posts;
 
 public:
-  journal_posts_iterator() {
-    TRACE_CTOR(journal_posts_iterator, "");
-  }
+  journal_posts_iterator() {}
   journal_posts_iterator(journal_t& journal) {
-    TRACE_CTOR(journal_posts_iterator, "journal_t&");
     reset(journal);
   }
-  virtual ~journal_posts_iterator() throw() {
-    TRACE_DTOR(journal_posts_iterator);
-  }
+  ~journal_posts_iterator() throw() {}
 
   void reset(journal_t& journal);
 
-  virtual post_t * operator()();
+  void increment();
 };
 
-class posts_commodities_iterator : public posts_iterator
+class posts_commodities_iterator
+  : public iterator_facade_base<posts_commodities_iterator, post_t *,
+                                boost::forward_traversal_tag>
 {
 protected:
   journal_posts_iterator  journal_posts;
@@ -148,55 +173,44 @@ protected:
   xacts_list              xact_temps;
 
 public:
-  posts_commodities_iterator() {
-    TRACE_CTOR(posts_commodities_iterator, "");
-  }
+  posts_commodities_iterator() {}
   posts_commodities_iterator(journal_t& journal) {
-    TRACE_CTOR(posts_commodities_iterator, "journal_t&");
     reset(journal);
   }
-  virtual ~posts_commodities_iterator() throw() {
-    TRACE_DTOR(posts_commodities_iterator);
-  }
+  ~posts_commodities_iterator() throw() {}
 
   void reset(journal_t& journal);
 
-  virtual post_t * operator()();
-};
-
-class accounts_iterator : public noncopyable
-{
-public:
-  virtual ~accounts_iterator() throw() {}
-  virtual account_t * operator()() = 0;
+  void increment();
 };
 
-class basic_accounts_iterator : public accounts_iterator
+class basic_accounts_iterator
+  : public iterator_facade_base<basic_accounts_iterator, account_t *,
+                                boost::forward_traversal_tag>
 {
   std::list<accounts_map::const_iterator> accounts_i;
   std::list<accounts_map::const_iterator> accounts_end;
 
 public:
-  basic_accounts_iterator() {
-    TRACE_CTOR(basic_accounts_iterator, "");
-  }
+  basic_accounts_iterator() {}
   basic_accounts_iterator(account_t& account) {
-    TRACE_CTOR(basic_accounts_iterator, "account_t&");
     push_back(account);
+    increment();
   }
-  virtual ~basic_accounts_iterator() throw() {
-    TRACE_DTOR(basic_accounts_iterator);
-  }
+  ~basic_accounts_iterator() throw() {}
 
+  void increment();
+
+private:
   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 accounts_iterator
+class sorted_accounts_iterator
+  : public iterator_facade_base<sorted_accounts_iterator, account_t *,
+                                boost::forward_traversal_tag>
 {
   expr_t sort_cmp;
   bool   flatten_all;
@@ -211,18 +225,17 @@ public:
   sorted_accounts_iterator(account_t& account,
                            const expr_t& _sort_cmp, bool _flatten_all)
     : sort_cmp(_sort_cmp), flatten_all(_flatten_all) {
-    TRACE_CTOR(sorted_accounts_iterator, "const expr_t&, bool, account_t&");
     push_back(account);
+    increment();
   }
-  virtual ~sorted_accounts_iterator() throw() {
-    TRACE_DTOR(sorted_accounts_iterator);
-  }
+  ~sorted_accounts_iterator() throw() {}
+
+  void increment();
 
+private:
   void push_back(account_t& account);
   void push_all(account_t& account, accounts_deque_t& deque);
   void sort_accounts(account_t& account, accounts_deque_t& deque);
-
-  virtual account_t * operator()();
 };
 
 } // namespace ledger