315 lines
9.7 KiB
C++
315 lines
9.7 KiB
C++
/*
|
|
* Copyright (c) 2003-2012, 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 "pyinterp.h"
|
|
#include "pyutils.h"
|
|
#include "pyfstream.h"
|
|
#include "commodity.h"
|
|
#include "annotate.h"
|
|
#include "pool.h"
|
|
|
|
namespace ledger {
|
|
|
|
using namespace boost::python;
|
|
|
|
namespace {
|
|
|
|
boost::optional<amount_t> py_value_0(const amount_t& amount) {
|
|
return amount.value(CURRENT_TIME());
|
|
}
|
|
boost::optional<amount_t> py_value_1(const amount_t& amount,
|
|
commodity_t& in_terms_of) {
|
|
return amount.value(CURRENT_TIME(), in_terms_of);
|
|
}
|
|
boost::optional<amount_t> py_value_2(const amount_t& amount,
|
|
commodity_t& in_terms_of,
|
|
datetime_t& moment) {
|
|
return amount.value(moment, in_terms_of);
|
|
}
|
|
|
|
void py_parse_2(amount_t& amount, object in, unsigned char flags) {
|
|
if (PyFile_Check(in.ptr())) {
|
|
pyifstream instr(reinterpret_cast<PyFileObject *>(in.ptr()));
|
|
amount.parse(instr, flags);
|
|
} else {
|
|
PyErr_SetString(PyExc_IOError,
|
|
_("Argument to amount.parse(file) is not a file object"));
|
|
}
|
|
}
|
|
void py_parse_1(amount_t& amount, object in) {
|
|
py_parse_2(amount, in, 0);
|
|
}
|
|
|
|
void py_parse_str_1(amount_t& amount, const string& str) {
|
|
amount.parse(str);
|
|
}
|
|
void py_parse_str_2(amount_t& amount, const string& str, unsigned char flags) {
|
|
amount.parse(str, flags);
|
|
}
|
|
|
|
#if 0
|
|
void py_print(amount_t& amount, object out) {
|
|
if (PyFile_Check(out.ptr())) {
|
|
pyofstream outstr(reinterpret_cast<PyFileObject *>(out.ptr()));
|
|
amount.print(outstr);
|
|
} else {
|
|
PyErr_SetString(PyExc_IOError,
|
|
_("Argument to amount.print_(file) is not a file object"));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
annotation_t& py_amount_annotation(amount_t& amount) {
|
|
return amount.annotation();
|
|
}
|
|
|
|
amount_t py_strip_annotations_0(amount_t& amount) {
|
|
return amount.strip_annotations(keep_details_t());
|
|
}
|
|
amount_t py_strip_annotations_1(amount_t& amount, const keep_details_t& keep) {
|
|
return amount.strip_annotations(keep);
|
|
}
|
|
|
|
PyObject * py_amount_unicode(amount_t& amount) {
|
|
return str_to_py_unicode(amount.to_string());
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
#define EXC_TRANSLATOR(type) \
|
|
void exc_translate_ ## type(const type& err) { \
|
|
PyErr_SetString(PyExc_ArithmeticError, err.what()); \
|
|
}
|
|
|
|
EXC_TRANSLATOR(amount_error)
|
|
|
|
void export_amount()
|
|
{
|
|
class_< amount_t > ("Amount")
|
|
.def("initialize", &amount_t::initialize) // only for the PyUnitTests
|
|
.staticmethod("initialize")
|
|
.def("shutdown", &amount_t::shutdown)
|
|
.staticmethod("shutdown")
|
|
|
|
.add_static_property("is_initialized",
|
|
make_getter(&amount_t::is_initialized),
|
|
make_setter(&amount_t::is_initialized))
|
|
.add_static_property("stream_fullstrings",
|
|
make_getter(&amount_t::stream_fullstrings),
|
|
make_setter(&amount_t::stream_fullstrings))
|
|
|
|
.def(init<long>())
|
|
.def(init<std::string>())
|
|
|
|
.def("exact", &amount_t::exact, args("value"),
|
|
_("Construct an amount object whose display precision is always equal to its\n\
|
|
internal precision."))
|
|
.staticmethod("exact")
|
|
|
|
.def(init<amount_t>())
|
|
|
|
.def("compare", &amount_t::compare, args("amount"),
|
|
_("Compare two amounts for equality, returning <0, 0 or >0."))
|
|
|
|
.def(self == self)
|
|
.def(self == long())
|
|
.def(long() == self)
|
|
|
|
.def(self != self)
|
|
.def(self != long())
|
|
.def(long() != self)
|
|
|
|
.def(! self)
|
|
|
|
.def(self < self)
|
|
.def(self < long())
|
|
.def(long() < self)
|
|
|
|
.def(self <= self)
|
|
.def(self <= long())
|
|
.def(long() <= self)
|
|
|
|
.def(self > self)
|
|
.def(self > long())
|
|
.def(long() > self)
|
|
|
|
.def(self >= self)
|
|
.def(self >= long())
|
|
.def(long() >= self)
|
|
|
|
.def(self += self)
|
|
.def(self += long())
|
|
|
|
.def(self + self)
|
|
.def(self + long())
|
|
.def(long() + self)
|
|
|
|
.def(self -= self)
|
|
.def(self -= long())
|
|
|
|
.def(self - self)
|
|
.def(self - long())
|
|
.def(long() - self)
|
|
|
|
.def(self *= self)
|
|
.def(self *= long())
|
|
|
|
.def(self * self)
|
|
.def(self * long())
|
|
.def(long() * self)
|
|
|
|
.def(self /= self)
|
|
.def(self /= long())
|
|
|
|
.def(self / self)
|
|
.def(self / long())
|
|
.def(long() / self)
|
|
|
|
.add_property("precision", &amount_t::precision)
|
|
.add_property("display_precision", &amount_t::display_precision)
|
|
.add_property("keep_precision",
|
|
&amount_t::keep_precision,
|
|
&amount_t::set_keep_precision)
|
|
|
|
.def("negated", &amount_t::negated)
|
|
.def("in_place_negate", &amount_t::in_place_negate,
|
|
return_internal_reference<>())
|
|
.def(- self)
|
|
|
|
.def("abs", &amount_t::abs)
|
|
.def("__abs__", &amount_t::abs)
|
|
|
|
.def("inverted", &amount_t::inverted)
|
|
|
|
.def("rounded", &amount_t::rounded)
|
|
.def("in_place_round", &amount_t::in_place_round,
|
|
return_internal_reference<>())
|
|
|
|
.def("truncated", &amount_t::truncated)
|
|
.def("in_place_truncate", &amount_t::in_place_truncate,
|
|
return_internal_reference<>())
|
|
|
|
.def("floored", &amount_t::floored)
|
|
.def("in_place_floor", &amount_t::in_place_floor,
|
|
return_internal_reference<>())
|
|
|
|
.def("unrounded", &amount_t::unrounded)
|
|
.def("in_place_unround", &amount_t::in_place_unround,
|
|
return_internal_reference<>())
|
|
|
|
.def("reduced", &amount_t::reduced)
|
|
.def("in_place_reduce", &amount_t::in_place_reduce,
|
|
return_internal_reference<>())
|
|
|
|
.def("unreduced", &amount_t::unreduced)
|
|
.def("in_place_unreduce", &amount_t::in_place_unreduce,
|
|
return_internal_reference<>())
|
|
|
|
.def("value", py_value_0)
|
|
.def("value", py_value_1, args("in_terms_of"))
|
|
.def("value", py_value_2, args("in_terms_of", "moment"))
|
|
|
|
.def("price", &amount_t::price)
|
|
|
|
.def("sign", &amount_t::sign)
|
|
.def("__nonzero__", &amount_t::is_nonzero)
|
|
.def("is_nonzero", &amount_t::is_nonzero)
|
|
.def("is_zero", &amount_t::is_zero)
|
|
.def("is_realzero", &amount_t::is_realzero)
|
|
.def("is_null", &amount_t::is_null)
|
|
|
|
.def("to_double", &amount_t::to_double)
|
|
.def("__float__", &amount_t::to_double)
|
|
.def("to_long", &amount_t::to_long)
|
|
.def("__int__", &amount_t::to_long)
|
|
.def("fits_in_long", &amount_t::fits_in_long)
|
|
|
|
.def("__str__", &amount_t::to_string)
|
|
.def("to_string", &amount_t::to_string)
|
|
.def("__unicode__", py_amount_unicode)
|
|
.def("to_fullstring", &amount_t::to_fullstring)
|
|
.def("__repr__", &amount_t::to_fullstring)
|
|
.def("quantity_string", &amount_t::quantity_string)
|
|
|
|
.add_property("commodity",
|
|
make_function(&amount_t::commodity,
|
|
return_internal_reference<>()),
|
|
make_function(&amount_t::set_commodity,
|
|
with_custodian_and_ward<1, 2>()))
|
|
.def("has_commodity", &amount_t::has_commodity)
|
|
.def("clear_commodity", &amount_t::clear_commodity)
|
|
|
|
.def("number", &amount_t::number)
|
|
|
|
.def("annotate", &amount_t::annotate)
|
|
.def("has_annotation", &amount_t::has_annotation)
|
|
.add_property("annotation",
|
|
make_function(py_amount_annotation,
|
|
return_internal_reference<>()))
|
|
.def("strip_annotations", py_strip_annotations_0)
|
|
.def("strip_annotations", py_strip_annotations_1)
|
|
|
|
.def("parse", py_parse_1)
|
|
.def("parse", py_parse_2)
|
|
.def("parse", py_parse_str_1)
|
|
.def("parse", py_parse_str_2)
|
|
|
|
.def("parse_conversion", &amount_t::parse_conversion)
|
|
.staticmethod("parse_conversion")
|
|
|
|
.def("valid", &amount_t::valid)
|
|
;
|
|
|
|
enum_< parse_flags_enum_t >("ParseFlags")
|
|
.value("Default", PARSE_DEFAULT)
|
|
.value("Partial", PARSE_PARTIAL)
|
|
.value("Single", PARSE_SINGLE)
|
|
.value("NoMigrate", PARSE_NO_MIGRATE)
|
|
.value("NoReduce", PARSE_NO_REDUCE)
|
|
.value("NoAssign", PARSE_NO_ASSIGN)
|
|
.value("OpContext", PARSE_OP_CONTEXT)
|
|
.value("SoftFail", PARSE_SOFT_FAIL)
|
|
;
|
|
|
|
register_optional_to_python<amount_t>();
|
|
|
|
implicitly_convertible<long, amount_t>();
|
|
implicitly_convertible<string, amount_t>();
|
|
|
|
#define EXC_TRANSLATE(type) \
|
|
register_exception_translator<type>(&exc_translate_ ## type);
|
|
|
|
EXC_TRANSLATE(amount_error);
|
|
}
|
|
|
|
} // namespace ledger
|