a875940a93
As the format used by property trees to represent valid JSON and that for valid XML is too different and given that there are more requests for valid XML output I decided to pursue a quick fix and remove the json command in favor of a working xml command. See bug #782, #909, recent discussion on mailing list. JSON support is postponed until I or someone else finds time to work on this or the python bindings are more stable.
375 lines
11 KiB
C++
375 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2003-2013, 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 <system.hh>
|
|
|
|
#include "amount.h"
|
|
#include "commodity.h"
|
|
#include "expr.h"
|
|
#include "annotate.h"
|
|
#include "pool.h"
|
|
|
|
namespace ledger {
|
|
|
|
bool annotation_t::operator<(const annotation_t& rhs) const
|
|
{
|
|
if (! price && rhs.price) return true;
|
|
if (price && ! rhs.price) return false;
|
|
if (! date && rhs.date) return true;
|
|
if (date && ! rhs.date) return false;
|
|
if (! tag && rhs.tag) return true;
|
|
if (tag && ! rhs.tag) return false;
|
|
|
|
if (! value_expr && rhs.value_expr) return true;
|
|
if (value_expr && ! rhs.value_expr) return false;
|
|
|
|
if (price) {
|
|
if (price->commodity().symbol() < rhs.price->commodity().symbol())
|
|
return true;
|
|
if (price->commodity().symbol() > rhs.price->commodity().symbol())
|
|
return false;
|
|
|
|
if (*price < *rhs.price) return true;
|
|
if (*price > *rhs.price) return false;
|
|
}
|
|
if (date) {
|
|
if (*date < *rhs.date) return true;
|
|
if (*date > *rhs.date) return false;
|
|
}
|
|
if (tag) {
|
|
if (*tag < *rhs.tag) return true;
|
|
if (*tag > *rhs.tag) return false;
|
|
}
|
|
if (value_expr) {
|
|
DEBUG("annotate.less", "Comparing (" << value_expr->text()
|
|
<< ") < (" << rhs.value_expr->text());
|
|
if (value_expr->text() < rhs.value_expr->text()) return true;
|
|
//if (value_expr->text() > rhs.value_expr->text()) return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void annotation_t::parse(std::istream& in)
|
|
{
|
|
do {
|
|
istream_pos_type pos = in.tellg();
|
|
if (static_cast<int>(pos) < 0)
|
|
return;
|
|
|
|
char buf[256];
|
|
char c = peek_next_nonws(in);
|
|
if (c == '{') {
|
|
if (price)
|
|
throw_(amount_error, _("Commodity specifies more than one price"));
|
|
|
|
in.get(c);
|
|
c = static_cast<char>(in.peek());
|
|
if (c == '{') {
|
|
in.get(c);
|
|
add_flags(ANNOTATION_PRICE_NOT_PER_UNIT);
|
|
}
|
|
|
|
c = peek_next_nonws(in);
|
|
if (c == '=') {
|
|
in.get(c);
|
|
add_flags(ANNOTATION_PRICE_FIXATED);
|
|
}
|
|
|
|
READ_INTO(in, buf, 255, c, c != '}');
|
|
if (c == '}') {
|
|
in.get(c);
|
|
if (has_flags(ANNOTATION_PRICE_NOT_PER_UNIT)) {
|
|
c = static_cast<char>(in.peek());
|
|
if (c != '}')
|
|
throw_(amount_error, _("Commodity lot price lacks double closing brace"));
|
|
else
|
|
in.get(c);
|
|
}
|
|
} else {
|
|
throw_(amount_error, _("Commodity lot price lacks closing brace"));
|
|
}
|
|
|
|
amount_t temp;
|
|
temp.parse(buf, PARSE_NO_MIGRATE);
|
|
|
|
DEBUG("commodity.annotations", "Parsed annotation price: " << temp);
|
|
price = temp;
|
|
}
|
|
else if (c == '[') {
|
|
if (date)
|
|
throw_(amount_error, _("Commodity specifies more than one date"));
|
|
|
|
in.get(c);
|
|
READ_INTO(in, buf, 255, c, c != ']');
|
|
if (c == ']')
|
|
in.get(c);
|
|
else
|
|
throw_(amount_error, _("Commodity date lacks closing bracket"));
|
|
|
|
date = parse_date(buf);
|
|
}
|
|
else if (c == '(') {
|
|
in.get(c);
|
|
c = static_cast<char>(in.peek());
|
|
if (c == '@') {
|
|
in.clear();
|
|
in.seekg(pos, std::ios::beg);
|
|
break;
|
|
}
|
|
else if (c == '(') {
|
|
if (value_expr)
|
|
throw_(amount_error,
|
|
_("Commodity specifies more than one valuation expresion"));
|
|
|
|
in.get(c);
|
|
READ_INTO(in, buf, 255, c, c != ')');
|
|
if (c == ')') {
|
|
in.get(c);
|
|
c = static_cast<char>(in.peek());
|
|
if (c == ')')
|
|
in.get(c);
|
|
else
|
|
throw_(amount_error,
|
|
_("Commodity valuation expression lacks closing parentheses"));
|
|
} else {
|
|
throw_(amount_error,
|
|
_("Commodity valuation expression lacks closing parentheses"));
|
|
}
|
|
|
|
value_expr = expr_t(buf);
|
|
} else {
|
|
if (tag)
|
|
throw_(amount_error, _("Commodity specifies more than one tag"));
|
|
|
|
READ_INTO(in, buf, 255, c, c != ')');
|
|
if (c == ')')
|
|
in.get(c);
|
|
else
|
|
throw_(amount_error, _("Commodity tag lacks closing parenthesis"));
|
|
|
|
tag = buf;
|
|
}
|
|
}
|
|
else {
|
|
in.clear();
|
|
in.seekg(pos, std::ios::beg);
|
|
break;
|
|
}
|
|
} while (true);
|
|
|
|
#if DEBUG_ON
|
|
if (SHOW_DEBUG("amounts.commodities") && *this) {
|
|
DEBUG("amounts.commodities",
|
|
"Parsed commodity annotations: " << std::endl << *this);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void annotation_t::print(std::ostream& out, bool keep_base,
|
|
bool no_computed_annotations) const
|
|
{
|
|
if (price &&
|
|
(! no_computed_annotations || ! has_flags(ANNOTATION_PRICE_CALCULATED)))
|
|
out << " {"
|
|
<< (has_flags(ANNOTATION_PRICE_FIXATED) ? "=" : "")
|
|
<< (keep_base ? *price : price->unreduced())
|
|
<< '}';
|
|
|
|
if (date &&
|
|
(! no_computed_annotations || ! has_flags(ANNOTATION_DATE_CALCULATED)))
|
|
out << " [" << format_date(*date, FMT_WRITTEN) << ']';
|
|
|
|
if (tag &&
|
|
(! no_computed_annotations || ! has_flags(ANNOTATION_TAG_CALCULATED)))
|
|
out << " (" << *tag << ')';
|
|
|
|
if (value_expr && ! has_flags(ANNOTATION_VALUE_EXPR_CALCULATED))
|
|
out << " ((" << *value_expr << "))";
|
|
}
|
|
|
|
void put_annotation(property_tree::ptree& st, const annotation_t& details)
|
|
{
|
|
if (details.price)
|
|
put_amount(st.put("price", ""), *details.price);
|
|
|
|
if (details.date)
|
|
put_date(st.put("date", ""), *details.date);
|
|
|
|
if (details.tag)
|
|
st.put("tag", *details.tag);
|
|
|
|
if (details.value_expr)
|
|
st.put("value_expr", details.value_expr->text());
|
|
}
|
|
|
|
bool keep_details_t::keep_all(const commodity_t& comm) const
|
|
{
|
|
return (! comm.has_annotation() ||
|
|
(keep_price && keep_date && keep_tag && ! only_actuals));
|
|
}
|
|
|
|
bool keep_details_t::keep_any(const commodity_t& comm) const
|
|
{
|
|
return comm.has_annotation() && (keep_price || keep_date || keep_tag);
|
|
}
|
|
|
|
bool annotated_commodity_t::operator==(const commodity_t& comm) const
|
|
{
|
|
// If the base commodities don't match, the game's up.
|
|
if (base != comm.base)
|
|
return false;
|
|
|
|
assert(annotated);
|
|
if (! comm.annotated)
|
|
return false;
|
|
|
|
if (details != as_annotated_commodity(comm).details)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
optional<price_point_t>
|
|
annotated_commodity_t::find_price(const commodity_t * commodity,
|
|
const datetime_t& moment,
|
|
const datetime_t& oldest) const
|
|
{
|
|
DEBUG("commodity.price.find",
|
|
"annotated_commodity_t::find_price(" << symbol() << ")");
|
|
|
|
datetime_t when;
|
|
if (! moment.is_not_a_date_time())
|
|
when = moment;
|
|
else if (epoch)
|
|
when = *epoch;
|
|
else
|
|
when = CURRENT_TIME();
|
|
|
|
DEBUG("commodity.price.find", "reference time: " << when);
|
|
|
|
const commodity_t * target = NULL;
|
|
if (commodity)
|
|
target = commodity;
|
|
|
|
if (details.price) {
|
|
DEBUG("commodity.price.find", "price annotation: " << *details.price);
|
|
|
|
if (details.has_flags(ANNOTATION_PRICE_FIXATED)) {
|
|
DEBUG("commodity.price.find",
|
|
"amount_t::value: fixated price = " << *details.price);
|
|
return price_point_t(when, *details.price);
|
|
}
|
|
else if (! target) {
|
|
DEBUG("commodity.price.find", "setting target commodity from price");
|
|
target = details.price->commodity_ptr();
|
|
}
|
|
}
|
|
|
|
#if DEBUG_ON
|
|
if (target)
|
|
DEBUG("commodity.price.find", "target commodity: " << target->symbol());
|
|
#endif
|
|
|
|
if (details.value_expr)
|
|
return find_price_from_expr(const_cast<expr_t&>(*details.value_expr),
|
|
commodity, when);
|
|
|
|
return commodity_t::find_price(target, when, oldest);
|
|
}
|
|
|
|
commodity_t&
|
|
annotated_commodity_t::strip_annotations(const keep_details_t& what_to_keep)
|
|
{
|
|
DEBUG("commodity.annotated.strip",
|
|
"Reducing commodity " << *this << std::endl
|
|
<< " keep price " << what_to_keep.keep_price << " "
|
|
<< " keep date " << what_to_keep.keep_date << " "
|
|
<< " keep tag " << what_to_keep.keep_tag);
|
|
|
|
commodity_t * new_comm;
|
|
|
|
bool keep_price =
|
|
((what_to_keep.keep_price ||
|
|
(details.has_flags(ANNOTATION_PRICE_FIXATED) &&
|
|
has_flags(COMMODITY_SAW_ANN_PRICE_FLOAT) &&
|
|
has_flags(COMMODITY_SAW_ANN_PRICE_FIXATED))) &&
|
|
(! what_to_keep.only_actuals ||
|
|
! details.has_flags(ANNOTATION_PRICE_CALCULATED)));
|
|
bool keep_date =
|
|
(what_to_keep.keep_date &&
|
|
(! what_to_keep.only_actuals ||
|
|
! details.has_flags(ANNOTATION_DATE_CALCULATED)));
|
|
bool keep_tag =
|
|
(what_to_keep.keep_tag &&
|
|
(! what_to_keep.only_actuals ||
|
|
! details.has_flags(ANNOTATION_TAG_CALCULATED)));
|
|
|
|
DEBUG("commodity.annotated.strip",
|
|
"Reducing commodity " << *this << std::endl
|
|
<< " keep price " << keep_price << " "
|
|
<< " keep date " << keep_date << " "
|
|
<< " keep tag " << keep_tag);
|
|
|
|
if ((keep_price && details.price) ||
|
|
(keep_date && details.date) ||
|
|
(keep_tag && details.tag)) {
|
|
new_comm = pool().find_or_create
|
|
(referent(), annotation_t(keep_price ? details.price : none,
|
|
keep_date ? details.date : none,
|
|
keep_tag ? details.tag : none));
|
|
|
|
// Transfer over any relevant annotation flags, as they still apply.
|
|
if (new_comm->annotated) {
|
|
annotation_t& new_details(as_annotated_commodity(*new_comm).details);
|
|
if (keep_price)
|
|
new_details.add_flags(details.flags() &
|
|
(ANNOTATION_PRICE_CALCULATED |
|
|
ANNOTATION_PRICE_FIXATED));
|
|
if (keep_date)
|
|
new_details.add_flags(details.flags() & ANNOTATION_DATE_CALCULATED);
|
|
if (keep_tag)
|
|
new_details.add_flags(details.flags() & ANNOTATION_TAG_CALCULATED);
|
|
}
|
|
|
|
return *new_comm;
|
|
}
|
|
|
|
return referent();
|
|
}
|
|
|
|
void annotated_commodity_t::write_annotations
|
|
(std::ostream& out, bool no_computed_annotations) const
|
|
{
|
|
details.print(out, pool().keep_base, no_computed_annotations);
|
|
}
|
|
|
|
} // namespace ledger
|