sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

*** no comment ***

Browse source
This commit is contained in:
John Wiegley 2006-03-04 14:17:26 +00:00
parent 2034d6640c
commit 6375730fc9
6 changed files with 545 additions and 258 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
acprep
View file

@ -17,7 +17,7 @@ fi
autoconf autoconf
INCDIRS="-I/sw/include -I/usr/local/include/boost-1_33 -I/usr/include/httpd/xml" INCDIRS="-I/sw/include -I/usr/local/include/boost-1_33 -I/usr/include/httpd/xml"
INCDIRS="$INCDIRS -I/sw/include/libofx" #INCDIRS="$INCDIRS -I/sw/include/libofx"
INCDIRS="$INCDIRS -Wno-long-double" INCDIRS="$INCDIRS -Wno-long-double"
LIBDIRS="-L/sw/lib -L/usr/local/lib" LIBDIRS="-L/sw/lib -L/usr/local/lib"

12
balance.cc
View file

@ -94,8 +94,7 @@ balance_t& balance_t::operator*=(const balance_t& bal)
return *this *= (*bal.amounts.begin()).second; return *this *= (*bal.amounts.begin()).second;
} }
else { else {
std::string msg; std::ostringstream errmsg;
std::ostringstream errmsg(msg);
errmsg << "It makes no sense to multiply two balances: " errmsg << "It makes no sense to multiply two balances: "
<< *this << " * " << bal; << *this << " * " << bal;
throw amount_error(errmsg.str()); throw amount_error(errmsg.str());
@ -108,8 +107,7 @@ balance_t& balance_t::operator/=(const balance_t& bal)
return (*this = 0L); return (*this = 0L);
} }
else if (! bal) { else if (! bal) {
std::string msg; std::ostringstream errmsg;
std::ostringstream errmsg(msg);
errmsg << "Attempt to divide by zero: " << *this << " / " << bal; errmsg << "Attempt to divide by zero: " << *this << " / " << bal;
throw amount_error(errmsg.str()); throw amount_error(errmsg.str());
} }
@ -120,8 +118,7 @@ balance_t& balance_t::operator/=(const balance_t& bal)
return (*this = 1L); return (*this = 1L);
} }
else { else {
std::string msg; std::ostringstream errmsg;
std::ostringstream errmsg(msg);
errmsg << "It makes no sense to divide two balances: " errmsg << "It makes no sense to divide two balances: "
<< *this << " / " << bal; << *this << " / " << bal;
throw amount_error(errmsg.str()); throw amount_error(errmsg.str());
@ -137,8 +134,7 @@ balance_t::operator amount_t() const
return amount_t(); return amount_t();
} }
else { else {
std::string msg; std::ostringstream errmsg;
std::ostringstream errmsg(msg);
errmsg << "Cannot convert a balance with " errmsg << "Cannot convert a balance with "
<< "multiple commodities to an amount: " << *this; << "multiple commodities to an amount: " << *this;
throw amount_error(errmsg.str()); throw amount_error(errmsg.str());

15
balance.h
View file

@ -97,10 +97,14 @@ class balance_t
} }
balance_t& operator-=(const amount_t& amt) { balance_t& operator-=(const amount_t& amt) {
amounts_map::iterator i = amounts.find(&amt.commodity()); amounts_map::iterator i = amounts.find(&amt.commodity());
if (i != amounts.end()) if (i != amounts.end()) {
(*i).second -= amt; (*i).second -= amt;
else if (amt) if (! (*i).second)
amounts.erase(&amt.commodity());
}
else if (amt) {
amounts.insert(amounts_pair(&amt.commodity(), - amt)); amounts.insert(amounts_pair(&amt.commodity(), - amt));
}
return *this; return *this;
} }
template <typename T> template <typename T>
@ -147,7 +151,10 @@ class balance_t
balance_t& operator*=(const amount_t& amt) { balance_t& operator*=(const amount_t& amt) {
// Multiplying by the null commodity causes all amounts to be // Multiplying by the null commodity causes all amounts to be
// increased by the same factor. // increased by the same factor.
if (amt.commodity().symbol.empty()) { if (! amt) {
amounts.clear();
}
else if (! amt.commodity()) {
for (amounts_map::iterator i = amounts.begin(); for (amounts_map::iterator i = amounts.begin();
i != amounts.end(); i != amounts.end();
i++) i++)
@ -172,7 +179,7 @@ class balance_t
balance_t& operator/=(const amount_t& amt) { balance_t& operator/=(const amount_t& amt) {
// Dividing by the null commodity causes all amounts to be // Dividing by the null commodity causes all amounts to be
// increased by the same factor. // increased by the same factor.
if (amt.commodity().symbol.empty()) { if (! amt.commodity()) {
for (amounts_map::iterator i = amounts.begin(); for (amounts_map::iterator i = amounts.begin();
i != amounts.end(); i != amounts.end();
i++) i++)

28
derive.cc
View file

@ -2,6 +2,7 @@
#include "datetime.h" #include "datetime.h"
#include "error.h" #include "error.h"
#include "mask.h" #include "mask.h"
#include "walk.h"
#include <memory> #include <memory>
@ -47,10 +48,31 @@ entry_t * derive_new_entry(journal_t& journal,
i++; i++;
} }
if (i == end) if (i == end) {
added->add_transaction(new transaction_t(acct)); added->add_transaction(new transaction_t(acct));
else } else {
added->add_transaction(new transaction_t(acct, amount_t(*i++))); transaction_t * xact = new transaction_t(acct, amount_t(*i++));
added->add_transaction(xact);
if (! xact->amount.commodity()) {
// If the amount has no commodity, we can determine it given
// the account by creating a final for the account and then
// checking if it contains only a single commodity. An
// account to which only dollars are applied would imply that
// dollars are wanted now too.
std::auto_ptr<item_handler<transaction_t> > formatter;
formatter.reset(new set_account_value);
walk_entries(journal.entries, *formatter.get());
formatter->flush();
sum_accounts(*journal.master);
value_t total = account_xdata(*acct).total;
if (total.type == value_t::AMOUNT)
xact->amount.set_commodity(((amount_t *) total.data)->commodity());
}
}
if (journal.basket) if (journal.basket)
acct = journal.basket; acct = journal.basket;

745
value.cc
View file

@ -19,6 +19,27 @@ void value_t::destroy()
} }
} }
void value_t::simplify()
{
if (! *this) {
*this = 0L;
return;
}
if (type == BALANCE_PAIR &&
(! ((balance_pair_t *) data)->cost ||
! *((balance_pair_t *) data)->cost))
cast(BALANCE);
if (type == BALANCE &&
((balance_t *) data)->amounts.size() == 1)
cast(AMOUNT);
if (type == AMOUNT &&
! ((amount_t *) data)->commodity())
cast(INTEGER);
}
value_t& value_t::operator=(const value_t& value) value_t& value_t::operator=(const value_t& value)
{ {
if (this == &value) if (this == &value)
@ -57,253 +78,493 @@ value_t& value_t::operator=(const value_t& value)
return *this; return *this;
} }
#define DEF_VALUE_ADDSUB_OP(OP) \ value_t& value_t::operator+=(const value_t& value)
value_t& value_t::operator OP(const value_t& value) \ {
{ \ switch (type) {
switch (type) { \ case BOOLEAN:
case BOOLEAN: \ case INTEGER:
case INTEGER: \ cast(INTEGER);
cast(INTEGER); \ switch (value.type) {
switch (value.type) { \ case BOOLEAN:
case BOOLEAN: \ *((long *) data) += (*((bool *) value.data) ? 1L : 0L);
*((long *) data) OP (*((bool *) value.data) ? 1L : 0L); \ break;
break; \ case INTEGER:
case INTEGER: \ *((long *) data) += *((long *) value.data);
*((long *) data) OP *((long *) value.data); \ break;
break; \ case AMOUNT:
case AMOUNT: \ cast(AMOUNT);
cast(AMOUNT); \ *((amount_t *) data) += *((amount_t *) value.data);
*((amount_t *) data) OP *((amount_t *) value.data); \ break;
break; \ case BALANCE:
case BALANCE: \ cast(BALANCE);
cast(BALANCE); \ *((balance_t *) data) += *((balance_t *) value.data);
*((balance_t *) data) OP *((balance_t *) value.data); \ break;
break; \ case BALANCE_PAIR:
case BALANCE_PAIR: \ cast(BALANCE_PAIR);
cast(BALANCE_PAIR); \ *((balance_pair_t *) data) += *((balance_pair_t *) value.data);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \ default:
default: \ assert(0);
assert(0); \ break;
break; \ }
} \ break;
break; \
\ case AMOUNT:
case AMOUNT: \ switch (value.type) {
switch (value.type) { \ case BOOLEAN:
case BOOLEAN: \ if (*((bool *) value.data) &&
if (*((bool *) value.data) && \ ((amount_t *) data)->commodity()) {
((amount_t *) data)->commodity()) { \ cast(BALANCE);
cast(BALANCE); \ return *this += value;
return *this OP value; \ }
} \ *((amount_t *) data) += (*((bool *) value.data) ? 1L : 0L);
*((amount_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ break;
break; \
\ case INTEGER:
case INTEGER: \ if (*((long *) value.data) &&
if (*((long *) value.data) && \ ((amount_t *) data)->commodity()) {
((amount_t *) data)->commodity()) { \ cast(BALANCE);
cast(BALANCE); \ return *this += value;
return *this OP value; \ }
} \ *((amount_t *) data) += *((long *) value.data);
*((amount_t *) data) OP *((long *) value.data); \ break;
break; \
\ case AMOUNT:
case AMOUNT: \ if (((amount_t *) data)->commodity() !=
if (((amount_t *) data)->commodity() != \ ((amount_t *) value.data)->commodity()) {
((amount_t *) value.data)->commodity()) { \ cast(BALANCE);
cast(BALANCE); \ return *this += value;
return *this OP value; \ }
} \ *((amount_t *) data) += *((amount_t *) value.data);
*((amount_t *) data) OP *((amount_t *) value.data); \ break;
break; \
\ case BALANCE:
case BALANCE: \ cast(BALANCE);
cast(BALANCE); \ *((balance_t *) data) += *((balance_t *) value.data);
*((balance_t *) data) OP *((balance_t *) value.data); \ break;
break; \
\ case BALANCE_PAIR:
case BALANCE_PAIR: \ cast(BALANCE_PAIR);
cast(BALANCE_PAIR); \ *((balance_pair_t *) data) += *((balance_pair_t *) value.data);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \
\ default:
default: \ assert(0);
assert(0); \ break;
break; \ }
} \ break;
break; \
\ case BALANCE:
case BALANCE: \ switch (value.type) {
switch (value.type) { \ case BOOLEAN:
case BOOLEAN: \ *((balance_t *) data) += (*((bool *) value.data) ? 1L : 0L);
*((balance_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ break;
break; \ case INTEGER:
case INTEGER: \ *((balance_t *) data) += *((long *) value.data);
*((balance_t *) data) OP *((long *) value.data); \ break;
break; \ case AMOUNT:
case AMOUNT: \ *((balance_t *) data) += *((amount_t *) value.data);
*((balance_t *) data) OP *((amount_t *) value.data); \ break;
break; \ case BALANCE:
case BALANCE: \ *((balance_t *) data) += *((balance_t *) value.data);
*((balance_t *) data) OP *((balance_t *) value.data); \ break;
break; \ case BALANCE_PAIR:
case BALANCE_PAIR: \ cast(BALANCE_PAIR);
cast(BALANCE_PAIR); \ *((balance_pair_t *) data) += *((balance_pair_t *) value.data);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \ default:
default: \ assert(0);
assert(0); \ break;
break; \ }
} \ break;
break; \
\ case BALANCE_PAIR:
case BALANCE_PAIR: \ switch (value.type) {
switch (value.type) { \ case BOOLEAN:
case BOOLEAN: \ *((balance_pair_t *) data) += (*((bool *) value.data) ? 1L : 0L);
*((balance_pair_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ break;
break; \ case INTEGER:
case INTEGER: \ *((balance_pair_t *) data) += *((long *) value.data);
*((balance_pair_t *) data) OP *((long *) value.data); \ break;
break; \ case AMOUNT:
case AMOUNT: \ *((balance_pair_t *) data) += *((amount_t *) value.data);
*((balance_pair_t *) data) OP *((amount_t *) value.data); \ break;
break; \ case BALANCE:
case BALANCE: \ *((balance_pair_t *) data) += *((balance_t *) value.data);
*((balance_pair_t *) data) OP *((balance_t *) value.data); \ break;
break; \ case BALANCE_PAIR:
case BALANCE_PAIR: \ *((balance_pair_t *) data) += *((balance_pair_t *) value.data);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \ default:
default: \ assert(0);
assert(0); \ break;
break; \ }
} \ break;
break; \
\ default:
default: \ assert(0);
assert(0); \ break;
break; \ }
} \ return *this;
return *this; \
} }
DEF_VALUE_ADDSUB_OP(+=) value_t& value_t::operator-=(const value_t& value)
DEF_VALUE_ADDSUB_OP(-=) {
switch (type) {
case BOOLEAN:
case INTEGER:
cast(INTEGER);
switch (value.type) {
case BOOLEAN:
*((long *) data) -= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((long *) data) -= *((long *) value.data);
break;
case AMOUNT:
cast(AMOUNT);
*((amount_t *) data) -= *((amount_t *) value.data);
break;
case BALANCE:
cast(BALANCE);
*((balance_t *) data) -= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) -= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
#define DEF_VALUE_MULDIV_OP(OP) \ case AMOUNT:
value_t& value_t::operator OP(const value_t& value) \ switch (value.type) {
{ \ case BOOLEAN:
switch (type) { \ if (*((bool *) value.data) &&
case BOOLEAN: \ ((amount_t *) data)->commodity()) {
case INTEGER: \ cast(BALANCE);
cast(INTEGER); \ return *this -= value;
switch (value.type) { \ }
case BOOLEAN: \ *((amount_t *) data) -= (*((bool *) value.data) ? 1L : 0L);
*((long *) data) OP (*((bool *) value.data) ? 1L : 0L); \ break;
break; \
case INTEGER: \ case INTEGER:
*((long *) data) OP *((long *) value.data); \ if (*((long *) value.data) &&
break; \ ((amount_t *) data)->commodity()) {
case AMOUNT: \ cast(BALANCE);
cast(AMOUNT); \ return *this -= value;
*((amount_t *) data) OP *((amount_t *) value.data); \ }
break; \ *((amount_t *) data) -= *((long *) value.data);
case BALANCE: \ break;
cast(BALANCE); \
*((balance_t *) data) OP *((balance_t *) value.data); \ case AMOUNT:
break; \ if (((amount_t *) data)->commodity() !=
case BALANCE_PAIR: \ ((amount_t *) value.data)->commodity()) {
cast(BALANCE_PAIR); \ cast(BALANCE);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ return *this -= value;
break; \ }
default: \ *((amount_t *) data) -= *((amount_t *) value.data);
assert(0); \ break;
break; \
} \ case BALANCE:
break; \ cast(BALANCE);
\ *((balance_t *) data) -= *((balance_t *) value.data);
case AMOUNT: \ break;
switch (value.type) { \
case BOOLEAN: \ case BALANCE_PAIR:
*((amount_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ cast(BALANCE_PAIR);
break; \ *((balance_pair_t *) data) -= *((balance_pair_t *) value.data);
case INTEGER: \ break;
*((amount_t *) data) OP *((long *) value.data); \
break; \ default:
case AMOUNT: \ assert(0);
*((amount_t *) data) OP *((amount_t *) value.data); \ break;
break; \ }
case BALANCE: \ break;
cast(BALANCE); \
*((balance_t *) data) OP *((balance_t *) value.data); \ case BALANCE:
break; \ switch (value.type) {
case BALANCE_PAIR: \ case BOOLEAN:
cast(BALANCE_PAIR); \ *((balance_t *) data) -= (*((bool *) value.data) ? 1L : 0L);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \ case INTEGER:
default: \ *((balance_t *) data) -= *((long *) value.data);
assert(0); \ break;
break; \ case AMOUNT:
} \ *((balance_t *) data) -= *((amount_t *) value.data);
break; \ break;
\ case BALANCE:
case BALANCE: \ *((balance_t *) data) -= *((balance_t *) value.data);
switch (value.type) { \ break;
case BOOLEAN: \ case BALANCE_PAIR:
*((balance_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ cast(BALANCE_PAIR);
break; \ *((balance_pair_t *) data) -= *((balance_pair_t *) value.data);
case INTEGER: \ break;
*((balance_t *) data) OP *((long *) value.data); \ default:
break; \ assert(0);
case AMOUNT: \ break;
*((balance_t *) data) OP *((amount_t *) value.data); \ }
break; \ break;
case BALANCE: \
*((balance_t *) data) OP *((balance_t *) value.data); \ case BALANCE_PAIR:
break; \ switch (value.type) {
case BALANCE_PAIR: \ case BOOLEAN:
cast(BALANCE_PAIR); \ *((balance_pair_t *) data) -= (*((bool *) value.data) ? 1L : 0L);
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \ break;
break; \ case INTEGER:
default: \ *((balance_pair_t *) data) -= *((long *) value.data);
assert(0); \ break;
break; \ case AMOUNT:
} \ *((balance_pair_t *) data) -= *((amount_t *) value.data);
break; \ break;
\ case BALANCE:
case BALANCE_PAIR: \ *((balance_pair_t *) data) -= *((balance_t *) value.data);
switch (value.type) { \ break;
case BOOLEAN: \ case BALANCE_PAIR:
*((balance_pair_t *) data) OP (*((bool *) value.data) ? 1L : 0L); \ *((balance_pair_t *) data) -= *((balance_pair_t *) value.data);
break; \ break;
case INTEGER: \ default:
*((balance_pair_t *) data) OP *((long *) value.data); \ assert(0);
break; \ break;
case AMOUNT: \ }
*((balance_pair_t *) data) OP *((amount_t *) value.data); \ break;
break; \
case BALANCE: \ default:
*((balance_pair_t *) data) OP *((balance_t *) value.data); \ assert(0);
break; \ break;
case BALANCE_PAIR: \ }
*((balance_pair_t *) data) OP *((balance_pair_t *) value.data); \
break; \ simplify();
default: \
assert(0); \ return *this;
break; \
} \
break; \
\
default: \
assert(0); \
break; \
} \
return *this; \
} }
DEF_VALUE_MULDIV_OP(*=) value_t& value_t::operator*=(const value_t& value)
DEF_VALUE_MULDIV_OP(/=) {
if (! value) {
*this = 0L;
return *this;
}
switch (type) {
case BOOLEAN:
case INTEGER:
cast(INTEGER);
switch (value.type) {
case BOOLEAN:
*((long *) data) *= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((long *) data) *= *((long *) value.data);
break;
case AMOUNT:
cast(AMOUNT);
*((amount_t *) data) *= *((amount_t *) value.data);
break;
case BALANCE:
cast(BALANCE);
*((balance_t *) data) *= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) *= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case AMOUNT:
switch (value.type) {
case BOOLEAN:
*((amount_t *) data) *= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((amount_t *) data) *= *((long *) value.data);
break;
case AMOUNT:
*((amount_t *) data) *= *((amount_t *) value.data);
break;
case BALANCE:
cast(BALANCE);
*((balance_t *) data) *= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) *= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case BALANCE:
switch (value.type) {
case BOOLEAN:
*((balance_t *) data) *= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((balance_t *) data) *= *((long *) value.data);
break;
case AMOUNT:
*((balance_t *) data) *= *((amount_t *) value.data);
break;
case BALANCE:
*((balance_t *) data) *= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) *= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case BALANCE_PAIR:
switch (value.type) {
case BOOLEAN:
*((balance_pair_t *) data) *= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((balance_pair_t *) data) *= *((long *) value.data);
break;
case AMOUNT:
*((balance_pair_t *) data) *= *((amount_t *) value.data);
break;
case BALANCE:
*((balance_pair_t *) data) *= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
*((balance_pair_t *) data) *= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
default:
assert(0);
break;
}
return *this;
}
value_t& value_t::operator/=(const value_t& value)
{
switch (type) {
case BOOLEAN:
case INTEGER:
cast(INTEGER);
switch (value.type) {
case BOOLEAN:
*((long *) data) /= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((long *) data) /= *((long *) value.data);
break;
case AMOUNT:
cast(AMOUNT);
*((amount_t *) data) /= *((amount_t *) value.data);
break;
case BALANCE:
cast(BALANCE);
*((balance_t *) data) /= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) /= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case AMOUNT:
switch (value.type) {
case BOOLEAN:
*((amount_t *) data) /= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((amount_t *) data) /= *((long *) value.data);
break;
case AMOUNT:
*((amount_t *) data) /= *((amount_t *) value.data);
break;
case BALANCE:
cast(BALANCE);
*((balance_t *) data) /= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) /= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case BALANCE:
switch (value.type) {
case BOOLEAN:
*((balance_t *) data) /= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((balance_t *) data) /= *((long *) value.data);
break;
case AMOUNT:
*((balance_t *) data) /= *((amount_t *) value.data);
break;
case BALANCE:
*((balance_t *) data) /= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
cast(BALANCE_PAIR);
*((balance_pair_t *) data) /= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
case BALANCE_PAIR:
switch (value.type) {
case BOOLEAN:
*((balance_pair_t *) data) /= (*((bool *) value.data) ? 1L : 0L);
break;
case INTEGER:
*((balance_pair_t *) data) /= *((long *) value.data);
break;
case AMOUNT:
*((balance_pair_t *) data) /= *((amount_t *) value.data);
break;
case BALANCE:
*((balance_pair_t *) data) /= *((balance_t *) value.data);
break;
case BALANCE_PAIR:
*((balance_pair_t *) data) /= *((balance_pair_t *) value.data);
break;
default:
assert(0);
break;
}
break;
default:
assert(0);
break;
}
return *this;
}
#define DEF_VALUE_CMP_OP(OP) \ #define DEF_VALUE_CMP_OP(OP) \
bool value_t::operator OP(const value_t& value) \ bool value_t::operator OP(const value_t& value) \

1
value.h
View file

@ -89,6 +89,7 @@ class value_t
} }
void destroy(); void destroy();
void simplify();
value_t& operator=(const value_t& value); value_t& operator=(const value_t& value);
value_t& operator=(const bool value) { value_t& operator=(const bool value) {