Skip to content

Commit ecf7cfc

Browse files
skrahskrah
committed
Merge pull request #1 from insertinterestingnamehere/type_sep
Fix MSVC compilation errors.
2 parents cdf45f5 + fa522e0 commit ecf7cfc

2 files changed

Lines changed: 63 additions & 72 deletions

File tree

‎.clang-format‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,4 +6,4 @@ BreakBeforeBraces: Stroustrup
66
Cpp11BracedListStyle: true
77
NamespaceIndentation: Inner
88
AlwaysBreakTemplateDeclarations: true
9-
9+
ColumnLimit: 120

‎dynd/include/types/type_unpack.hpp‎

Lines changed: 62 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -14,143 +14,134 @@
1414

1515
using namespace dynd;
1616

17-
1817
// Unpack and convert a single element to a PyObject.
19-
template <typename T, typename std::enable_if_t<std::is_signed<T>::value && std::numeric_limits<T>::max() <= INT64_MAX, int> = 0>
20-
inline PyObject *
21-
unpack_single(const char *data)
18+
template <typename T,
19+
typename std::enable_if<
20+
std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) <= sizeof(long long), int>::type = 0>
21+
inline PyObject *unpack_single(const char *data)
2222
{
23-
return PyLong_FromLongLong(*reinterpret_cast<const T *>(data));
23+
return PyLong_FromLongLong(*reinterpret_cast<const T *>(data));
2424
}
2525

26-
template <typename T, std::enable_if_t<std::is_unsigned<T>::value && std::numeric_limits<T>::max() <= UINT64_MAX, int> = 0>
27-
inline PyObject *
28-
unpack_single(const char *data)
26+
template <typename T, typename std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value &&
27+
sizeof(T) <= sizeof(unsigned long long),
28+
int> = 0>
29+
inline PyObject *unpack_single(const char *data)
2930
{
30-
return PyLong_FromUnsignedLongLong(*reinterpret_cast<const T *>(data));
31+
return PyLong_FromUnsignedLongLong(*reinterpret_cast<const T *>(data));
3132
}
3233

3334
template <typename T, typename std::enable_if_t<std::is_same<T, bool1>::value, int> = 0>
34-
inline PyObject *
35-
unpack_single(const char *data)
35+
inline PyObject *unpack_single(const char *data)
3636
{
37-
return PyBool_FromLong(*reinterpret_cast<const T *>(data));
37+
return PyBool_FromLong(*reinterpret_cast<const T *>(data));
3838
}
3939

4040
template <typename T, typename std::enable_if_t<std::is_same<T, float64>::value, int> = 0>
41-
inline PyObject *
42-
unpack_single(const char *data)
41+
inline PyObject *unpack_single(const char *data)
4342
{
44-
return PyFloat_FromDouble(*reinterpret_cast<const T *>(data));
43+
return PyFloat_FromDouble(*reinterpret_cast<const T *>(data));
4544
}
4645

4746
template <typename T, typename std::enable_if_t<std::is_same<T, complex128>::value, int> = 0>
48-
inline PyObject *
49-
unpack_single(const char *data)
47+
inline PyObject *unpack_single(const char *data)
5048
{
51-
complex128 c = *reinterpret_cast<const T *>(data);
52-
return PyComplex_FromDoubles(c.real(), c.imag());
49+
complex128 c = *reinterpret_cast<const T *>(data);
50+
return PyComplex_FromDoubles(c.real(), c.imag());
5351
}
5452

5553
template <typename T, typename std::enable_if_t<std::is_same<T, std::string>::value, int> = 0>
56-
inline PyObject *
57-
unpack_single(const char *data)
54+
inline PyObject *unpack_single(const char *data)
5855
{
59-
const std::string &s = *reinterpret_cast<const T *>(data);
60-
return PyUnicode_FromString(s.data());
56+
const std::string &s = *reinterpret_cast<const T *>(data);
57+
return PyUnicode_FromString(s.data());
6158
}
6259

6360
template <typename T, typename std::enable_if_t<std::is_same<T, ndt::type>::value, int> = 0>
64-
inline PyObject *
65-
unpack_single(const char *data)
61+
inline PyObject *unpack_single(const char *data)
6662
{
67-
return pydynd::type_from_cpp(*reinterpret_cast<const T *>(data));
63+
return pydynd::type_from_cpp(*reinterpret_cast<const T *>(data));
6864
}
6965

70-
7166
// Convert a single element to a PyObject.
72-
template <typename T, typename std::enable_if_t<std::is_signed<T>::value && std::numeric_limits<T>::max() <= INT64_MAX, int> = 0>
73-
inline PyObject *
74-
convert_single(T value)
67+
template <typename T,
68+
typename std::enable_if_t<
69+
std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) <= sizeof(long long), int> = 0>
70+
inline PyObject *convert_single(T value)
7571
{
76-
return PyLong_FromLongLong(value);
72+
return PyLong_FromLongLong(value);
7773
}
7874

79-
template <typename T, typename std::enable_if_t<std::is_unsigned<T>::value && std::numeric_limits<T>::max() <= UINT64_MAX, int> = 0>
80-
inline PyObject *
81-
convert_single(T value)
75+
template <typename T, typename std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value &&
76+
sizeof(T) <= sizeof(unsigned long long),
77+
int> = 0>
78+
inline PyObject *convert_single(T value)
8279
{
83-
return PyLong_FromUnsignedLongLong(value);
80+
return PyLong_FromUnsignedLongLong(value);
8481
}
8582

8683
template <typename T, typename std::enable_if_t<std::is_same<T, bool1>::value, int> = 0>
87-
inline PyObject *
88-
convert_single(T value)
84+
inline PyObject *convert_single(T value)
8985
{
90-
return PyBool_FromLong(value);
86+
return PyBool_FromLong(value);
9187
}
9288

9389
template <typename T, typename std::enable_if_t<std::is_same<T, float64>::value, int> = 0>
94-
inline PyObject *
95-
convert_single(T value)
90+
inline PyObject *convert_single(T value)
9691
{
97-
return PyFloat_FromDouble(value);
92+
return PyFloat_FromDouble(value);
9893
}
9994

10095
template <typename T, typename std::enable_if_t<std::is_same<T, complex128>::value, int> = 0>
101-
inline PyObject *
102-
convert_single(T value)
96+
inline PyObject *convert_single(T value)
10397
{
104-
return PyComplex_FromDoubles(value.real(), value.imag());
98+
return PyComplex_FromDoubles(value.real(), value.imag());
10599
}
106100

107101
template <typename T, typename std::enable_if_t<std::is_same<T, std::string>::value, int> = 0>
108-
inline PyObject *
109-
convert_single(const T &value)
102+
inline PyObject *convert_single(const T &value)
110103
{
111-
return PyUnicode_FromString(value.data());
104+
return PyUnicode_FromString(value.data());
112105
}
113106

114107
template <typename T, typename std::enable_if_t<std::is_same<T, ndt::type>::value, int> = 0>
115-
inline PyObject *
116-
convert_single(const T &value)
108+
inline PyObject *convert_single(const T &value)
117109
{
118-
return pydynd::type_from_cpp(value);
110+
return pydynd::type_from_cpp(value);
119111
}
120112

121-
122113
template <typename T>
123114
PyObject *unpack_vector(const char *data)
124115
{
125-
auto &vec = *reinterpret_cast<const std::vector<T> *>(data);
126-
PyObject *lst, *item;
116+
auto &vec = *reinterpret_cast<const std::vector<T> *>(data);
117+
PyObject *lst, *item;
127118

128-
lst = PyList_New(vec.size());
129-
if (lst == NULL) {
130-
return NULL;
131-
}
119+
lst = PyList_New(vec.size());
120+
if (lst == NULL) {
121+
return NULL;
122+
}
132123

133-
for (size_t i = 0; i < vec.size(); ++i) {
134-
item = convert_single<T>(vec[i]);
135-
if (item == NULL) {
136-
Py_DECREF(lst);
137-
return NULL;
138-
}
139-
PyList_SET_ITEM(lst, i, item);
124+
for (size_t i = 0; i < vec.size(); ++i) {
125+
item = convert_single<T>(vec[i]);
126+
if (item == NULL) {
127+
Py_DECREF(lst);
128+
return NULL;
140129
}
130+
PyList_SET_ITEM(lst, i, item);
131+
}
141132

142-
return lst;
133+
return lst;
143134
}
144135

145136
template <typename T>
146137
inline PyObject *unpack(bool is_vector, const char *data)
147138
{
148-
if (is_vector) {
149-
return unpack_vector<T>(data);
150-
}
151-
else {
152-
return unpack_single<T>(data);
153-
}
139+
if (is_vector) {
140+
return unpack_vector<T>(data);
141+
}
142+
else {
143+
return unpack_single<T>(data);
144+
}
154145
}
155146

156147
PyObject *from_type_property(const std::pair<ndt::type, const char *> &pair)

0 commit comments

Comments
 (0)