14 #include <unordered_set>
16 #include <unordered_map>
24 #pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
29 # if defined(PYBIND11_CPP17) && __has_include(<optional>)
31 # define PYBIND11_HAS_OPTIONAL 1
34 # if defined(PYBIND11_CPP14) && (__has_include(<experimental/optional>) && \
35 !__has_include(<optional>))
36 # include <experimental/optional>
37 # define PYBIND11_HAS_EXP_OPTIONAL 1
40 # if defined(PYBIND11_CPP17) && __has_include(<variant>)
42 # define PYBIND11_HAS_VARIANT 1
44 #elif defined(_MSC_VER) && defined(PYBIND11_CPP17)
47 # define PYBIND11_HAS_OPTIONAL 1
48 # define PYBIND11_HAS_VARIANT 1
51 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
52 PYBIND11_NAMESPACE_BEGIN(detail)
56 template <typename T, typename U>
57 using forwarded_type = conditional_t<
58 std::is_lvalue_reference<T>::value, remove_reference_t<U> &, remove_reference_t<U> &&>;
62 template <typename T, typename U>
63 forwarded_type<T, U> forward_like(U &&u) {
64 return std::forward<detail::forwarded_type<T, U>>(std::forward<U>(u));
67 template <
typename Type,
typename Key>
struct set_caster {
71 bool load(
handle src,
bool convert) {
72 if (!isinstance<pybind11::set>(src))
74 auto s = reinterpret_borrow<pybind11::set>(src);
76 for (
auto entry : s) {
78 if (!conv.load(entry, convert))
80 value.insert(cast_op<Key &&>(std::move(conv)));
86 static handle cast(T &&src, return_value_policy policy,
handle parent) {
87 if (!std::is_lvalue_reference<T>::value)
88 policy = return_value_policy_override<Key>::policy(policy);
90 for (
auto &&value : src) {
91 auto value_ = reinterpret_steal<object>(key_conv::cast(forward_like<T>(value), policy, parent));
92 if (!value_ || !s.add(value_))
98 PYBIND11_TYPE_CASTER(
type, _(
"Set[") + key_conv::name + _(
"]"));
101 template <
typename Type,
typename Key,
typename Value>
struct map_caster {
105 bool load(
handle src,
bool convert) {
106 if (!isinstance<dict>(src))
108 auto d = reinterpret_borrow<dict>(src);
113 if (!kconv.load(it.first.ptr(), convert) ||
114 !vconv.load(it.second.ptr(), convert))
116 value.emplace(cast_op<Key &&>(std::move(kconv)), cast_op<Value &&>(std::move(vconv)));
121 template <
typename T>
122 static handle cast(T &&src, return_value_policy policy,
handle parent) {
124 return_value_policy policy_key = policy;
125 return_value_policy policy_value = policy;
126 if (!std::is_lvalue_reference<T>::value) {
127 policy_key = return_value_policy_override<Key>::policy(policy_key);
128 policy_value = return_value_policy_override<Value>::policy(policy_value);
130 for (
auto &&kv : src) {
131 auto key = reinterpret_steal<object>(key_conv::cast(forward_like<T>(kv.first), policy_key, parent));
132 auto value = reinterpret_steal<object>(value_conv::cast(forward_like<T>(kv.second), policy_value, parent));
140 PYBIND11_TYPE_CASTER(Type, _(
"Dict[") + key_conv::name + _(
", ") + value_conv::name + _(
"]"));
146 bool load(
handle src,
bool convert) {
147 if (!isinstance<sequence>(src) || isinstance<str>(src))
149 auto s = reinterpret_borrow<sequence>(src);
151 reserve_maybe(s, &value);
154 if (!conv.load(it, convert))
156 value.push_back(cast_op<Value &&>(std::move(conv)));
162 template <
typename T = Type,
163 enable_if_t<std::is_same<decltype(std::declval<T>().reserve(0)),
void>::value,
int> = 0>
164 void reserve_maybe(
sequence s, Type *) { value.reserve(s.size()); }
165 void reserve_maybe(
sequence,
void *) { }
168 template <
typename T>
169 static handle cast(T &&src, return_value_policy policy,
handle parent) {
170 if (!std::is_lvalue_reference<T>::value)
171 policy = return_value_policy_override<Value>::policy(policy);
174 for (
auto &&value : src) {
175 auto value_ = reinterpret_steal<object>(value_conv::cast(forward_like<T>(value), policy, parent));
178 PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr());
183 PYBIND11_TYPE_CASTER(Type, _(
"List[") + value_conv::name + _(
"]"));
189 template <
typename Type,
typename Alloc>
struct type_caster<std::deque<Type, Alloc>>
195 template <
typename ArrayType,
typename Value,
bool Resizable,
size_t Size = 0>
struct array_caster {
199 template <
bool R = Resizable>
200 bool require_size(enable_if_t<R, size_t> size) {
201 if (value.size() != size)
205 template <
bool R = Resizable>
206 bool require_size(enable_if_t<!R, size_t> size) {
211 bool load(
handle src,
bool convert) {
212 if (!isinstance<sequence>(src))
214 auto l = reinterpret_borrow<sequence>(src);
215 if (!require_size(l.size()))
220 if (!conv.load(it, convert))
222 value[ctr++] = cast_op<Value &&>(std::move(conv));
227 template <
typename T>
228 static handle cast(T &&src, return_value_policy policy,
handle parent) {
231 for (
auto &&value : src) {
232 auto value_ = reinterpret_steal<object>(value_conv::cast(forward_like<T>(value), policy, parent));
235 PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr());
240 PYBIND11_TYPE_CASTER(ArrayType, _(
"List[") + value_conv::name + _<Resizable>(_(
""), _(
"[") + _<Size>() + _(
"]")) + _(
"]"));
244 :
array_caster<std::array<Type, Size>, Type, false, Size> { };
249 template <
typename Key,
typename Compare,
typename Alloc>
struct type_caster<std::
set<Key, Compare, Alloc>>
250 :
set_caster<std::set<Key, Compare, Alloc>, Key> { };
252 template <
typename Key,
typename Hash,
typename Equal,
typename Alloc>
struct type_caster<std::unordered_set<Key, Hash, Equal, Alloc>>
253 :
set_caster<std::unordered_set<Key, Hash, Equal, Alloc>, Key> { };
255 template <
typename Key,
typename Value,
typename Compare,
typename Alloc>
struct type_caster<std::map<Key, Value, Compare, Alloc>>
256 :
map_caster<std::map<Key, Value, Compare, Alloc>, Key, Value> { };
258 template <
typename Key,
typename Value,
typename Hash,
typename Equal,
typename Alloc>
struct type_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>>
259 :
map_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>, Key, Value> { };
265 template <
typename T_>
266 static handle cast(T_ &&src, return_value_policy policy,
handle parent) {
269 if (!std::is_lvalue_reference<T>::value) {
270 policy = return_value_policy_override<T>::policy(policy);
272 return value_conv::cast(*std::forward<T_>(src), policy, parent);
275 bool load(
handle src,
bool convert) {
278 }
else if (src.is_none()) {
282 if (!inner_caster.load(src, convert))
285 value.emplace(cast_op<typename T::value_type &&>(std::move(inner_caster)));
289 PYBIND11_TYPE_CASTER(T, _(
"Optional[") + value_conv::name + _(
"]"));
292 #if defined(PYBIND11_HAS_OPTIONAL)
293 template<
typename T>
struct type_caster<std::optional<T>>
300 #if defined(PYBIND11_HAS_EXP_OPTIONAL)
301 template<
typename T>
struct type_caster<std::experimental::optional<T>>
304 template<>
struct type_caster<std::experimental::nullopt_t>
305 :
public void_caster<std::experimental::nullopt_t> {};
310 return_value_policy policy;
315 template <
typename T>
325 template <
template<
typename...>
class Variant>
327 template <
typename... Args>
328 static auto call(Args &&...
args) -> decltype(visit(std::forward<Args>(
args)...)) {
329 return visit(std::forward<Args>(
args)...);
336 template <
template<
typename...>
class V,
typename... Ts>
338 static_assert(
sizeof...(Ts) > 0,
"Variant must consist of at least one alternative.");
340 template <
typename U,
typename... Us>
343 if (caster.load(src, convert)) {
344 value = cast_op<U>(caster);
352 bool load(
handle src,
bool convert) {
362 template <
typename Variant>
363 static handle cast(Variant &&src, return_value_policy policy,
handle parent) {
365 std::forward<Variant>(src));
368 using Type = V<Ts...>;
372 #if defined(PYBIND11_HAS_VARIANT)
373 template <
typename... Ts>
377 PYBIND11_NAMESPACE_END(detail)
379 inline std::ostream &operator<<(std::ostream &os, const
handle &obj) {
380 os << (std::string)
str(obj);
384 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
386 #if defined(_MSC_VER)
Helper template which holds a list of types.
const handle & inc_ref() const &
Visit a variant and cast any found type to Python.