Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-25 22:52:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

consistent macro naming throughout the project

Browse Source
This commit is contained in:
Wenzel Jakob 2015-10-18 16:48:30 +02:00
parent 041a8656af
commit b1b714023a
18 changed files with 149 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.travis.yml
View File

@ -16,7 +16,7 @@ matrix:
compiler: gcc-4.8 compiler: gcc-4.8
script: script:
- pyvenv-3.5 venv - pyvenv-3.5 venv
- cmake -DPYBIND_PYTHON_VERSION=3.5 -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.5m -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.5m.so -DPYTHON_EXECUTABLE:FILEPATH=`pwd`/venv/bin/python3.5 -DCMAKE_CXX_COMPILER=g++-4.8 - cmake -DPYBIND11_PYTHON_VERSION=3.5 -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.5m -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.5m.so -DPYTHON_EXECUTABLE:FILEPATH=`pwd`/venv/bin/python3.5 -DCMAKE_CXX_COMPILER=g++-4.8
- make -j 2 - make -j 2
- source venv/bin/activate - source venv/bin/activate
- pip install numpy - pip install numpy
@ -24,6 +24,6 @@ matrix:
- os: osx - os: osx
compiler: clang compiler: clang
script: script:
- cmake -DPYBIND_PYTHON_VERSION=2.7 - cmake -DPYBIND11_PYTHON_VERSION=2.7
- make -j 2 - make -j 2
- CTEST_OUTPUT_ON_FAILURE=TRUE make test - CTEST_OUTPUT_ON_FAILURE=TRUE make test

6
CMakeLists.txt
View File

@ -10,7 +10,7 @@ cmake_minimum_required(VERSION 2.8)
project(pybind11) project(pybind11)
# Add a CMake parameter for choosing a desired Python version # Add a CMake parameter for choosing a desired Python version
set(PYBIND_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling the example application") set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling the example application")
# Set a default build configuration if none is specified. 'MinSizeRel' produces the smallest binaries # Set a default build configuration if none is specified. 'MinSizeRel' produces the smallest binaries
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
@ -22,8 +22,8 @@ endif()
string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE) string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
set(Python_ADDITIONAL_VERSIONS 3.4 3.5 3.6) set(Python_ADDITIONAL_VERSIONS 3.4 3.5 3.6)
find_package(PythonLibs ${PYBIND_PYTHON_VERSION} REQUIRED) find_package(PythonLibs ${PYBIND11_PYTHON_VERSION} REQUIRED)
find_package(PythonInterp ${PYBIND_PYTHON_VERSION} REQUIRED) find_package(PythonInterp ${PYBIND11_PYTHON_VERSION} REQUIRED)
if (UNIX) if (UNIX)
# Enable C++11 mode # Enable C++11 mode

18
docs/advanced.rst
View File

@ -45,7 +45,7 @@ to Python.
#include <pybind11/operators.h> #include <pybind11/operators.h>
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
py::class_<Vector2>(m, "Vector2") py::class_<Vector2>(m, "Vector2")
@ -127,7 +127,7 @@ trivial to generate binding code for both of these functions.
#include <pybind11/functional.h> #include <pybind11/functional.h>
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
m.def("func_arg", &func_arg); m.def("func_arg", &func_arg);
@ -199,7 +199,7 @@ Normally, the binding code for these classes would look as follows:
.. code-block:: cpp .. code-block:: cpp
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
py::class_<Animal> animal(m, "Animal"); py::class_<Animal> animal(m, "Animal");
@ -230,7 +230,7 @@ helper class that is defined as follows:
/* Trampoline (need one for each virtual function) */ /* Trampoline (need one for each virtual function) */
std::string go(int n_times) { std::string go(int n_times) {
PYBIND_OVERLOAD_PURE( PYBIND11_OVERLOAD_PURE(
std::string, /* Return type */ std::string, /* Return type */
Animal, /* Parent class */ Animal, /* Parent class */
go, /* Name of function */ go, /* Name of function */
@ -239,15 +239,15 @@ helper class that is defined as follows:
} }
}; };
The macro :func:`PYBIND_OVERLOAD_PURE` should be used for pure virtual The macro :func:`PYBIND11_OVERLOAD_PURE` should be used for pure virtual
functions, and :func:`PYBIND_OVERLOAD` should be used for functions which have functions, and :func:`PYBIND11_OVERLOAD` should be used for functions which have
a default implementation. The binding code also needs a few minor adaptations a default implementation. The binding code also needs a few minor adaptations
(highlighted): (highlighted):
.. code-block:: cpp .. code-block:: cpp
:emphasize-lines: 4,6,7 :emphasize-lines: 4,6,7
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
py::class_<PyAnimal> animal(m, "Animal"); py::class_<PyAnimal> animal(m, "Animal");
@ -375,7 +375,7 @@ See below for an example that uses the
Internal internal; Internal internal;
}; };
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
py::class_<Example>(m, "Example") py::class_<Example>(m, "Example")
@ -441,7 +441,7 @@ be declared at the top level before any binding code:
.. code-block:: cpp .. code-block:: cpp
PYBIND_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>); PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
.. seealso:: .. seealso::

4
docs/basics.rst
View File

@ -87,7 +87,7 @@ a file named :file:`example.cpp` with the following contents:
namespace py = pybind11; namespace py = pybind11;
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
m.def("add", &add, "A function which adds two numbers"); m.def("add", &add, "A function which adds two numbers");
@ -95,7 +95,7 @@ a file named :file:`example.cpp` with the following contents:
return m.ptr(); return m.ptr();
} }
The :func:`PYBIND_PLUGIN` macro creates a function that will be called when an The :func:`PYBIND11_PLUGIN` macro creates a function that will be called when an
``import`` statement is issued from within Python. The next line creates a ``import`` statement is issued from within Python. The next line creates a
module named ``example`` (with the supplied docstring). The method module named ``example`` (with the supplied docstring). The method
:func:`module::def` generates binding code that exposes the :func:`module::def` generates binding code that exposes the

2
docs/classes.rst
View File

@ -27,7 +27,7 @@ The binding code for ``Pet`` looks as follows:
namespace py = pybind11; namespace py = pybind11;
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin"); py::module m("example", "pybind11 example plugin");
py::class_<Pet>(m, "Pet") py::class_<Pet>(m, "Pet")

4
docs/reference.rst
View File

@ -12,7 +12,7 @@ Reference
Macros Macros
====== ======
.. function:: PYBIND_PLUGIN(const char *name) .. function:: PYBIND11_PLUGIN(const char *name)
This macro creates the entry point that will be invoked when the Python This macro creates the entry point that will be invoked when the Python
interpreter imports a plugin library. Please create a interpreter imports a plugin library. Please create a
@ -21,7 +21,7 @@ Macros
.. code-block:: cpp .. code-block:: cpp
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
pybind11::module m("example", "pybind11 example plugin"); pybind11::module m("example", "pybind11 example plugin");
/// Set up bindings here /// Set up bindings here
return m.ptr(); return m.ptr();

2
example/example.cpp
View File

@ -22,7 +22,7 @@ void init_ex10(py::module &);
void init_ex11(py::module &); void init_ex11(py::module &);
void init_ex12(py::module &); void init_ex12(py::module &);
PYBIND_PLUGIN(example) { PYBIND11_PLUGIN(example) {
py::module m("example", "pybind example plugin"); py::module m("example", "pybind example plugin");
init_ex1(m); init_ex1(m);

4
example/example12.cpp
View File

@ -39,7 +39,7 @@ public:
virtual int run(int value) { virtual int run(int value) {
/* Generate wrapping code that enables native function overloading */ /* Generate wrapping code that enables native function overloading */
PYBIND_OVERLOAD( PYBIND11_OVERLOAD(
int, /* Return type */ int, /* Return type */
Example12, /* Parent class */ Example12, /* Parent class */
run, /* Name of function */ run, /* Name of function */
@ -48,7 +48,7 @@ public:
} }
virtual void pure_virtual() { virtual void pure_virtual() {
PYBIND_OVERLOAD_PURE( PYBIND11_OVERLOAD_PURE(
void, /* Return type */ void, /* Return type */
Example12, /* Parent class */ Example12, /* Parent class */
pure_virtual /* Name of function */ pure_virtual /* Name of function */

2
example/example8.cpp
View File

@ -32,7 +32,7 @@ private:
}; };
/// Make pybind aware of the ref-counted wrapper type /// Make pybind aware of the ref-counted wrapper type
PYBIND_DECLARE_HOLDER_TYPE(T, ref<T>); PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>);
Object *make_object_1() { return new MyObject(1); } Object *make_object_1() { return new MyObject(1); }
ref<Object> make_object_2() { return new MyObject(2); } ref<Object> make_object_2() { return new MyObject(2); }

66
include/pybind11/cast.h
View File

@ -25,9 +25,9 @@ NAMESPACE_BEGIN(detail)
#endif #endif
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
#define PYBIND_AS_STRING PyBytes_AsString #define PYBIND11_AS_STRING PyBytes_AsString
#else #else
#define PYBIND_AS_STRING PyString_AsString #define PYBIND11_AS_STRING PyString_AsString
#endif #endif
/** Linked list descriptor type for function signatures (produces smaller binaries /** Linked list descriptor type for function signatures (produces smaller binaries
@ -214,7 +214,7 @@ protected:
object temp; object temp;
}; };
#define PYBIND_TYPE_CASTER(type, py_name) \ #define PYBIND11_TYPE_CASTER(type, py_name) \
protected: \ protected: \
type value; \ type value; \
public: \ public: \
@ -225,7 +225,7 @@ protected:
operator type*() { return &value; } \ operator type*() { return &value; } \
operator type&() { return value; } \ operator type&() { return value; } \
#define PYBIND_TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \ #define PYBIND11_TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \
template <> class type_caster<type> { \ template <> class type_caster<type> { \
public: \ public: \
bool load(PyObject *src, bool) { \ bool load(PyObject *src, bool) { \
@ -244,7 +244,7 @@ protected:
static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \ static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \
return to_pytype((py_type) src); \ return to_pytype((py_type) src); \
} \ } \
PYBIND_TYPE_CASTER(type, #type); \ PYBIND11_TYPE_CASTER(type, #type); \
}; };
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
@ -266,27 +266,27 @@ inline unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong_Fixed(PyObject *o) {
} }
#endif #endif
PYBIND_TYPE_CASTER_NUMBER(int8_t, long, PyLong_AsLong, PyLong_FromLong) PYBIND11_TYPE_CASTER_NUMBER(int8_t, long, PyLong_AsLong, PyLong_FromLong)
PYBIND_TYPE_CASTER_NUMBER(uint8_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong) PYBIND11_TYPE_CASTER_NUMBER(uint8_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
PYBIND_TYPE_CASTER_NUMBER(int16_t, long, PyLong_AsLong, PyLong_FromLong) PYBIND11_TYPE_CASTER_NUMBER(int16_t, long, PyLong_AsLong, PyLong_FromLong)
PYBIND_TYPE_CASTER_NUMBER(uint16_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong) PYBIND11_TYPE_CASTER_NUMBER(uint16_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
PYBIND_TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong) PYBIND11_TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong)
PYBIND_TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong) PYBIND11_TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
PYBIND_TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong) PYBIND11_TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
PYBIND_TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong) PYBIND11_TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
#if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X #if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
PYBIND_TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t) PYBIND11_TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t)
PYBIND_TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t) PYBIND11_TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t)
#else #else
PYBIND_TYPE_CASTER_NUMBER(ssize_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong) PYBIND11_TYPE_CASTER_NUMBER(ssize_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
PYBIND_TYPE_CASTER_NUMBER(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong) PYBIND11_TYPE_CASTER_NUMBER(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
#endif #endif
#endif #endif
PYBIND_TYPE_CASTER_NUMBER(float, double, PyFloat_AsDouble, PyFloat_FromDouble) PYBIND11_TYPE_CASTER_NUMBER(float, double, PyFloat_AsDouble, PyFloat_FromDouble)
PYBIND_TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble) PYBIND11_TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble)
template <> class type_caster<void_type> { template <> class type_caster<void_type> {
public: public:
@ -295,7 +295,7 @@ public:
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
PYBIND_TYPE_CASTER(void_type, "None"); PYBIND11_TYPE_CASTER(void_type, "None");
}; };
template <> class type_caster<void> : public type_caster<void_type> { template <> class type_caster<void> : public type_caster<void_type> {
@ -313,7 +313,7 @@ public:
Py_INCREF(result); Py_INCREF(result);
return result; return result;
} }
PYBIND_TYPE_CASTER(bool, "bool"); PYBIND11_TYPE_CASTER(bool, "bool");
}; };
template <> class type_caster<std::string> { template <> class type_caster<std::string> {
@ -325,7 +325,7 @@ public:
object temp(PyUnicode_AsUTF8String(src), false); object temp(PyUnicode_AsUTF8String(src), false);
const char *ptr = nullptr; const char *ptr = nullptr;
if (temp) if (temp)
ptr = PYBIND_AS_STRING(temp.ptr()); ptr = PYBIND11_AS_STRING(temp.ptr());
if (!ptr) { PyErr_Clear(); return false; } if (!ptr) { PyErr_Clear(); return false; }
value = ptr; value = ptr;
return true; return true;
@ -333,7 +333,7 @@ public:
static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) { static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) {
return PyUnicode_FromString(src.c_str()); return PyUnicode_FromString(src.c_str());
} }
PYBIND_TYPE_CASTER(std::string, "str"); PYBIND11_TYPE_CASTER(std::string, "str");
}; };
template <> class type_caster<char> { template <> class type_caster<char> {
@ -345,7 +345,7 @@ public:
object temp(PyUnicode_AsUTF8String(src), false); object temp(PyUnicode_AsUTF8String(src), false);
const char *ptr = nullptr; const char *ptr = nullptr;
if (temp) if (temp)
ptr = PYBIND_AS_STRING(temp.ptr()); ptr = PYBIND11_AS_STRING(temp.ptr());
if (!ptr) { PyErr_Clear(); return false; } if (!ptr) { PyErr_Clear(); return false; }
value = ptr; value = ptr;
return true; return true;
@ -527,7 +527,7 @@ protected:
holder_type holder; holder_type holder;
}; };
#define PYBIND_DECLARE_HOLDER_TYPE(type, holder_type) \ #define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type) \
namespace pybind11 { namespace detail { \ namespace pybind11 { namespace detail { \
template <typename type> class type_caster<holder_type> \ template <typename type> class type_caster<holder_type> \
: public type_caster_holder<type, holder_type> { }; \ : public type_caster_holder<type, holder_type> { }; \
@ -543,24 +543,24 @@ public:
src.inc_ref(); src.inc_ref();
return (PyObject *) src.ptr(); return (PyObject *) src.ptr();
} }
PYBIND_TYPE_CASTER(handle, "handle"); PYBIND11_TYPE_CASTER(handle, "handle");
}; };
#define PYBIND_TYPE_CASTER_PYTYPE(name) \ #define PYBIND11_TYPE_CASTER_PYTYPE(name) \
template <> class type_caster<name> { \ template <> class type_caster<name> { \
public: \ public: \
bool load(PyObject *src, bool) { value = name(src, true); return true; } \ bool load(PyObject *src, bool) { value = name(src, true); return true; } \
static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \ static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \
src.inc_ref(); return (PyObject *) src.ptr(); \ src.inc_ref(); return (PyObject *) src.ptr(); \
} \ } \
PYBIND_TYPE_CASTER(name, #name); \ PYBIND11_TYPE_CASTER(name, #name); \
}; };
PYBIND_TYPE_CASTER_PYTYPE(object) PYBIND_TYPE_CASTER_PYTYPE(buffer) PYBIND11_TYPE_CASTER_PYTYPE(object) PYBIND11_TYPE_CASTER_PYTYPE(buffer)
PYBIND_TYPE_CASTER_PYTYPE(capsule) PYBIND_TYPE_CASTER_PYTYPE(dict) PYBIND11_TYPE_CASTER_PYTYPE(capsule) PYBIND11_TYPE_CASTER_PYTYPE(dict)
PYBIND_TYPE_CASTER_PYTYPE(float_) PYBIND_TYPE_CASTER_PYTYPE(int_) PYBIND11_TYPE_CASTER_PYTYPE(float_) PYBIND11_TYPE_CASTER_PYTYPE(int_)
PYBIND_TYPE_CASTER_PYTYPE(list) PYBIND_TYPE_CASTER_PYTYPE(slice) PYBIND11_TYPE_CASTER_PYTYPE(list) PYBIND11_TYPE_CASTER_PYTYPE(slice)
PYBIND_TYPE_CASTER_PYTYPE(tuple) PYBIND_TYPE_CASTER_PYTYPE(function) PYBIND11_TYPE_CASTER_PYTYPE(tuple) PYBIND11_TYPE_CASTER_PYTYPE(function)
NAMESPACE_END(detail) NAMESPACE_END(detail)

22
include/pybind11/common.h
View File

@ -16,11 +16,11 @@
#define NAMESPACE_END(name) } #define NAMESPACE_END(name) }
#endif #endif
#if !defined(PYBIND_EXPORT) #if !defined(PYBIND11_EXPORT)
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
#define PYBIND_EXPORT __declspec(dllexport) #define PYBIND11_EXPORT __declspec(dllexport)
#else #else
#define PYBIND_EXPORT __attribute__ ((visibility("default"))) #define PYBIND11_EXPORT __attribute__ ((visibility("default")))
#endif #endif
#endif #endif
@ -61,11 +61,11 @@
#endif #endif
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
#define PYBIND_PLUGIN(name) \ #define PYBIND11_PLUGIN(name) \
extern "C" PYBIND_EXPORT PyObject *PyInit_##name() extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
#else #else
#define PYBIND_PLUGIN(name) \ #define PYBIND11_PLUGIN(name) \
extern "C" PYBIND_EXPORT PyObject *init##name() extern "C" PYBIND11_EXPORT PyObject *init##name()
#endif #endif
NAMESPACE_BEGIN(pybind11) NAMESPACE_BEGIN(pybind11)
@ -93,10 +93,10 @@ enum class return_value_policy : int {
/// Format strings for basic number types /// Format strings for basic number types
template <typename type> struct format_descriptor { }; template <typename type> struct format_descriptor { };
#define PYBIND_DECL_FMT(t, n) template<> struct format_descriptor<t> { static std::string value() { return n; }; }; #define PYBIND11_DECL_FMT(t, n) template<> struct format_descriptor<t> { static std::string value() { return n; }; };
PYBIND_DECL_FMT(int8_t, "b"); PYBIND_DECL_FMT(uint8_t, "B"); PYBIND_DECL_FMT(int16_t, "h"); PYBIND_DECL_FMT(uint16_t, "H"); PYBIND11_DECL_FMT(int8_t, "b"); PYBIND11_DECL_FMT(uint8_t, "B"); PYBIND11_DECL_FMT(int16_t, "h"); PYBIND11_DECL_FMT(uint16_t, "H");
PYBIND_DECL_FMT(int32_t, "i"); PYBIND_DECL_FMT(uint32_t, "I"); PYBIND_DECL_FMT(int64_t, "q"); PYBIND_DECL_FMT(uint64_t, "Q"); PYBIND11_DECL_FMT(int32_t, "i"); PYBIND11_DECL_FMT(uint32_t, "I"); PYBIND11_DECL_FMT(int64_t, "q"); PYBIND11_DECL_FMT(uint64_t, "Q");
PYBIND_DECL_FMT(float, "f"); PYBIND_DECL_FMT(double, "d"); PYBIND_DECL_FMT(bool, "?"); PYBIND11_DECL_FMT(float, "f"); PYBIND11_DECL_FMT(double, "d"); PYBIND11_DECL_FMT(bool, "?");
/// Information record describing a Python buffer object /// Information record describing a Python buffer object
struct buffer_info { struct buffer_info {

6
include/pybind11/complex.h
View File

@ -14,8 +14,8 @@
NAMESPACE_BEGIN(pybind11) NAMESPACE_BEGIN(pybind11)
PYBIND_DECL_FMT(std::complex<float>, "Zf"); PYBIND11_DECL_FMT(std::complex<float>, "Zf");
PYBIND_DECL_FMT(std::complex<double>, "Zd"); PYBIND11_DECL_FMT(std::complex<double>, "Zd");
NAMESPACE_BEGIN(detail) NAMESPACE_BEGIN(detail)
template <typename T> class type_caster<std::complex<T>> { template <typename T> class type_caster<std::complex<T>> {
@ -34,7 +34,7 @@ public:
return PyComplex_FromDoubles((double) src.real(), (double) src.imag()); return PyComplex_FromDoubles((double) src.real(), (double) src.imag());
} }
PYBIND_TYPE_CASTER(std::complex<T>, "complex"); PYBIND11_TYPE_CASTER(std::complex<T>, "complex");
}; };
NAMESPACE_END(detail) NAMESPACE_END(detail)
NAMESPACE_END(pybind11) NAMESPACE_END(pybind11)

2
include/pybind11/functional.h
View File

@ -39,7 +39,7 @@ public:
} }
PYBIND_TYPE_CASTER(type, detail::descr("function<") + PYBIND11_TYPE_CASTER(type, detail::descr("function<") +
type_caster<std::tuple<Args...>>::name() + detail::descr(" -> ") + type_caster<std::tuple<Args...>>::name() + detail::descr(" -> ") +
type_caster<typename decay<Return>::type>::name() + type_caster<typename decay<Return>::type>::name() +
detail::descr(">")); detail::descr(">"));

22
include/pybind11/numpy.h
View File

@ -76,7 +76,7 @@ public:
PyObject *(*PyArray_FromAny) (PyObject *, PyObject *, int, int, int, PyObject *); PyObject *(*PyArray_FromAny) (PyObject *, PyObject *, int, int, int, PyObject *);
}; };
PYBIND_OBJECT_DEFAULT(array, buffer, lookup_api().PyArray_Check) PYBIND11_OBJECT_DEFAULT(array, buffer, lookup_api().PyArray_Check)
template <typename Type> array(size_t size, const Type *ptr) { template <typename Type> array(size_t size, const Type *ptr) {
API& api = lookup_api(); API& api = lookup_api();
@ -126,7 +126,7 @@ protected:
template <typename T> class array_t : public array { template <typename T> class array_t : public array {
public: public:
PYBIND_OBJECT_CVT(array_t, array, is_non_null, m_ptr = ensure(m_ptr)); PYBIND11_OBJECT_CVT(array_t, array, is_non_null, m_ptr = ensure(m_ptr));
array_t() : array() { } array_t() : array() { }
static bool is_non_null(PyObject *ptr) { return ptr != nullptr; } static bool is_non_null(PyObject *ptr) { return ptr != nullptr; }
PyObject *ensure(PyObject *ptr) { PyObject *ensure(PyObject *ptr) {
@ -150,15 +150,15 @@ DECL_FMT(std::complex<double>, NPY_CDOUBLE);
NAMESPACE_BEGIN(detail) NAMESPACE_BEGIN(detail)
PYBIND_TYPE_CASTER_PYTYPE(array) PYBIND11_TYPE_CASTER_PYTYPE(array)
PYBIND_TYPE_CASTER_PYTYPE(array_t<int8_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint8_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<int8_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint8_t>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<int16_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint16_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<int16_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint16_t>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<int32_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint32_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<int32_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint32_t>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<int64_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint64_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<int64_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint64_t>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<float>) PYBIND_TYPE_CASTER_PYTYPE(array_t<double>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<float>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<double>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<std::complex<float>>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<std::complex<float>>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<std::complex<double>>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<std::complex<double>>)
PYBIND_TYPE_CASTER_PYTYPE(array_t<bool>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<bool>)
template <typename Func, typename Return, typename... Args> template <typename Func, typename Return, typename... Args>
struct vectorize_helper { struct vectorize_helper {

82
include/pybind11/operators.h
View File

@ -59,7 +59,7 @@ template <op_id id, op_type ot, typename L, typename R> struct op_ {
} }
}; };
#define PYBIND_BINARY_OPERATOR(id, rid, op, expr) \ #define PYBIND11_BINARY_OPERATOR(id, rid, op, expr) \
template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \ template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
static char const* name() { return "__" #id "__"; } \ static char const* name() { return "__" #id "__"; } \
static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \ static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \
@ -80,7 +80,7 @@ template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &
return op_<op_##id, op_r, T, self_t>(); \ return op_<op_##id, op_r, T, self_t>(); \
}; };
#define PYBIND_INPLACE_OPERATOR(id, op, expr) \ #define PYBIND11_INPLACE_OPERATOR(id, op, expr) \
template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \ template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
static char const* name() { return "__" #id "__"; } \ static char const* name() { return "__" #id "__"; } \
static auto execute(L &l, const R &r) -> decltype(expr) { return expr; } \ static auto execute(L &l, const R &r) -> decltype(expr) { return expr; } \
@ -90,7 +90,7 @@ template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &
return op_<op_##id, op_l, self_t, T>(); \ return op_<op_##id, op_l, self_t, T>(); \
}; };
#define PYBIND_UNARY_OPERATOR(id, op, expr) \ #define PYBIND11_UNARY_OPERATOR(id, op, expr) \
template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> { \ template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> { \
static char const* name() { return "__" #id "__"; } \ static char const* name() { return "__" #id "__"; } \
static auto execute(const L &l) -> decltype(expr) { return expr; } \ static auto execute(const L &l) -> decltype(expr) { return expr; } \
@ -100,48 +100,48 @@ inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {
return op_<op_##id, op_u, self_t, undefined_t>(); \ return op_<op_##id, op_u, self_t, undefined_t>(); \
}; };
PYBIND_BINARY_OPERATOR(sub, rsub, operator-, l - r) PYBIND11_BINARY_OPERATOR(sub, rsub, operator-, l - r)
PYBIND_BINARY_OPERATOR(add, radd, operator+, l + r) PYBIND11_BINARY_OPERATOR(add, radd, operator+, l + r)
PYBIND_BINARY_OPERATOR(mul, rmul, operator*, l * r) PYBIND11_BINARY_OPERATOR(mul, rmul, operator*, l * r)
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
PYBIND_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r) PYBIND11_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r)
#else #else
PYBIND_BINARY_OPERATOR(div, rdiv, operator/, l / r) PYBIND11_BINARY_OPERATOR(div, rdiv, operator/, l / r)
#endif #endif
PYBIND_BINARY_OPERATOR(mod, rmod, operator%, l % r) PYBIND11_BINARY_OPERATOR(mod, rmod, operator%, l % r)
PYBIND_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r) PYBIND11_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r)
PYBIND_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r) PYBIND11_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r)
PYBIND_BINARY_OPERATOR(and, rand, operator&, l & r) PYBIND11_BINARY_OPERATOR(and, rand, operator&, l & r)
PYBIND_BINARY_OPERATOR(xor, rxor, operator^, l ^ r) PYBIND11_BINARY_OPERATOR(xor, rxor, operator^, l ^ r)
PYBIND_BINARY_OPERATOR(eq, eq, operator==, l == r) PYBIND11_BINARY_OPERATOR(eq, eq, operator==, l == r)
PYBIND_BINARY_OPERATOR(ne, ne, operator!=, l != r) PYBIND11_BINARY_OPERATOR(ne, ne, operator!=, l != r)
PYBIND_BINARY_OPERATOR(or, ror, operator|, l | r) PYBIND11_BINARY_OPERATOR(or, ror, operator|, l | r)
PYBIND_BINARY_OPERATOR(gt, lt, operator>, l > r) PYBIND11_BINARY_OPERATOR(gt, lt, operator>, l > r)
PYBIND_BINARY_OPERATOR(ge, le, operator>=, l >= r) PYBIND11_BINARY_OPERATOR(ge, le, operator>=, l >= r)
PYBIND_BINARY_OPERATOR(lt, gt, operator<, l < r) PYBIND11_BINARY_OPERATOR(lt, gt, operator<, l < r)
PYBIND_BINARY_OPERATOR(le, ge, operator<=, l <= r) PYBIND11_BINARY_OPERATOR(le, ge, operator<=, l <= r)
//PYBIND_BINARY_OPERATOR(pow, rpow, pow, std::pow(l, r)) //PYBIND11_BINARY_OPERATOR(pow, rpow, pow, std::pow(l, r))
PYBIND_INPLACE_OPERATOR(iadd, operator+=, l += r) PYBIND11_INPLACE_OPERATOR(iadd, operator+=, l += r)
PYBIND_INPLACE_OPERATOR(isub, operator-=, l -= r) PYBIND11_INPLACE_OPERATOR(isub, operator-=, l -= r)
PYBIND_INPLACE_OPERATOR(imul, operator*=, l *= r) PYBIND11_INPLACE_OPERATOR(imul, operator*=, l *= r)
PYBIND_INPLACE_OPERATOR(idiv, operator/=, l /= r) PYBIND11_INPLACE_OPERATOR(idiv, operator/=, l /= r)
PYBIND_INPLACE_OPERATOR(imod, operator%=, l %= r) PYBIND11_INPLACE_OPERATOR(imod, operator%=, l %= r)
PYBIND_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r) PYBIND11_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r)
PYBIND_INPLACE_OPERATOR(irshift, operator>>=, l >>= r) PYBIND11_INPLACE_OPERATOR(irshift, operator>>=, l >>= r)
PYBIND_INPLACE_OPERATOR(iand, operator&=, l &= r) PYBIND11_INPLACE_OPERATOR(iand, operator&=, l &= r)
PYBIND_INPLACE_OPERATOR(ixor, operator^=, l ^= r) PYBIND11_INPLACE_OPERATOR(ixor, operator^=, l ^= r)
PYBIND_INPLACE_OPERATOR(ior, operator|=, l |= r) PYBIND11_INPLACE_OPERATOR(ior, operator|=, l |= r)
PYBIND_UNARY_OPERATOR(neg, operator-, -l) PYBIND11_UNARY_OPERATOR(neg, operator-, -l)
PYBIND_UNARY_OPERATOR(pos, operator+, +l) PYBIND11_UNARY_OPERATOR(pos, operator+, +l)
PYBIND_UNARY_OPERATOR(abs, abs, std::abs(l)) PYBIND11_UNARY_OPERATOR(abs, abs, std::abs(l))
PYBIND_UNARY_OPERATOR(invert, operator~, ~l) PYBIND11_UNARY_OPERATOR(invert, operator~, ~l)
PYBIND_UNARY_OPERATOR(bool, operator!, !!l) PYBIND11_UNARY_OPERATOR(bool, operator!, !!l)
PYBIND_UNARY_OPERATOR(int, int_, (int) l) PYBIND11_UNARY_OPERATOR(int, int_, (int) l)
PYBIND_UNARY_OPERATOR(float, float_, (double) l) PYBIND11_UNARY_OPERATOR(float, float_, (double) l)
#undef PYBIND_BINARY_OPERATOR #undef PYBIND11_BINARY_OPERATOR
#undef PYBIND_INPLACE_OPERATOR #undef PYBIND11_INPLACE_OPERATOR
#undef PYBIND_UNARY_OPERATOR #undef PYBIND11_UNARY_OPERATOR
NAMESPACE_END(detail) NAMESPACE_END(detail)
using detail::self; using detail::self;

16
include/pybind11/pybind11.h
View File

@ -429,7 +429,7 @@ private:
class module : public object { class module : public object {
public: public:
PYBIND_OBJECT_DEFAULT(module, object, PyModule_Check) PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
module(const char *name, const char *doc = nullptr) { module(const char *name, const char *doc = nullptr) {
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
@ -476,7 +476,7 @@ NAMESPACE_BEGIN(detail)
/// Basic support for creating new Python heap types /// Basic support for creating new Python heap types
class custom_type : public object { class custom_type : public object {
public: public:
PYBIND_OBJECT_DEFAULT(custom_type, object, PyType_Check) PYBIND11_OBJECT_DEFAULT(custom_type, object, PyType_Check)
custom_type(object &scope, const char *name_, const std::type_info *tinfo, custom_type(object &scope, const char *name_, const std::type_info *tinfo,
size_t type_size, size_t instance_size, size_t type_size, size_t instance_size,
@ -667,7 +667,7 @@ template <typename type, typename holder_type = std::unique_ptr<type>> class cla
public: public:
typedef detail::instance<type, holder_type> instance_type; typedef detail::instance<type, holder_type> instance_type;
PYBIND_OBJECT(class_, detail::custom_type, PyType_Check) PYBIND11_OBJECT(class_, detail::custom_type, PyType_Check)
class_(object &scope, const char *name, const char *doc = nullptr) class_(object &scope, const char *name, const char *doc = nullptr)
: detail::custom_type(scope, name, &typeid(type), sizeof(type), : detail::custom_type(scope, name, &typeid(type), sizeof(type),
@ -925,18 +925,18 @@ inline function get_overload(const void *this_ptr, const char *name) {
return overload; return overload;
} }
#define PYBIND_OVERLOAD_INT(ret_type, class_name, name, ...) { \ #define PYBIND11_OVERLOAD_INT(ret_type, class_name, name, ...) { \
pybind11::gil_scoped_acquire gil; \ pybind11::gil_scoped_acquire gil; \
pybind11::function overload = pybind11::get_overload(this, #name); \ pybind11::function overload = pybind11::get_overload(this, #name); \
if (overload) \ if (overload) \
return overload.call(__VA_ARGS__).cast<ret_type>(); } return overload.call(__VA_ARGS__).cast<ret_type>(); }
#define PYBIND_OVERLOAD(ret_type, class_name, name, ...) \ #define PYBIND11_OVERLOAD(ret_type, class_name, name, ...) \
PYBIND_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \ PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
return class_name::name(__VA_ARGS__) return class_name::name(__VA_ARGS__)
#define PYBIND_OVERLOAD_PURE(ret_type, class_name, name, ...) \ #define PYBIND11_OVERLOAD_PURE(ret_type, class_name, name, ...) \
PYBIND_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \ PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
throw std::runtime_error("Tried to call pure virtual function \"" #name "\""); throw std::runtime_error("Tried to call pure virtual function \"" #name "\"");
NAMESPACE_END(pybind11) NAMESPACE_END(pybind11)

32
include/pybind11/pytypes.h
View File

@ -195,7 +195,7 @@ inline detail::accessor handle::operator[](const char *key) { return detail::acc
inline detail::accessor handle::attr(handle key) { return detail::accessor(ptr(), key.ptr(), true); } inline detail::accessor handle::attr(handle key) { return detail::accessor(ptr(), key.ptr(), true); }
inline detail::accessor handle::attr(const char *key) { return detail::accessor(ptr(), key, true); } inline detail::accessor handle::attr(const char *key) { return detail::accessor(ptr(), key, true); }
#define PYBIND_OBJECT_CVT(Name, Parent, CheckFun, CvtStmt) \ #define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, CvtStmt) \
Name(const handle &h, bool borrowed) : Parent(h, borrowed) { CvtStmt; } \ Name(const handle &h, bool borrowed) : Parent(h, borrowed) { CvtStmt; } \
Name(const object& o): Parent(o) { CvtStmt; } \ Name(const object& o): Parent(o) { CvtStmt; } \
Name(object&& o): Parent(std::move(o)) { CvtStmt; } \ Name(object&& o): Parent(std::move(o)) { CvtStmt; } \
@ -203,16 +203,16 @@ inline detail::accessor handle::attr(const char *key) { return detail::accessor(
Name& operator=(object& o) { return static_cast<Name&>(object::operator=(o)); CvtStmt; } \ Name& operator=(object& o) { return static_cast<Name&>(object::operator=(o)); CvtStmt; } \
bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); }
#define PYBIND_OBJECT(Name, Parent, CheckFun) \ #define PYBIND11_OBJECT(Name, Parent, CheckFun) \
PYBIND_OBJECT_CVT(Name, Parent, CheckFun, ) PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, )
#define PYBIND_OBJECT_DEFAULT(Name, Parent, CheckFun) \ #define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \
PYBIND_OBJECT(Name, Parent, CheckFun) \ PYBIND11_OBJECT(Name, Parent, CheckFun) \
Name() : Parent() { } Name() : Parent() { }
class str : public object { class str : public object {
public: public:
PYBIND_OBJECT_DEFAULT(str, object, PyUnicode_Check) PYBIND11_OBJECT_DEFAULT(str, object, PyUnicode_Check)
str(const char *s) : object(PyUnicode_FromString(s), false) { } str(const char *s) : object(PyUnicode_FromString(s), false) { }
operator const char *() const { operator const char *() const {
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
@ -241,13 +241,13 @@ inline pybind11::str handle::str() const {
class bool_ : public object { class bool_ : public object {
public: public:
PYBIND_OBJECT_DEFAULT(bool_, object, PyBool_Check) PYBIND11_OBJECT_DEFAULT(bool_, object, PyBool_Check)
operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; } operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; }
}; };
class int_ : public object { class int_ : public object {
public: public:
PYBIND_OBJECT_DEFAULT(int_, object, PyLong_Check) PYBIND11_OBJECT_DEFAULT(int_, object, PyLong_Check)
int_(int value) : object(PyLong_FromLong((long) value), false) { } int_(int value) : object(PyLong_FromLong((long) value), false) { }
int_(size_t value) : object(PyLong_FromSize_t(value), false) { } int_(size_t value) : object(PyLong_FromSize_t(value), false) { }
#if !defined(WIN32) || defined(_WIN64) #if !defined(WIN32) || defined(_WIN64)
@ -258,7 +258,7 @@ public:
class float_ : public object { class float_ : public object {
public: public:
PYBIND_OBJECT_DEFAULT(float_, object, PyFloat_Check) PYBIND11_OBJECT_DEFAULT(float_, object, PyFloat_Check)
float_(float value) : object(PyFloat_FromDouble((double) value), false) { } float_(float value) : object(PyFloat_FromDouble((double) value), false) { }
float_(double value) : object(PyFloat_FromDouble((double) value), false) { } float_(double value) : object(PyFloat_FromDouble((double) value), false) { }
operator float() const { return (float) PyFloat_AsDouble(m_ptr); } operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
@ -267,7 +267,7 @@ public:
class slice : public object { class slice : public object {
public: public:
PYBIND_OBJECT_DEFAULT(slice, object, PySlice_Check) PYBIND11_OBJECT_DEFAULT(slice, object, PySlice_Check)
slice(ssize_t start_, ssize_t stop_, ssize_t step_) { slice(ssize_t start_, ssize_t stop_, ssize_t step_) {
int_ start(start_), stop(stop_), step(step_); int_ start(start_), stop(stop_), step(step_);
m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr()); m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
@ -285,7 +285,7 @@ public:
class capsule : public object { class capsule : public object {
public: public:
PYBIND_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact) PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
capsule(PyObject *obj, bool borrowed) : object(obj, borrowed) { } capsule(PyObject *obj, bool borrowed) : object(obj, borrowed) { }
capsule(void *value, void (*destruct)(PyObject *) = nullptr) : object(PyCapsule_New(value, nullptr, destruct), false) { } capsule(void *value, void (*destruct)(PyObject *) = nullptr) : object(PyCapsule_New(value, nullptr, destruct), false) { }
template <typename T> operator T *() const { template <typename T> operator T *() const {
@ -297,7 +297,7 @@ public:
class tuple : public object { class tuple : public object {
public: public:
PYBIND_OBJECT_DEFAULT(tuple, object, PyTuple_Check) PYBIND11_OBJECT_DEFAULT(tuple, object, PyTuple_Check)
tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { } tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { }
size_t size() const { return (size_t) PyTuple_Size(m_ptr); } size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); } detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); }
@ -305,7 +305,7 @@ public:
class dict : public object { class dict : public object {
public: public:
PYBIND_OBJECT(dict, object, PyDict_Check) PYBIND11_OBJECT(dict, object, PyDict_Check)
dict() : object(PyDict_New(), false) { } dict() : object(PyDict_New(), false) { }
size_t size() const { return (size_t) PyDict_Size(m_ptr); } size_t size() const { return (size_t) PyDict_Size(m_ptr); }
detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); } detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); }
@ -314,7 +314,7 @@ public:
class list : public object { class list : public object {
public: public:
PYBIND_OBJECT(list, object, PyList_Check) PYBIND11_OBJECT(list, object, PyList_Check)
list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { } list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { }
size_t size() const { return (size_t) PyList_Size(m_ptr); } size_t size() const { return (size_t) PyList_Size(m_ptr); }
detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); } detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); }
@ -325,7 +325,7 @@ public:
class function : public object { class function : public object {
public: public:
PYBIND_OBJECT_DEFAULT(function, object, PyFunction_Check) PYBIND11_OBJECT_DEFAULT(function, object, PyFunction_Check)
bool is_cpp_function() { bool is_cpp_function() {
PyObject *ptr = m_ptr; PyObject *ptr = m_ptr;
@ -343,7 +343,7 @@ public:
class buffer : public object { class buffer : public object {
public: public:
PYBIND_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer) PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
buffer_info request(bool writable = false) { buffer_info request(bool writable = false) {
int flags = PyBUF_STRIDES | PyBUF_FORMAT; int flags = PyBUF_STRIDES | PyBUF_FORMAT;

4
include/pybind11/stl.h
View File

@ -54,7 +54,7 @@ public:
} }
return list; return list;
} }
PYBIND_TYPE_CASTER(type, detail::descr("list<") + value_conv::name() + detail::descr(">")); PYBIND11_TYPE_CASTER(type, detail::descr("list<") + value_conv::name() + detail::descr(">"));
}; };
template <typename Key, typename Value> struct type_caster<std::map<Key, Value>> { template <typename Key, typename Value> struct type_caster<std::map<Key, Value>> {
@ -97,7 +97,7 @@ public:
return dict; return dict;
} }
PYBIND_TYPE_CASTER(type, detail::descr("dict<") + key_conv::name() + detail::descr(", ") + value_conv::name() + detail::descr(">")); PYBIND11_TYPE_CASTER(type, detail::descr("dict<") + key_conv::name() + detail::descr(", ") + value_conv::name() + detail::descr(">"));
}; };
NAMESPACE_END(detail) NAMESPACE_END(detail)