mirror of
https://github.com/boostorg/python.git
synced 2026-01-21 17:12:22 +00:00
304277b806
Started 2008-05-25 by hohehohe2@gmail.com. Excerpts: If char const* is passed to objecjt.attr(), it uses PyObject_GetAttrStrng() or PyObject_SetAttrStrng(). If object is passed to objecjt.attr(), it takes the object as a Python string object and uses PyObject_GetAttr() or PyObject_SetAttr(). If attr() behaves like this, it can be useful when there are lots of objects which you know have the same attribute name. You can save time by first making a boost::python::object and passing it to every object's attr() inside a loop. I just made a bit of modification to boost:python locally and did a quick test, like test 1: for(int i = 0; i < n; ++i) { omain.attr(attrname) = 444; //attrname is a char const* } test 2: for(int i = 0; i < n; ++i) { object o = omain.attr(attrname); //attrname is a char const* } test 3: for(int i = 0; i < n; ++i) { omain.attr(oaaaa) = 444; //oaaaa is boost::python::object that represents a string } test 4: for(int i = 0; i < n; ++i) { object o = omain.attr(oaaaa); //oaaaa is boost::python::object that represents a string } and it reasonably reflected the difference between PyObject_*Attr() and PyObject_*AttrString. test 1 :2783ms test 2 :2357ms test 3 :1882ms test 4 :1267ms test5: PyObject_SetAttrString(po_main, "aaaa", po_num444); test6: Py_DECREF(PyObject_GetAttrString(po_main, "aaaa")); test7: PyObject_SetAttr(po_main, po_aaaa, po_num444); test8: Py_DECREF(PyObject_GetAttr(po_main, po_aaaa)); (po_ prefixed variables are PyObject*), all inside each for loop, and the results were test 5 :2410ms test 6 :2277ms test 7 :1629ms test 8 :1094ms It's boost 1.35.0, Python 2.5 on linux(gcc4.1.2). I also did the same test on windows(vs8) and the tendency was not so different. [SVN r45918]
387 lines
8.7 KiB
C++
387 lines
8.7 KiB
C++
// Copyright David Abrahams 2002.
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
#include <boost/python/module.hpp>
|
|
#include <boost/python/def.hpp>
|
|
#include <boost/python/object.hpp>
|
|
#include <boost/python/class.hpp>
|
|
|
|
using namespace boost::python;
|
|
|
|
class NotCopyable
|
|
{
|
|
} not_copyable;
|
|
|
|
object ref_to_noncopyable()
|
|
{
|
|
return object(boost::ref(not_copyable));
|
|
}
|
|
|
|
object call_object_3(object f)
|
|
{
|
|
return f(3);
|
|
}
|
|
|
|
object message()
|
|
{
|
|
return object("hello, world!");
|
|
}
|
|
|
|
object number()
|
|
{
|
|
return object(42);
|
|
}
|
|
|
|
object obj_getattr(object x, char const* name)
|
|
{
|
|
return x.attr(name);
|
|
}
|
|
|
|
object obj_objgetattr(object x, object const& name)
|
|
{
|
|
return x.attr(name);
|
|
}
|
|
|
|
object obj_const_getattr(object const& x, char const* name)
|
|
{
|
|
return x.attr(name);
|
|
}
|
|
|
|
object obj_const_objgetattr(object const& x, object const& name)
|
|
{
|
|
return x.attr(name);
|
|
}
|
|
|
|
void obj_setattr(object x, char const* name, object value)
|
|
{
|
|
x.attr(name) = value;
|
|
}
|
|
|
|
void obj_objsetattr(object x, object const& name, object value)
|
|
{
|
|
x.attr(name) = value;
|
|
}
|
|
|
|
void obj_setattr42(object x, char const* name)
|
|
{
|
|
x.attr(name) = 42;
|
|
}
|
|
|
|
void obj_objsetattr42(object x, object const& name)
|
|
{
|
|
x.attr(name) = 42;
|
|
}
|
|
|
|
void obj_moveattr(object& x, char const* src, char const* dst)
|
|
{
|
|
x.attr(dst) = x.attr(src);
|
|
}
|
|
|
|
void obj_objmoveattr(object& x, object const& src, object const& dst)
|
|
{
|
|
x.attr(dst) = x.attr(src);
|
|
}
|
|
|
|
void obj_delattr(object x, char const* name)
|
|
{
|
|
x.attr(name).del();
|
|
}
|
|
|
|
void obj_objdelattr(object x, object const& name)
|
|
{
|
|
x.attr(name).del();
|
|
}
|
|
|
|
object obj_getitem(object x, object key)
|
|
{
|
|
return x[key];
|
|
}
|
|
|
|
object obj_getitem3(object x)
|
|
{
|
|
return x[3];
|
|
}
|
|
|
|
object obj_const_getitem(object const& x, object key)
|
|
{
|
|
return x[key];
|
|
}
|
|
|
|
void obj_setitem(object x, object key, object value)
|
|
{
|
|
x[key] = value;
|
|
}
|
|
|
|
void obj_setitem42(object x, object key)
|
|
{
|
|
x[key] = 42;
|
|
}
|
|
|
|
void obj_moveitem(object& x, object src, object dst)
|
|
{
|
|
x[dst] = x[src];
|
|
}
|
|
|
|
void obj_moveitem2(object const& x_src, object k_src, object& x_dst, object k_dst)
|
|
{
|
|
x_dst[k_dst] = x_src[k_src];
|
|
}
|
|
|
|
bool test(object y)
|
|
{
|
|
return y;
|
|
}
|
|
|
|
bool test_not(object y)
|
|
{
|
|
return !y;
|
|
}
|
|
|
|
bool test_attr(object y, char* name)
|
|
{
|
|
return y.attr(name);
|
|
}
|
|
|
|
bool test_objattr(object y, object& name)
|
|
{
|
|
return y.attr(name);
|
|
}
|
|
|
|
bool test_not_attr(object y, char* name)
|
|
{
|
|
return !y.attr(name);
|
|
}
|
|
|
|
bool test_not_objattr(object y, object& name)
|
|
{
|
|
return !y.attr(name);
|
|
}
|
|
|
|
bool test_item(object y, object key)
|
|
{
|
|
return y[key];
|
|
}
|
|
|
|
bool test_not_item(object y, object key)
|
|
{
|
|
return !y[key];
|
|
}
|
|
|
|
bool check_string_slice()
|
|
{
|
|
object s("hello, world");
|
|
|
|
if (s.slice(_,-3) != "hello, wo")
|
|
return false;
|
|
|
|
if (s.slice(-3,_) != "rld")
|
|
return false;
|
|
|
|
if (s.slice(_,_) != s)
|
|
return false;
|
|
|
|
if (", " != s.slice(5,7))
|
|
return false;
|
|
|
|
return s.slice(2,-1).slice(1,-1) == "lo, wor";
|
|
}
|
|
|
|
bool check_binary_operators()
|
|
{
|
|
int y;
|
|
|
|
object x(3);
|
|
|
|
#define TEST_BINARY(op) \
|
|
for (y = 1; y < 6; ++y) \
|
|
{ \
|
|
if ((x op y) != (3 op y)) \
|
|
return false; \
|
|
} \
|
|
for (y = 1; y < 6; ++y) \
|
|
{ \
|
|
if ((y op x) != (y op 3)) \
|
|
return false; \
|
|
} \
|
|
for (y = 1; y < 6; ++y) \
|
|
{ \
|
|
object oy(y); \
|
|
if ((oy op x) != (oy op 3)) \
|
|
return false; \
|
|
}
|
|
TEST_BINARY(>)
|
|
TEST_BINARY(>=)
|
|
TEST_BINARY(<)
|
|
TEST_BINARY(<=)
|
|
TEST_BINARY(==)
|
|
TEST_BINARY(!=)
|
|
|
|
TEST_BINARY(+)
|
|
TEST_BINARY(-)
|
|
TEST_BINARY(*)
|
|
TEST_BINARY(/)
|
|
TEST_BINARY(%)
|
|
TEST_BINARY(<<)
|
|
TEST_BINARY(>>)
|
|
TEST_BINARY(&)
|
|
TEST_BINARY(^)
|
|
TEST_BINARY(|)
|
|
return true;
|
|
}
|
|
|
|
bool check_inplace(object l, object o)
|
|
{
|
|
int y;
|
|
#define TEST_INPLACE(op) \
|
|
for (y = 1; y < 6; ++y) \
|
|
{ \
|
|
object x(666); \
|
|
x op##= y; \
|
|
if (x != (666 op y)) \
|
|
return false; \
|
|
} \
|
|
for (y = 1; y < 6; ++y) \
|
|
{ \
|
|
object x(666); \
|
|
x op##= object(y); \
|
|
if (!(x == (666 op y))) \
|
|
return false; \
|
|
}
|
|
TEST_INPLACE(+)
|
|
TEST_INPLACE(-)
|
|
TEST_INPLACE(*)
|
|
TEST_INPLACE(/)
|
|
TEST_INPLACE(%)
|
|
TEST_INPLACE(<<)
|
|
TEST_INPLACE(>>)
|
|
TEST_INPLACE(&)
|
|
TEST_INPLACE(^)
|
|
TEST_INPLACE(|)
|
|
|
|
l += l;
|
|
for (y = 0; y < 6; ++y)
|
|
{
|
|
if (l[y] != y % 3)
|
|
return false;
|
|
}
|
|
|
|
#define TEST_ITEM_INPLACE(index, op, n, r1, r2) \
|
|
l[index] op##= n; \
|
|
if (l[index] != r1) \
|
|
return false; \
|
|
l[index] op##= object(n); \
|
|
if (!(l[index] == r2)) \
|
|
return false;
|
|
|
|
TEST_ITEM_INPLACE(0,+,7,7,14)
|
|
TEST_ITEM_INPLACE(1,-,2,-1,-3)
|
|
TEST_ITEM_INPLACE(2,*,3,6,18)
|
|
TEST_ITEM_INPLACE(2,/,2,9,4)
|
|
TEST_ITEM_INPLACE(0,%,4,2,2)
|
|
l[0] += 1;
|
|
TEST_ITEM_INPLACE(0,<<,2,12,48)
|
|
TEST_ITEM_INPLACE(0,>>,1,24,12)
|
|
l[4] = 15;
|
|
TEST_ITEM_INPLACE(4,&,(16+4+1),5,5)
|
|
TEST_ITEM_INPLACE(0,^,1,13,12)
|
|
TEST_ITEM_INPLACE(0,|,1,13,13)
|
|
|
|
o.attr("x0") = 0;
|
|
o.attr("x1") = 1;
|
|
o.attr("x2") = 2;
|
|
o.attr("x3") = 0;
|
|
o.attr("x4") = 1;
|
|
|
|
#define TEST_ATTR_INPLACE(index, op, n, r1, r2) \
|
|
o.attr("x" #index) op##= n; \
|
|
if (o.attr("x" #index) != r1) \
|
|
return false; \
|
|
o.attr("x" #index) op##= object(n); \
|
|
if (o.attr("x" #index) != r2) \
|
|
return false;
|
|
|
|
TEST_ATTR_INPLACE(0,+,7,7,14)
|
|
TEST_ATTR_INPLACE(1,-,2,-1,-3)
|
|
TEST_ATTR_INPLACE(2,*,3,6,18)
|
|
TEST_ATTR_INPLACE(2,/,2,9,4)
|
|
TEST_ATTR_INPLACE(0,%,4,2,2)
|
|
o.attr("x0") += 1;
|
|
TEST_ATTR_INPLACE(0,<<,2,12,48)
|
|
TEST_ATTR_INPLACE(0,>>,1,24,12)
|
|
o.attr("x4") = 15;
|
|
TEST_ATTR_INPLACE(4,&,(16+4+1),5,5)
|
|
TEST_ATTR_INPLACE(0,^,1,13,12)
|
|
TEST_ATTR_INPLACE(0,|,1,13,13)
|
|
|
|
if (l[0] != o.attr("x0"))
|
|
return false;
|
|
if (l[1] != o.attr("x1"))
|
|
return false;
|
|
if (l[2] != o.attr("x2"))
|
|
return false;
|
|
if (l[3] != o.attr("x3"))
|
|
return false;
|
|
if (l[4] != o.attr("x4"))
|
|
return false;
|
|
|
|
// set item 5 to be a list, by calling l.__class__
|
|
l[5] = l.attr("__class__")();
|
|
// append an element
|
|
l[5].attr("append")(2);
|
|
// Check its value
|
|
if (l[5][0] != 2)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BOOST_PYTHON_MODULE(object_ext)
|
|
{
|
|
class_<NotCopyable, boost::noncopyable>("NotCopyable", no_init);
|
|
|
|
def("ref_to_noncopyable", ref_to_noncopyable);
|
|
def("call_object_3", call_object_3);
|
|
def("message", message);
|
|
def("number", number);
|
|
|
|
def("obj_getattr", obj_getattr);
|
|
def("obj_objgetattr", obj_objgetattr);
|
|
def("obj_const_getattr", obj_const_getattr);
|
|
def("obj_const_objgetattr", obj_const_objgetattr);
|
|
def("obj_setattr", obj_setattr);
|
|
def("obj_objsetattr", obj_objsetattr);
|
|
def("obj_setattr42", obj_setattr42);
|
|
def("obj_objsetattr42", obj_objsetattr42);
|
|
def("obj_moveattr", obj_moveattr);
|
|
def("obj_objmoveattr", obj_objmoveattr);
|
|
def("obj_delattr", obj_delattr);
|
|
def("obj_objdelattr", obj_objdelattr);
|
|
|
|
def("obj_getitem", obj_getitem);
|
|
def("obj_getitem3", obj_getitem);
|
|
def("obj_const_getitem", obj_const_getitem);
|
|
def("obj_setitem", obj_setitem);
|
|
def("obj_setitem42", obj_setitem42);
|
|
def("obj_moveitem", obj_moveitem);
|
|
def("obj_moveitem2", obj_moveitem2);
|
|
|
|
def("test", test);
|
|
def("test_not", test_not);
|
|
|
|
def("test_attr", test_attr);
|
|
def("test_objattr", test_objattr);
|
|
def("test_not_attr", test_not_attr);
|
|
def("test_not_objattr", test_not_objattr);
|
|
|
|
def("test_item", test_item);
|
|
def("test_not_item", test_not_item);
|
|
|
|
def("check_binary_operators", check_binary_operators);
|
|
def("check_inplace", check_inplace);
|
|
def("check_string_slice", check_string_slice);
|
|
;
|
|
}
|
|
|
|
#include "module_tail.cpp"
|