Skip to content

P
pybind11
Commit 8f4eb006 by Wenzel Jakob
Options

last breaking change: be consistent about the project name

parent 607654f7
Showing with 163 additions and 161 deletions
CMakeLists.txt
......@@ -7,7 +7,7 @@
cmake_minimum_required(VERSION 2.8)
project(pybind)
project(pybind11)
# 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")
......@@ -55,13 +55,13 @@ include_directories(include)
# Create the binding library
add_library(example SHARED
include/pybind/cast.h
include/pybind/common.h
include/pybind/operators.h
include/pybind/pybind.h
include/pybind/pytypes.h
include/pybind/typeid.h
include/pybind/numpy.h
include/pybind11/cast.h
include/pybind11/common.h
include/pybind11/operators.h
include/pybind11/pybind11.h
include/pybind11/pytypes.h
include/pybind11/typeid.h
include/pybind11/numpy.h
example/example.cpp
example/example1.cpp
example/example2.cpp
......
docs/advanced.rst
......@@ -8,9 +8,9 @@ present:
.. code-block:: cpp
#include <pybind/pybind.h>
#include <pybind11/pybind11.h>
namespace py = pybind;
namespace py = pybind11
Operator overloading
====================
......@@ -43,10 +43,10 @@ to Python.
.. code-block:: cpp
#include <pybind/operators.h>
#include <pybind11/operators.h>
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
py::class_<Vector2>(m, "Vector2")
.def(py::init<float, float>())
......@@ -79,7 +79,7 @@ C++ side, or to perform other types of customization.
.. note::
To use the more convenient ``py::self`` notation, the additional
header file :file:`pybind/operators.h` must be included.
header file :file:`pybind11/operators.h` must be included.
.. seealso::
......@@ -120,15 +120,15 @@ its return value upon execution.
};
}
After including the extra header file :file:`pybind/functional.h`, it is almost
After including the extra header file :file:`pybind11/functional.h`, it is almost
trivial to generate binding code for both of these functions.
.. code-block:: cpp
#include <pybind/functional.h>
#include <pybind11/functional.h>
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
m.def("func_arg", &func_arg);
m.def("func_ret", &func_ret);
......@@ -200,7 +200,7 @@ Normally, the binding code for these classes would look as follows:
.. code-block:: cpp
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
py::class_<Animal> animal(m, "Animal");
animal
......@@ -248,7 +248,7 @@ a default implementation. The binding code also needs a few minor adaptations
:emphasize-lines: 4,6,7
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
py::class_<PyAnimal> animal(m, "Animal");
animal
......@@ -295,11 +295,11 @@ a virtual method call.
Passing STL data structures
===========================
When including the additional header file :file:`pybind/stl.h`, conversions
When including the additional header file :file:`pybind11/stl.h`, conversions
between ``std::vector<>`` and ``std::map<>`` and the Python ``list`` and
``dict`` data structures are automatically enabled. The types ``std::pair<>``
and ``std::tuple<>`` are already supported out of the box with just the core
:file:`pybind/pybind.h` header.
:file:`pybind11/pybind11.h` header.
.. note::
......@@ -376,7 +376,7 @@ See below for an example that uses the
};
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
py::class_<Example>(m, "Example")
.def(py::init<>())
......@@ -620,7 +620,7 @@ dense array of doubles in C-style ordering.
When it is invoked with a different type (e.g. an integer), the binding code
will attempt to cast the input into a NumPy array of the requested type.
Note that this feature requires the ``pybind/numpy.h`` header to be included.
Note that this feature requires the ``pybind11/numpy.h`` header to be included.
Vectorizing functions
=====================
......@@ -633,7 +633,7 @@ N-D arrays) in addition to its normal arguments:
double my_func(int x, float y, double z);
After including the ``pybind/numpy.h`` header, this is extremely simple:
After including the ``pybind11/numpy.h`` header, this is extremely simple:
.. code-block:: cpp
......
docs/basics.rst
......@@ -37,7 +37,7 @@ Windows
On Windows, use the `CMake GUI`_ to create a Visual Studio project. Note that
only the 2015 release and newer versions are supported since pybind11 relies on
various C++11 language features that break older versions of Visual Studio.
After running CMake, open the created :file:`pybind.sln` file and perform a
After running CMake, open the created :file:`pybind11.sln` file and perform a
release build, which will will produce a file named
:file:`Release\\example.pyd`. Copy this file to the :file:`example` directory
and run :file:`example\\run_test.py` using the targeted Python version.
......@@ -79,16 +79,16 @@ a file named :file:`example.cpp` with the following contents:
.. code-block:: cpp
#include <pybind/pybind.h>
#include <pybind11/pybind11.h>
int add(int i, int j) {
return i + j;
}
namespace py = pybind;
namespace py = pybind11
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
m.def("add", &add, "A function which adds two numbers");
......@@ -117,7 +117,7 @@ example can be compiled using the following command
.. code-block:: bash
$ c++ -O3 -shared -std=c++11 -I <path-to-pybind>/include `python-config --cflags --libs` example.cpp -o example.so
$ c++ -O3 -shared -std=c++11 -I <path-to-pybind11>/include `python-config --cflags --libs` example.cpp -o example.so
In general, it is advisable to include several additional build parameters
that can considerably reduce the size of the created binary. Refer to section
......@@ -222,41 +222,41 @@ The following basic data types are supported out of the box (some may require
an additional extension header to be included). To pass other data structures
as arguments and return values, refer to the section on binding :ref:`classes`.
+------------------------+--------------------------+---------------------+
+------------------------+--------------------------+-----------------------+
| Data type | Description | Header file |
+========================+==========================+=====================+
| int8_t, uint8_t | 8-bit integers | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| int16_t, uint16_t | 16-bit integers | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| int32_t, uint32_t | 32-bit integers | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| int64_t, uint64_t | 64-bit integers | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| ssize_t, size_t | Platform-dependent size | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| float, double | Floating point types | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| bool | Two-state Boolean type | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| char | Character literal | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| const char * | UTF-8 string literal | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| std::string | STL dynamic UTF-8 string | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| std::pair<T1, T2> | Pair of two custom types | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| std::tuple<....> | Arbitrary tuple of types | pybind/pybind.h |
+------------------------+--------------------------+---------------------+
| std::complex<T> | Complex numbers | pybind/complex.h |
+------------------------+--------------------------+---------------------+
| std::vector<T> | STL dynamic array | pybind/stl.h |
+------------------------+--------------------------+---------------------+
| std::map<T1, T2> | STL dynamic maps | pybind/stl.h |
+------------------------+--------------------------+---------------------+
| std::function<...> | STL polymorphic function | pybind/functional.h |
+------------------------+--------------------------+---------------------+
+========================+==========================+=======================+
| int8_t, uint8_t | 8-bit integers | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| int16_t, uint16_t | 16-bit integers | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| int32_t, uint32_t | 32-bit integers | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| int64_t, uint64_t | 64-bit integers | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| ssize_t, size_t | Platform-dependent size | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| float, double | Floating point types | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| bool | Two-state Boolean type | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| char | Character literal | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| const char * | UTF-8 string literal | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| std::string | STL dynamic UTF-8 string | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| std::pair<T1, T2> | Pair of two custom types | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| std::tuple<....> | Arbitrary tuple of types | pybind11/pybind11.h |
+------------------------+--------------------------+-----------------------+
| std::complex<T> | Complex numbers | pybind11/complex.h |
+------------------------+--------------------------+-----------------------+
| std::vector<T> | STL dynamic array | pybind11/stl.h |
+------------------------+--------------------------+-----------------------+
| std::map<T1, T2> | STL dynamic maps | pybind11/stl.h |
+------------------------+--------------------------+-----------------------+
| std::function<...> | STL polymorphic function | pybind11/functional.h |
+------------------------+--------------------------+-----------------------+
.. [#f1] In practice, implementation and binding code will generally be located
......
docs/classes.rst
......@@ -23,12 +23,12 @@ The binding code for ``Pet`` looks as follows:
.. code-block:: cpp
#include <pybind/pybind.h>
#include <pybind11/pybind11.h>
namespace py = pybind;
namespace py = pybind11
PYBIND_PLUGIN(example) {
py::module m("example", "pybind example plugin");
py::module m("example", "pybind11 example plugin");
py::class_<Pet>(m, "Pet")
.def(py::init<const std::string &>())
......
docs/reference.rst
......@@ -4,7 +4,7 @@
Please be advised that the reference documentation discussing pybind11
internals is currently incomplete. Please refer to the previous sections
and the pybind header files for the nitty gritty details.
and the pybind11 header files for the nitty gritty details.
Reference
#########
......@@ -22,7 +22,7 @@ Macros
.. code-block:: cpp
PYBIND_PLUGIN(example) {
pybind::module m("example", "pybind example plugin");
pybind11::module m("example", "pybind11 example plugin");
/// Set up bindings here
return m.ptr();
}
......@@ -188,9 +188,9 @@ Convenience classes for specific Python types
.. code-block:: cpp
pybind::module m("example", "pybind example plugin");
pybind::module m2 = m.def_submodule("sub", "A submodule of 'example'");
pybind::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
pybind11::module m("example", "pybind11 example plugin");
pybind11::module m2 = m.def_submodule("sub", "A submodule of 'example'");
pybind11::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
.. cpp:function:: template <typename Func, typename ... Extra> module& module::def(const char *name, Func && f, Extra && ... extra)
......
example/example.h
#include <pybind/pybind.h>
#include <pybind11/pybind11.h>
#include <iostream>
using std::cout;
using std::endl;
namespace py = pybind;
namespace py = pybind11;
example/example10.cpp
......@@ -9,7 +9,7 @@
*/
#include "example.h"
#include <pybind/numpy.h>
#include <pybind11/numpy.h>
double my_func(int x, float y, double z) {
std::cout << "my_func(x:int=" << x << ", y:float=" << y << ", z:float=" << z << ")" << std::endl;
......
example/example12.cpp
......@@ -8,7 +8,7 @@
*/
#include "example.h"
#include <pybind/functional.h>
#include <pybind11/functional.h>
/* This is an example class that we'll want to be able to extend from Python */
class Example12 {
......
example/example2.cpp
......@@ -9,7 +9,7 @@
*/
#include "example.h"
#include <pybind/stl.h>
#include <pybind11/stl.h>
class Example2 {
public:
......
example/example3.cpp
......@@ -8,7 +8,7 @@
*/
#include "example.h"
#include <pybind/operators.h>
#include <pybind11/operators.h>
class Vector2 {
public:
......
example/example5.cpp
......@@ -9,7 +9,7 @@
*/
#include "example.h"
#include <pybind/functional.h>
#include <pybind11/functional.h>
class Pet {
......
example/example6.cpp
......@@ -9,8 +9,8 @@
*/
#include "example.h"
#include <pybind/operators.h>
#include <pybind/stl.h>
#include <pybind11/operators.h>
#include <pybind11/stl.h>
class Sequence {
public:
......
example/example8.cpp
......@@ -32,10 +32,7 @@ private:
};
/// Make pybind aware of the ref-counted wrapper type
namespace pybind { namespace detail {
template <typename T> class type_caster<ref<T>>
: public type_caster_holder<T, ref<T>> { };
}}
PYBIND_DECLARE_HOLDER_TYPE(T, ref<T>);
Object *make_object_1() { return new MyObject(1); }
ref<Object> make_object_2() { return new MyObject(2); }
......
include/pybind/cast.h → include/pybind11/cast.h
/*
pybind/cast.h: Partial template specializations to cast between
pybind11/cast.h: Partial template specializations to cast between
C++ and Python types
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -10,12 +10,12 @@
#pragma once
#include <pybind/pytypes.h>
#include <pybind/typeid.h>
#include "pytypes.h"
#include "typeid.h"
#include <array>
#include <limits>
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
#if defined(_MSC_VER)
......@@ -527,6 +527,12 @@ protected:
holder_type holder;
};
#define PYBIND_DECLARE_HOLDER_TYPE(type, holder_type) \
namespace pybind11 { namespace detail { \
template <typename type> class type_caster<holder_type> \
: public type_caster_holder<type, holder_type> { }; \
}}
template <> class type_caster<handle> {
public:
bool load(PyObject *src) {
......@@ -571,7 +577,7 @@ template <typename T> inline object cast(const T &value, return_value_policy pol
return object(detail::type_caster<typename detail::decay<T>::type>::cast(value, policy, parent), false);
}
template <typename T> inline T handle::cast() { return pybind::cast<T>(m_ptr); }
template <typename T> inline T handle::cast() { return pybind11::cast<T>(m_ptr); }
template <> inline void handle::cast() { return; }
template <typename... Args> inline object handle::call(Args&&... args_) {
......@@ -601,4 +607,4 @@ template <typename... Args> inline object handle::call(Args&&... args_) {
return object(result, false);
}
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/common.h → include/pybind11/common.h
/*
pybind/common.h -- Basic macros
pybind11/common.h -- Basic macros
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -68,7 +68,7 @@
extern "C" PYBIND_EXPORT PyObject *init##name()
#endif
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
typedef Py_ssize_t ssize_t;
......@@ -192,7 +192,7 @@ NAMESPACE_END(detail)
struct stop_iteration : public std::runtime_error { public: stop_iteration(const std::string &w="") : std::runtime_error(w) {} };
struct index_error : public std::runtime_error { public: index_error(const std::string &w="") : std::runtime_error(w) {} };
struct error_already_set : public std::runtime_error { public: error_already_set() : std::runtime_error(detail::error_string()) {} };
/// Thrown when pybind::cast or handle::call fail due to a type casting error
/// Thrown when pybind11::cast or handle::call fail due to a type casting error
struct cast_error : public std::runtime_error { public: cast_error(const std::string &w = "") : std::runtime_error(w) {} };
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/complex.h → include/pybind11/complex.h
/*
pybind/complex.h: Complex number support
pybind11/complex.h: Complex number support
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,10 +9,10 @@
#pragma once
#include <pybind/pybind.h>
#include "pybind11.h"
#include <complex>
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
PYBIND_DECL_FMT(std::complex<float>, "Zf");
PYBIND_DECL_FMT(std::complex<double>, "Zd");
......@@ -37,4 +37,4 @@ public:
PYBIND_TYPE_CASTER(std::complex<T>, "complex");
};
NAMESPACE_END(detail)
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/functional.h → include/pybind11/functional.h
/*
pybind/functional.h: std::function<> support
pybind11/functional.h: std::function<> support
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,10 +9,10 @@
#pragma once
#include <pybind/pybind.h>
#include "pybind11.h"
#include <functional>
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
template <typename Return, typename... Args> struct type_caster<std::function<Return(Args...)>> {
......@@ -24,7 +24,7 @@ public:
return false;
object src(src_, true);
value = [src](Args... args) -> Return {
object retval(pybind::handle(src).call(std::move(args)...));
object retval(pybind11::handle(src).call(std::move(args)...));
/* Visual studio 2015 parser issue: need parentheses around this expression */
return (retval.template cast<Return>());
};
......@@ -46,4 +46,4 @@ public:
};
NAMESPACE_END(detail)
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/numpy.h → include/pybind11/numpy.h
/*
pybind/numpy.h: Basic NumPy support, auto-vectorization support
pybind11/numpy.h: Basic NumPy support, auto-vectorization support
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,15 +9,15 @@
#pragma once
#include <pybind/pybind.h>
#include <pybind/complex.h>
#include "pybind11.h"
#include "complex.h"
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
#endif
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
template <typename type> struct npy_format_descriptor { };
......@@ -196,7 +196,7 @@ struct vectorize_helper {
/* Check if the parameters are actually compatible */
for (size_t i=0; i<N; ++i) {
if (buffers[i].count != 1 && (buffers[i].ndim != ndim || buffers[i].shape != shape))
throw std::runtime_error("pybind::vectorize: incompatible size/dimension of inputs!");
throw std::runtime_error("pybind11::vectorize: incompatible size/dimension of inputs!");
}
/* Call the function */
......@@ -234,7 +234,7 @@ template <typename func> auto vectorize(func &&f) -> decltype(
&std::remove_reference<func>::type::operator())>::type *) nullptr);
}
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
#if defined(_MSC_VER)
#pragma warning(pop)
......
include/pybind/operators.h → include/pybind11/operators.h
/*
pybind/operator.h: Metatemplates for operator overloading
pybind11/operator.h: Metatemplates for operator overloading
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,10 +9,10 @@
#pragma once
#include <pybind/pybind.h>
#include "pybind11.h"
#include <type_traits>
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
/// Enumeration with all supported operator types
......@@ -45,13 +45,13 @@ template <op_id, op_type, typename B, typename L, typename R> struct op_impl { }
/// Operator implementation generator
template <op_id id, op_type ot, typename L, typename R> struct op_ {
template <typename Base, typename Holder, typename... Extra> void execute(pybind::class_<Base, Holder> &class_, Extra&&... extra) const {
template <typename Base, typename Holder, typename... Extra> void execute(pybind11::class_<Base, Holder> &class_, Extra&&... extra) const {
typedef typename std::conditional<std::is_same<L, self_t>::value, Base, L>::type L_type;
typedef typename std::conditional<std::is_same<R, self_t>::value, Base, R>::type R_type;
typedef op_impl<id, ot, Base, L_type, R_type> op;
class_.def(op::name(), &op::execute, std::forward<Extra>(extra)...);
}
template <typename Base, typename Holder, typename... Extra> void execute_cast(pybind::class_<Base, Holder> &class_, Extra&&... extra) const {
template <typename Base, typename Holder, typename... Extra> void execute_cast(pybind11::class_<Base, Holder> &class_, Extra&&... extra) const {
typedef typename std::conditional<std::is_same<L, self_t>::value, Base, L>::type L_type;
typedef typename std::conditional<std::is_same<R, self_t>::value, Base, R>::type R_type;
typedef op_impl<id, ot, Base, L_type, R_type> op;
......@@ -146,4 +146,4 @@ NAMESPACE_END(detail)
using detail::self;
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/pytypes.h → include/pybind11/pytypes.h
/*
pybind/typeid.h: Convenience wrapper classes for basic Python types
pybind11/typeid.h: Convenience wrapper classes for basic Python types
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,10 +9,10 @@
#pragma once
#include <pybind/common.h>
#include "common.h"
#include <utility>
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
/* A few forward declarations */
class object;
......@@ -37,7 +37,7 @@ public:
inline detail::accessor operator[](const char *key);
inline detail::accessor attr(handle key);
inline detail::accessor attr(const char *key);
inline pybind::str str() const;
inline pybind11::str str() const;
template <typename T> T cast();
template <typename ... Args> object call(Args&&... args_);
operator bool() const { return m_ptr != nullptr; }
......@@ -230,13 +230,13 @@ private:
#endif
};
inline pybind::str handle::str() const {
inline pybind11::str handle::str() const {
PyObject *str = PyObject_Str(m_ptr);
#if PY_MAJOR_VERSION < 3
PyObject *unicode = PyUnicode_FromEncodedObject(str, "utf-8", nullptr);
Py_XDECREF(str); str = unicode;
#endif
return pybind::str(str, false);
return pybind11::str(str, false);
}
class bool_ : public object {
......@@ -370,12 +370,12 @@ inline internals &get_internals() {
if (internals_ptr)
return *internals_ptr;
handle builtins(PyEval_GetBuiltins());
capsule caps(builtins["__pybind__"]);
capsule caps(builtins["__pybind11__"]);
if (caps.check()) {
internals_ptr = caps;
} else {
internals_ptr = new internals();
builtins["__pybind__"] = capsule(internals_ptr);
builtins["__pybind11__"] = capsule(internals_ptr);
}
return *internals_ptr;
}
......@@ -413,4 +413,4 @@ inline handle get_type_handle(const std::type_info &tp) {
}
NAMESPACE_END(detail)
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
include/pybind/stl.h → include/pybind11/stl.h
/*
pybind/complex.h: Complex number support
pybind11/complex.h: Complex number support
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,7 +9,7 @@
#pragma once
#include <pybind/pybind.h>
#include "pybind11.h"
#include <map>
#include <iostream>
......@@ -19,7 +19,7 @@
#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
#endif
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
template <typename Value> struct type_caster<std::vector<Value>> {
......@@ -104,7 +104,7 @@ NAMESPACE_END(detail)
inline std::ostream &operator<<(std::ostream &os, const object &obj) { os << (const char *) obj.str(); return os; }
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
#if defined(_MSC_VER)
#pragma warning(pop)
......
include/pybind/typeid.h → include/pybind11/typeid.h
/*
pybind/typeid.h: Compiler-independent access to type identifiers
pybind11/typeid.h: Compiler-independent access to type identifiers
Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
......@@ -9,14 +9,13 @@
#pragma once
#include <pybind/typeid.h>
#include <cstdio>
#include <cstdlib>
#if defined(__GNUG__)
#include <cxxabi.h>
#endif
NAMESPACE_BEGIN(pybind)
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
/// Erase all occurrences of a substring
inline void erase_all(std::string &string, const std::string &search) {
......@@ -39,7 +38,7 @@ inline void clean_type_id(std::string &name) {
detail::erase_all(name, "struct ");
detail::erase_all(name, "enum ");
#endif
detail::erase_all(name, "pybind::");
detail::erase_all(name, "pybind11::");
}
NAMESPACE_END(detail)
......@@ -50,4 +49,4 @@ template <typename T> static std::string type_id() {
return name;
}
NAMESPACE_END(pybind)
NAMESPACE_END(pybind11)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment