Adding pybind11 v2.2.4 to repo
[tidl/tidl-api.git] / tidl_api / pybind11 / include / pybind11 / chrono.h
1 /*
2     pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
4     Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
5                        Wenzel Jakob <wenzel.jakob@epfl.ch>
7     All rights reserved. Use of this source code is governed by a
8     BSD-style license that can be found in the LICENSE file.
9 */
11 #pragma once
13 #include "pybind11.h"
14 #include <cmath>
15 #include <ctime>
16 #include <chrono>
17 #include <datetime.h>
19 // Backport the PyDateTime_DELTA functions from Python3.3 if required
20 #ifndef PyDateTime_DELTA_GET_DAYS
21 #define PyDateTime_DELTA_GET_DAYS(o)         (((PyDateTime_Delta*)o)->days)
22 #endif
23 #ifndef PyDateTime_DELTA_GET_SECONDS
24 #define PyDateTime_DELTA_GET_SECONDS(o)      (((PyDateTime_Delta*)o)->seconds)
25 #endif
26 #ifndef PyDateTime_DELTA_GET_MICROSECONDS
27 #define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds)
28 #endif
30 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
31 NAMESPACE_BEGIN(detail)
33 template <typename type> class duration_caster {
34 public:
35     typedef typename type::rep rep;
36     typedef typename type::period period;
38     typedef std::chrono::duration<uint_fast32_t, std::ratio<86400>> days;
40     bool load(handle src, bool) {
41         using namespace std::chrono;
43         // Lazy initialise the PyDateTime import
44         if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
46         if (!src) return false;
47         // If invoked with datetime.delta object
48         if (PyDelta_Check(src.ptr())) {
49             value = type(duration_cast<duration<rep, period>>(
50                   days(PyDateTime_DELTA_GET_DAYS(src.ptr()))
51                 + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr()))
52                 + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
53             return true;
54         }
55         // If invoked with a float we assume it is seconds and convert
56         else if (PyFloat_Check(src.ptr())) {
57             value = type(duration_cast<duration<rep, period>>(duration<double>(PyFloat_AsDouble(src.ptr()))));
58             return true;
59         }
60         else return false;
61     }
63     // If this is a duration just return it back
64     static const std::chrono::duration<rep, period>& get_duration(const std::chrono::duration<rep, period> &src) {
65         return src;
66     }
68     // If this is a time_point get the time_since_epoch
69     template <typename Clock> static std::chrono::duration<rep, period> get_duration(const std::chrono::time_point<Clock, std::chrono::duration<rep, period>> &src) {
70         return src.time_since_epoch();
71     }
73     static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) {
74         using namespace std::chrono;
76         // Use overloaded function to get our duration from our source
77         // Works out if it is a duration or time_point and get the duration
78         auto d = get_duration(src);
80         // Lazy initialise the PyDateTime import
81         if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
83         // Declare these special duration types so the conversions happen with the correct primitive types (int)
84         using dd_t = duration<int, std::ratio<86400>>;
85         using ss_t = duration<int, std::ratio<1>>;
86         using us_t = duration<int, std::micro>;
88         auto dd = duration_cast<dd_t>(d);
89         auto subd = d - dd;
90         auto ss = duration_cast<ss_t>(subd);
91         auto us = duration_cast<us_t>(subd - ss);
92         return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
93     }
95     PYBIND11_TYPE_CASTER(type, _("datetime.timedelta"));
96 };
98 // This is for casting times on the system clock into datetime.datetime instances
99 template <typename Duration> class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> {
100 public:
101     typedef std::chrono::time_point<std::chrono::system_clock, Duration> type;
102     bool load(handle src, bool) {
103         using namespace std::chrono;
105         // Lazy initialise the PyDateTime import
106         if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
108         if (!src) return false;
109         if (PyDateTime_Check(src.ptr())) {
110             std::tm cal;
111             cal.tm_sec   = PyDateTime_DATE_GET_SECOND(src.ptr());
112             cal.tm_min   = PyDateTime_DATE_GET_MINUTE(src.ptr());
113             cal.tm_hour  = PyDateTime_DATE_GET_HOUR(src.ptr());
114             cal.tm_mday  = PyDateTime_GET_DAY(src.ptr());
115             cal.tm_mon   = PyDateTime_GET_MONTH(src.ptr()) - 1;
116             cal.tm_year  = PyDateTime_GET_YEAR(src.ptr()) - 1900;
117             cal.tm_isdst = -1;
119             value = system_clock::from_time_t(std::mktime(&cal)) + microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
120             return true;
121         }
122         else return false;
123     }
125     static handle cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src, return_value_policy /* policy */, handle /* parent */) {
126         using namespace std::chrono;
128         // Lazy initialise the PyDateTime import
129         if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
131         std::time_t tt = system_clock::to_time_t(src);
132         // this function uses static memory so it's best to copy it out asap just in case
133         // otherwise other code that is using localtime may break this (not just python code)
134         std::tm localtime = *std::localtime(&tt);
136         // Declare these special duration types so the conversions happen with the correct primitive types (int)
137         using us_t = duration<int, std::micro>;
139         return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
140                                           localtime.tm_mon + 1,
141                                           localtime.tm_mday,
142                                           localtime.tm_hour,
143                                           localtime.tm_min,
144                                           localtime.tm_sec,
145                                           (duration_cast<us_t>(src.time_since_epoch() % seconds(1))).count());
146     }
147     PYBIND11_TYPE_CASTER(type, _("datetime.datetime"));
148 };
150 // Other clocks that are not the system clock are not measured as datetime.datetime objects
151 // since they are not measured on calendar time. So instead we just make them timedeltas
152 // Or if they have passed us a time as a float we convert that
153 template <typename Clock, typename Duration> class type_caster<std::chrono::time_point<Clock, Duration>>
154 : public duration_caster<std::chrono::time_point<Clock, Duration>> {
155 };
157 template <typename Rep, typename Period> class type_caster<std::chrono::duration<Rep, Period>>
158 : public duration_caster<std::chrono::duration<Rep, Period>> {
159 };
161 NAMESPACE_END(detail)
162 NAMESPACE_END(PYBIND11_NAMESPACE)