mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-29 08:32:02 +00:00
617fbcfc1e
This commit includes the following changes:
* Don't provide make_copy_constructor for non-copyable container
make_copy_constructor currently fails for various stl containers (e.g.
std::vector, std::unordered_map, std::deque, etc.) when the container's
value type (e.g. the "T" or the std::pair<K,T> for a map) is
non-copyable. This adds an override that, for types that look like
containers, also requires that the value_type be copyable.
* stl_bind.h: make bind_{vector,map} work for non-copy-constructible types
Most stl_bind modifiers require copying, so if the type isn't copy
constructible, we provide a read-only interface instead.
In practice, this means that if the type is non-copyable, it will be,
for all intents and purposes, read-only from the Python side (but
currently it simply fails to compile with such a container).
It is still possible for the caller to provide an interface manually
(by defining methods on the returned class_ object), but this isn't
something stl_bind can handle because the C++ code to construct values
is going to be highly dependent on the container value_type.
* stl_bind: copy only for arithmetic value types
For non-primitive types, we may well be copying some complex type, when
returning by reference is more appropriate. This commit returns by
internal reference for all but basic arithmetic types.
* Return by reference whenever possible
Only if we definitely can't--i.e. std::vector<bool>--because v[i]
returns something that isn't a T& do we copy; for everything else, we
return by reference.
For the map case, we can always return by reference (at least for the
default stl map/unordered_map).
154 lines
3.3 KiB
Python
154 lines
3.3 KiB
Python
def test_vector_int():
|
|
from pybind11_tests import VectorInt
|
|
|
|
v_int = VectorInt([0, 0])
|
|
assert len(v_int) == 2
|
|
assert bool(v_int) is True
|
|
|
|
v_int2 = VectorInt([0, 0])
|
|
assert v_int == v_int2
|
|
v_int2[1] = 1
|
|
assert v_int != v_int2
|
|
|
|
v_int2.append(2)
|
|
v_int2.append(3)
|
|
v_int2.insert(0, 1)
|
|
v_int2.insert(0, 2)
|
|
v_int2.insert(0, 3)
|
|
assert str(v_int2) == "VectorInt[3, 2, 1, 0, 1, 2, 3]"
|
|
|
|
v_int.append(99)
|
|
v_int2[2:-2] = v_int
|
|
assert v_int2 == VectorInt([3, 2, 0, 0, 99, 2, 3])
|
|
del v_int2[1:3]
|
|
assert v_int2 == VectorInt([3, 0, 99, 2, 3])
|
|
del v_int2[0]
|
|
assert v_int2 == VectorInt([0, 99, 2, 3])
|
|
|
|
|
|
def test_vector_custom():
|
|
from pybind11_tests import El, VectorEl, VectorVectorEl
|
|
|
|
v_a = VectorEl()
|
|
v_a.append(El(1))
|
|
v_a.append(El(2))
|
|
assert str(v_a) == "VectorEl[El{1}, El{2}]"
|
|
|
|
vv_a = VectorVectorEl()
|
|
vv_a.append(v_a)
|
|
vv_b = vv_a[0]
|
|
assert str(vv_b) == "VectorEl[El{1}, El{2}]"
|
|
|
|
|
|
def test_vector_bool():
|
|
from pybind11_tests import VectorBool
|
|
|
|
vv_c = VectorBool()
|
|
for i in range(10):
|
|
vv_c.append(i % 2 == 0)
|
|
for i in range(10):
|
|
assert vv_c[i] == (i % 2 == 0)
|
|
assert str(vv_c) == "VectorBool[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]"
|
|
|
|
def test_map_string_double():
|
|
from pybind11_tests import MapStringDouble, UnorderedMapStringDouble
|
|
|
|
m = MapStringDouble()
|
|
m['a'] = 1
|
|
m['b'] = 2.5
|
|
|
|
keys = []
|
|
for k in m: keys.append(k)
|
|
assert keys == ['a', 'b']
|
|
|
|
key_values = []
|
|
for k, v in m.items(): key_values.append( (k, v) )
|
|
assert key_values == [('a', 1), ('b', 2.5) ]
|
|
|
|
assert str(m) == "MapStringDouble{a: 1, b: 2.5}"
|
|
|
|
|
|
um = UnorderedMapStringDouble()
|
|
um['ua'] = 1.1
|
|
um['ub'] = 2.6
|
|
|
|
keys = []
|
|
for k in um: keys.append(k)
|
|
assert sorted(keys) == ['ua', 'ub']
|
|
|
|
key_values = []
|
|
for k, v in um.items(): key_values.append( (k, v) )
|
|
assert sorted(key_values) == [('ua', 1.1), ('ub', 2.6) ]
|
|
|
|
str(um)
|
|
|
|
|
|
def test_map_string_double_const():
|
|
from pybind11_tests import MapStringDoubleConst, UnorderedMapStringDoubleConst
|
|
|
|
mc = MapStringDoubleConst()
|
|
mc['a'] = 10
|
|
mc['b'] = 20.5
|
|
assert str(mc) == "MapStringDoubleConst{a: 10, b: 20.5}"
|
|
|
|
umc = UnorderedMapStringDoubleConst()
|
|
umc['a'] = 11
|
|
umc['b'] = 21.5
|
|
|
|
str(umc)
|
|
|
|
def test_noncopyable_vector():
|
|
from pybind11_tests import ENC, get_vnc
|
|
|
|
vnc = get_vnc(5)
|
|
for i in range(0, 5):
|
|
assert(vnc[i].value == i+1)
|
|
|
|
i = 1
|
|
for j in vnc:
|
|
assert(j.value == i)
|
|
i += 1
|
|
|
|
def test_noncopyable_deque():
|
|
from pybind11_tests import ENC, get_dnc
|
|
|
|
dnc = get_dnc(5)
|
|
for i in range(0, 5):
|
|
assert(dnc[i].value == i+1)
|
|
|
|
i = 1
|
|
for j in dnc:
|
|
assert(j.value == i)
|
|
i += 1
|
|
|
|
def test_noncopyable_map():
|
|
from pybind11_tests import ENC, get_mnc
|
|
|
|
mnc = get_mnc(5)
|
|
for i in range(1, 6):
|
|
assert(mnc[i].value == 10*i)
|
|
|
|
i = 1
|
|
vsum = 0
|
|
for k, v in mnc.items():
|
|
assert(v.value == 10*k)
|
|
vsum += v.value
|
|
|
|
assert(vsum == 150)
|
|
|
|
def test_noncopyable_unordered_map():
|
|
from pybind11_tests import ENC, get_umnc
|
|
|
|
mnc = get_umnc(5)
|
|
for i in range(1, 6):
|
|
assert(mnc[i].value == 10*i)
|
|
|
|
i = 1
|
|
vsum = 0
|
|
for k, v in mnc.items():
|
|
assert(v.value == 10*k)
|
|
vsum += v.value
|
|
|
|
assert(vsum == 150)
|
|
|