/* * 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 "pyinterp.h" #include "pyutils.h" #include "times.h" // jww (2007-05-04): Convert time duration objects to PyDelta namespace ledger { using namespace boost::python; #define MY_PyDateTime_IMPORT \ PyDateTimeAPI = (PyDateTime_CAPI*) \ PyCObject_Import(const_cast<char *>("datetime"), \ const_cast<char *>("datetime_CAPI")) struct date_to_python { static PyObject* convert(const date_t& dte) { MY_PyDateTime_IMPORT; return PyDate_FromDate(dte.year(), dte.month(), dte.day()); } }; struct date_from_python { static void* convertible(PyObject* obj_ptr) { MY_PyDateTime_IMPORT; if (PyDate_Check(obj_ptr)) return obj_ptr; return 0; } static void construct(PyObject * obj_ptr, converter::rvalue_from_python_stage1_data * data) { MY_PyDateTime_IMPORT; int year = PyDateTime_GET_YEAR(obj_ptr); date::year_type y = gregorian::greg_year(static_cast<unsigned short>(year)); date::month_type m = static_cast<date::month_type>(PyDateTime_GET_MONTH(obj_ptr)); date::day_type d = static_cast<date::day_type>(PyDateTime_GET_DAY(obj_ptr)); date_t * dte = new date_t(y, m, d); data->convertible = (void *) dte; } }; typedef register_python_conversion<date_t, date_to_python, date_from_python> date_python_conversion; struct datetime_to_python { static PyObject* convert(const datetime_t& moment) { MY_PyDateTime_IMPORT; date_t dte = moment.date(); datetime_t::time_duration_type tod = moment.time_of_day(); return PyDateTime_FromDateAndTime (static_cast<int>(dte.year()), static_cast<int>(dte.month()), static_cast<int>(dte.day()), static_cast<int>(tod.hours()), static_cast<int>(tod.minutes()), static_cast<int>(tod.seconds()), static_cast<int>(tod.total_microseconds() % 1000000)); } }; struct datetime_from_python { static void* convertible(PyObject* obj_ptr) { MY_PyDateTime_IMPORT; if(PyDateTime_Check(obj_ptr)) return obj_ptr; return 0; } static void construct(PyObject * obj_ptr, converter::rvalue_from_python_stage1_data * data) { MY_PyDateTime_IMPORT; int year = PyDateTime_GET_YEAR(obj_ptr); date::year_type y = gregorian::greg_year(static_cast<unsigned short>(year)); date::month_type m = static_cast<date::month_type>(PyDateTime_GET_MONTH(obj_ptr)); date::day_type d = static_cast<date::day_type>(PyDateTime_GET_DAY(obj_ptr)); datetime_t::time_duration_type::hour_type h = static_cast<datetime_t::time_duration_type::hour_type> (PyDateTime_DATE_GET_HOUR(obj_ptr)); datetime_t::time_duration_type::min_type min = static_cast<datetime_t::time_duration_type::min_type> (PyDateTime_DATE_GET_MINUTE(obj_ptr)); datetime_t::time_duration_type::sec_type s = static_cast<datetime_t::time_duration_type::sec_type> (PyDateTime_DATE_GET_SECOND(obj_ptr)); datetime_t::time_duration_type::fractional_seconds_type ms = static_cast<datetime_t::time_duration_type::fractional_seconds_type> (PyDateTime_DATE_GET_MICROSECOND(obj_ptr)) * 1000000; datetime_t * moment = new datetime_t(date_t(y, m, d), datetime_t::time_duration_type(h, min, s, ms)); data->convertible = (void *) moment; } }; typedef register_python_conversion<datetime_t, datetime_to_python, datetime_from_python> datetime_python_conversion; /* Convert time_duration to/from python */ struct duration_to_python { static int get_usecs(boost::posix_time::time_duration const& d) { static int64_t resolution = boost::posix_time::time_duration::ticks_per_second(); int64_t fracsecs = d.fractional_seconds(); if (resolution > 1000000) return static_cast<int>(fracsecs / (resolution / 1000000)); else return static_cast<int>(fracsecs * (1000000 / resolution)); } static PyObject * convert(posix_time::time_duration d) { int days = d.hours() / 24; if (days < 0) days --; int seconds = d.total_seconds() - days*(24*3600); int usecs = get_usecs(d); if (days < 0) usecs = 1000000-1 - usecs; return PyDelta_FromDSU(days, seconds, usecs); } }; /* Should support the negative values, but not the special boost time durations */ struct duration_from_python { static void* convertible(PyObject * obj_ptr) { if ( ! PyDelta_Check(obj_ptr)) return 0; return obj_ptr; } static void construct(PyObject* obj_ptr, python::converter::rvalue_from_python_stage1_data * data) { PyDateTime_Delta const* pydelta = reinterpret_cast<PyDateTime_Delta*>(obj_ptr); int days = pydelta->days; bool is_negative = (days < 0); if (is_negative) days = -days; // Create time duration object posix_time::time_duration duration = (posix_time::hours(24) * days + posix_time::seconds(pydelta->seconds) + posix_time::microseconds(pydelta->microseconds)); if (is_negative) duration = duration.invert_sign(); void * storage = reinterpret_cast<converter::rvalue_from_python_storage <posix_time::time_duration> *> (data)->storage.bytes; new (storage) posix_time::time_duration(duration); data->convertible = storage; } }; typedef register_python_conversion<time_duration_t, duration_to_python, duration_from_python> duration_python_conversion; datetime_t py_parse_datetime(const string& str) { return parse_datetime(str); } date_t py_parse_date(const string& str) { return parse_date(str); } void export_times() { datetime_python_conversion(); date_python_conversion(); duration_python_conversion(); register_optional_to_python<datetime_t>(); register_optional_to_python<date_t>(); scope().attr("parse_datetime") = &py_parse_datetime; scope().attr("parse_date") = &py_parse_date; scope().attr("times_initialize") = ×_initialize; scope().attr("times_shutdown") = ×_shutdown; #if 0 class_< interval_t > ("Interval") ; #endif } } // namespace ledger