| /* | |
| pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime | |
| Copyright (c) 2016 Trent Houliston <trent@houliston.me> and | |
| Wenzel Jakob <wenzel.jakob@epfl.ch> | |
| All rights reserved. Use of this source code is governed by a | |
| BSD-style license that can be found in the LICENSE file. | |
| */ | |
| #pragma once | |
| #include "pybind11.h" | |
| #include <cmath> | |
| #include <ctime> | |
| #include <chrono> | |
| #include <datetime.h> | |
| // Backport the PyDateTime_DELTA functions from Python3.3 if required | |
| #ifndef PyDateTime_DELTA_GET_DAYS | |
| #define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days) | |
| #endif | |
| #ifndef PyDateTime_DELTA_GET_SECONDS | |
| #define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds) | |
| #endif | |
| #ifndef PyDateTime_DELTA_GET_MICROSECONDS | |
| #define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds) | |
| #endif | |
| NAMESPACE_BEGIN(PYBIND11_NAMESPACE) | |
| NAMESPACE_BEGIN(detail) | |
| template <typename type> class duration_caster { | |
| public: | |
| typedef typename type::rep rep; | |
| typedef typename type::period period; | |
| typedef std::chrono::duration<uint_fast32_t, std::ratio<86400>> days; | |
| bool load(handle src, bool) { | |
| using namespace std::chrono; | |
| // Lazy initialise the PyDateTime import | |
| if (!PyDateTimeAPI) { PyDateTime_IMPORT; } | |
| if (!src) return false; | |
| // If invoked with datetime.delta object | |
| if (PyDelta_Check(src.ptr())) { | |
| value = type(duration_cast<duration<rep, period>>( | |
| days(PyDateTime_DELTA_GET_DAYS(src.ptr())) | |
| + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr())) | |
| + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr())))); | |
| return true; | |
| } | |
| // If invoked with a float we assume it is seconds and convert | |
| else if (PyFloat_Check(src.ptr())) { | |
| value = type(duration_cast<duration<rep, period>>(duration<double>(PyFloat_AsDouble(src.ptr())))); | |
| return true; | |
| } | |
| else return false; | |
| } | |
| // If this is a duration just return it back | |
| static const std::chrono::duration<rep, period>& get_duration(const std::chrono::duration<rep, period> &src) { | |
| return src; | |
| } | |
| // If this is a time_point get the time_since_epoch | |
| template <typename Clock> static std::chrono::duration<rep, period> get_duration(const std::chrono::time_point<Clock, std::chrono::duration<rep, period>> &src) { | |
| return src.time_since_epoch(); | |
| } | |
| static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) { | |
| using namespace std::chrono; | |
| // Use overloaded function to get our duration from our source | |
| // Works out if it is a duration or time_point and get the duration | |
| auto d = get_duration(src); | |
| // Lazy initialise the PyDateTime import | |
| if (!PyDateTimeAPI) { PyDateTime_IMPORT; } | |
| // Declare these special duration types so the conversions happen with the correct primitive types (int) | |
| using dd_t = duration<int, std::ratio<86400>>; | |
| using ss_t = duration<int, std::ratio<1>>; | |
| using us_t = duration<int, std::micro>; | |
| auto dd = duration_cast<dd_t>(d); | |
| auto subd = d - dd; | |
| auto ss = duration_cast<ss_t>(subd); | |
| auto us = duration_cast<us_t>(subd - ss); | |
| return PyDelta_FromDSU(dd.count(), ss.count(), us.count()); | |
| } | |
| PYBIND11_TYPE_CASTER(type, _("datetime.timedelta")); | |
| }; | |
| // This is for casting times on the system clock into datetime.datetime instances | |
| template <typename Duration> class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> { | |
| public: | |
| typedef std::chrono::time_point<std::chrono::system_clock, Duration> type; | |
| bool load(handle src, bool) { | |
| using namespace std::chrono; | |
| // Lazy initialise the PyDateTime import | |
| if (!PyDateTimeAPI) { PyDateTime_IMPORT; } | |
| if (!src) return false; | |
| if (PyDateTime_Check(src.ptr())) { | |
| std::tm cal; | |
| cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr()); | |
| cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr()); | |
| cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr()); | |
| cal.tm_mday = PyDateTime_GET_DAY(src.ptr()); | |
| cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1; | |
| cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900; | |
| cal.tm_isdst = -1; | |
| value = system_clock::from_time_t(std::mktime(&cal)) + microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr())); | |
| return true; | |
| } | |
| else return false; | |
| } | |
| static handle cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src, return_value_policy /* policy */, handle /* parent */) { | |
| using namespace std::chrono; | |
| // Lazy initialise the PyDateTime import | |
| if (!PyDateTimeAPI) { PyDateTime_IMPORT; } | |
| std::time_t tt = system_clock::to_time_t(src); | |
| // this function uses static memory so it's best to copy it out asap just in case | |
| // otherwise other code that is using localtime may break this (not just python code) | |
| std::tm localtime = *std::localtime(&tt); | |
| // Declare these special duration types so the conversions happen with the correct primitive types (int) | |
| using us_t = duration<int, std::micro>; | |
| return PyDateTime_FromDateAndTime(localtime.tm_year + 1900, | |
| localtime.tm_mon + 1, | |
| localtime.tm_mday, | |
| localtime.tm_hour, | |
| localtime.tm_min, | |
| localtime.tm_sec, | |
| (duration_cast<us_t>(src.time_since_epoch() % seconds(1))).count()); | |
| } | |
| PYBIND11_TYPE_CASTER(type, _("datetime.datetime")); | |
| }; | |
| // Other clocks that are not the system clock are not measured as datetime.datetime objects | |
| // since they are not measured on calendar time. So instead we just make them timedeltas | |
| // Or if they have passed us a time as a float we convert that | |
| template <typename Clock, typename Duration> class type_caster<std::chrono::time_point<Clock, Duration>> | |
| : public duration_caster<std::chrono::time_point<Clock, Duration>> { | |
| }; | |
| template <typename Rep, typename Period> class type_caster<std::chrono::duration<Rep, Period>> | |
| : public duration_caster<std::chrono::duration<Rep, Period>> { | |
| }; | |
| NAMESPACE_END(detail) | |
| NAMESPACE_END(PYBIND11_NAMESPACE) |