1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#ifndef _CONSTRAINT_H
#define _CONSTRAINT_H
#include "ledger.h"
#include "expr.h"
#include "item.h"
template <typename ForwardIterator, typename ValueType, typename Constraint>
class constrained_iterator
{
ForwardIterator iter, end;
const Constraint& constraint;
constrained_iterator& operator=(const constrained_iterator&);
public:
constrained_iterator(ForwardIterator begin, ForwardIterator _end,
const Constraint& _constraint)
: iter(begin), end(_end), constraint(_constraint) {
skip_nonmatching();
}
constrained_iterator(const constrained_iterator& other)
: iter(other.iter), end(other.end), constraint(other.constraint) {}
constrained_iterator operator++() const {
ForwardIterator temp = iter;
temp++;
return constrained_iterator(temp, end);
}
constrained_iterator& operator++(int) {
iter++;
skip_nonmatching();
return *this;
}
bool operator==(ForwardIterator other) const {
return iter == other;
}
bool operator!=(ForwardIterator other) const {
return ! (*this == other);
}
ValueType operator*() const {
return *iter;
}
void skip_nonmatching() {
bool failed;
do {
if (iter == end) return;
failed = false;
if (! constraint(*iter)) {
failed = true;
iter++;
}
} while (failed);
}
};
namespace ledger {
class constraints_t
{
public:
bool show_expanded;
bool show_related;
bool show_inverted;
bool show_subtotals;
bool show_empty;
node_t * predicate;
explicit constraints_t() {
show_expanded = false;
show_related = false;
show_inverted = false;
show_subtotals = true;
show_empty = false;
predicate = NULL;
}
~constraints_t() {
if (predicate) delete predicate;
}
bool operator ()(const transaction_t * xact) const {
if (! predicate) {
return true;
} else {
item_t temp;
temp.date = xact->entry->date;
temp.payee = xact->entry->payee;
temp.account = xact->account;
return predicate->compute(&temp);
}
}
bool operator ()(const entry_t * entry) const {
if (! predicate) {
return true;
} else {
item_t temp;
temp.date = entry->date;
temp.payee = entry->payee;
// Although there may be conflicting account masks for the whole
// set of transactions -- for example, /rent/&!/expenses/, which
// might match one by not another transactions -- we let the
// entry through if at least one of the transactions meets the
// criterion
for (transactions_list::const_iterator i = entry->transactions.begin();
i != entry->transactions.end();
i++) {
temp.account = (*i)->account;
if (predicate->compute(&temp))
return true;
}
return false;
}
}
bool operator ()(const item_t * item) const {
return ! predicate || predicate->compute(item);
}
};
typedef constrained_iterator<transactions_list::const_iterator, transaction_t *,
constraints_t>
constrained_transactions_list_const_iterator;
typedef constrained_iterator<transactions_list::iterator, transaction_t *,
constraints_t>
constrained_transactions_list_iterator;
typedef constrained_iterator<entries_list::const_iterator, entry_t *,
constraints_t>
constrained_entries_list_const_iterator;
typedef constrained_iterator<entries_list::iterator, entry_t *,
constraints_t>
constrained_entries_list_iterator;
typedef constrained_iterator<items_deque::const_iterator, item_t *,
constraints_t>
constrained_items_deque_const_iterator;
typedef constrained_iterator<items_deque::iterator, item_t *,
constraints_t>
constrained_items_deque_iterator;
} // namespace ledger
#endif // _CONSTRAINT_H
|
