commit 38bd71134a428d641d8ca34b3ea94358a387703d Author: Wenzel Jakob Date: Sun Jul 5 20:05:44 2015 +0200 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..ed5902cc9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,20 @@ +CMakeCache.txt +CMakeFiles +Makefile +cmake_install.cmake +.DS_Store +/example/example.so +/example/example.pyd +*.sln +*.sdf +*.opensdf +*.vcxproj +*.filters +example.dir +Win32 +x64 +Release +Debug +.vs +CTestTestfile.cmake +Testing diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000..a028d8cd0 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,113 @@ +# CMakeLists.txt -- Build system for the pybind11 examples +# +# Copyright (c) 2015 Wenzel Jakob +# +# All rights reserved. Use of this source code is governed by a +# BSD-style license that can be found in the LICENSE file. + +cmake_minimum_required(VERSION 2.8) + +project(pybind) + +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + message(STATUS "Setting build type to 'MinSizeRel' as none was specified.") + set(CMAKE_BUILD_TYPE MinSizeRel CACHE STRING "Choose the type of build." FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" + "MinSizeRel" "RelWithDebInfo") +endif() + +set(Python_ADDITIONAL_VERSIONS 3.4 3.5 3.6) +find_package(PythonLibs 3 REQUIRED) +find_package(PythonInterp 3 REQUIRED) + +string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE) +if (UNIX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wno-unsequenced") + if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") + endif() +endif() + +# Compile with compiler warnings turned on +if(MSVC) + if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + endif() +else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") +endif() + +include_directories(${PYTHON_INCLUDE_DIR} include) + +add_library(example SHARED + include/pybind/cast.h + include/pybind/common.h + include/pybind/mpl.h + include/pybind/operators.h + include/pybind/pybind.h + include/pybind/pytypes.h + include/pybind/typeid.h + example/example.cpp + example/example1.cpp + example/example2.cpp + example/example3.cpp + example/example4.cpp + example/example5.cpp + example/example6.cpp + example/example7.cpp + example/example8.cpp + example/example9.cpp +) + +set_target_properties(example PROPERTIES PREFIX "") +set_target_properties(example PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/example) + +if (WIN32) + if (MSVC) + # Enforce size-based optimization and link time code generation on MSVC (~30% smaller binaries in experiments) + set_target_properties(example PROPERTIES COMPILE_FLAGS "/Os /GL") + set_target_properties(example PROPERTIES LINK_FLAGS "/LTCG") + endif() + + # .PYD file extension on Windows + set_target_properties(example PROPERTIES SUFFIX ".pyd") + + # Link against the Python shared library + target_link_libraries(example ${PYTHON_LIBRARY}) +elseif (UNIX) + # It's quite common to have multiple copies of the same Python version + # installed on one's system. E.g.: one copy from the OS and another copy + # that's statically linked into an application like Blender or Maya. + # If we link our plugin library against the OS Python here and import it + # into Blender or Maya later on, this will cause segfaults when multiple + # conflicting Python instances are active at the same time. + + # Windows does not seem to be affected by this issue. The solution for Linux + # and Mac OS is simple: we just don't link against the Python library. The + # resulting shared library will have missing symbols, but that's perfectly + # fine -- they will be resolved at import time. + + # .SO file extension on Linux/Mac OS + set_target_properties(example PROPERTIES SUFFIX ".so") + + # Strip unnecessary sections of the binary on Linux/Mac OS + if(APPLE) + set_target_properties(example PROPERTIES MACOSX_RPATH ".") + set_target_properties(example PROPERTIES LINK_FLAGS "-undefined dynamic_lookup -dead_strip") + if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG) + add_custom_command(TARGET example POST_BUILD COMMAND strip -u -r ${PROJECT_SOURCE_DIR}/example/example.so) + endif() + else() + if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG) + add_custom_command(TARGET example POST_BUILD COMMAND strip ${PROJECT_SOURCE_DIR}/example/example.so) + endif() + endif() +endif() + +enable_testing() +set(RUN_TEST ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example/run_test.py) +foreach(i RANGE 1 7) + add_test(NAME example${i} COMMAND ${RUN_TEST} example${i}) +endforeach() diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..42b5a5708 --- /dev/null +++ b/LICENSE @@ -0,0 +1,17 @@ +Copyright (c) 2015 Wenzel Jakob + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software +in a product, an acknowledgment in the product documentation would be +appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. diff --git a/README.md b/README.md new file mode 100644 index 000000000..bf4dcf56a --- /dev/null +++ b/README.md @@ -0,0 +1,106 @@ +# pybind11 -- Seamless operability between C++11 and Python + +**pybind11** is a lightweight header library that exposes C++ types in Python +and vice versa, mainly to create Python bindings of existing C++ code. Its +goals and syntax are similar to the excellent +[Boost.Python](http://www.boost.org/doc/libs/1_58_0/libs/python/doc/) library +by David Abrahams: to minimize boilerplate code in traditional extension +modules by inferring type information using compile-time introspection. + +The main issue with Boost.Python—and the reason for creating such a similar +project—is Boost. Boost is an enormously large and complex suite of utility +libraries that works with almost every C++ compiler in existence. This +compatibility has its cost: arcane template tricks and workarounds are +necessary to support the oldest and buggiest of compiler specimens. Now that +C++11-compatible compilers are widely available, this heavy machinery has +become an excessively large and unnecessary dependency. + +Think of this library as a tiny self-contained version of Boost.Python with +everything stripped away that isn't relevant for binding generation. The whole +codebase requires less than 2000 lines of code and just depends on Python and +the C++ standard library. This compact implementation was possible thanks to +some of the new C++11 language features (tuples, lambda functions and variadic +templates), and by only targeting Python 3.x and higher. + +## Core features +The following C++ features can be mapped to Python + +- Functions accepting and returning custom data structures per value, reference, or pointer +- Instance methods and static methods +- Overloaded functions +- Instance attributes and static attributes +- Exceptions +- Enumerations +- Callbacks +- Custom operators +- STL data structures +- Smart pointers with reference counting like `std::shared_ptr` +- Internal references with correct reference counting + +## Goodies +In addition to the core functionality, pybind11 provides some extra goodies: + +- It's easy to expose the internal storage of custom data types through + Pythons' buffer protocols. This is handy e.g. for fast conversion between + C++ matrix classes like Eigen and NumPy without expensive copy operations. + +- Python's slice-based access and assignment operations can be supported with + just a few lines of code. + +- pybind11 uses C++11 move constructors and move assignment operators whenever + possible to efficiently transfer custom data types. + +## Limitations +Various things that Boost.Python can do remain unsupported, e.g.: + +- Fine grained exception translation: currently, all exceptions derived from + `std::exception` are mapped to a Python `Exception`, but that's it. + +- Default arguments in C++ functions are ignored, though their effect can be + emulated by binding multiple overloads using anonymous functions. + +- Python keyword arguments are not supported in bindings + +- Weak pointers are not supported + +## What does the binding code look like? +Here is a simple example. The directory `example` contains many more. +```C++ +#include +#include + +namespace py = pybind; + +/// Example C++ class which should be bound to Python +class Test { +public: + Test(); + Test(int value); + std::string toString(); + Test operator+(const Test &e) const; + + void print_dict(py::dict dict) { + /* Easily interact with Python types */ + for (auto item : dict) + std::cout << "key=" << item.first << ", " + << "value=" << item.second << std::endl; + } + + int value = 0; +}; + + +PYTHON_PLUGIN(example) { + py::module m("example", "pybind example plugin"); + + py::class_(m, "Test", "docstring for the Test class") + .def(py::init<>(), "docstring for constructor 1") + .def(py::init(), "docstring for constructor 2") + .def(py::self + py::self, "Addition operator") + .def("__str__", &Test::toString, "Convert to a string representation") + .def("print_dict", &Test::print_dict, "Print a Python dictionary") + .def_readwrite("value", &Test::value, "An instance attribute"); + + return m.ptr(); +} +``` diff --git a/example/example.cpp b/example/example.cpp new file mode 100644 index 000000000..800fb9f83 --- /dev/null +++ b/example/example.cpp @@ -0,0 +1,36 @@ +/* + example/example.cpp -- pybind example plugin + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +void init_ex1(py::module &); +void init_ex2(py::module &); +void init_ex3(py::module &); +void init_ex4(py::module &); +void init_ex5(py::module &); +void init_ex6(py::module &); +void init_ex7(py::module &); +void init_ex8(py::module &); +void init_ex9(py::module &); + +PYTHON_PLUGIN(example) { + py::module m("example", "pybind example plugin"); + + init_ex1(m); + init_ex2(m); + init_ex3(m); + init_ex4(m); + init_ex5(m); + init_ex6(m); + init_ex7(m); + init_ex8(m); + init_ex9(m); + + return m.ptr(); +} diff --git a/example/example.h b/example/example.h new file mode 100644 index 000000000..67434bb11 --- /dev/null +++ b/example/example.h @@ -0,0 +1,7 @@ +#include +#include + +using std::cout; +using std::endl; + +namespace py = pybind; diff --git a/example/example1.cpp b/example/example1.cpp new file mode 100644 index 000000000..0cdc1f026 --- /dev/null +++ b/example/example1.cpp @@ -0,0 +1,92 @@ +/* + example/example1.cpp -- Example 1: constructors, deconstructors, + attribute access, __str__, argument and return value conventions + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +class Example1 { +public: + Example1() { + cout << "Called Example1 default constructor.." << endl; + } + Example1(int value) : value(value) { + cout << "Called Example1 constructor with value " << value << ".." << endl; + } + Example1(const Example1 &e) : value(e.value) { + cout << "Called Example1 copy constructor with value " << value << ".." << endl; + } + Example1(Example1 &&e) : value(e.value) { + cout << "Called Example1 move constructor with value " << value << ".." << endl; + e.value = 0; + } + ~Example1() { + cout << "Called Example1 destructor (" << value << ")" << endl; + } + std::string toString() { + return "Example1[value=" + std::to_string(value) + "]"; + } + + void operator=(const Example1 &e) { cout << "Assignment operator" << endl; value = e.value; } + void operator=(Example1 &&e) { cout << "Move assignment operator" << endl; value = e.value; e.value = 0;} + + void add1(Example1 other) { value += other.value; } // passing py value + void add2(Example1 &other) { value += other.value; } // passing by reference + void add3(const Example1 &other) { value += other.value; } // passing by const reference + void add4(Example1 *other) { value += other->value; } // passing py pointer + void add5(const Example1 *other) { value += other->value; } // passing by const pointer + + void add6(int other) { value += other; } // passing py value + void add7(int &other) { value += other; } // passing by reference + void add8(const int &other) { value += other; } // passing by const reference + void add9(int *other) { value += *other; } // passing py pointer + void add10(const int *other) { value += *other; } // passing by const pointer + + Example1 self1() { return *this; } // return by value + Example1 &self2() { return *this; } // return by reference + const Example1 &self3() { return *this; } // return by const reference + Example1 *self4() { return this; } // return by pointer + const Example1 *self5() { return this; } // return by const pointer + + int internal1() { return value; } // return by value + int &internal2() { return value; } // return by reference + const int &internal3() { return value; } // return by const reference + int *internal4() { return &value; } // return by pointer + const int *internal5() { return &value; } // return by const pointer + + int value = 0; +}; + +void init_ex1(py::module &m) { + py::class_(m, "Example1") + .def(py::init<>()) + .def(py::init()) + .def(py::init()) + .def("add1", &Example1::add1) + .def("add2", &Example1::add2) + .def("add3", &Example1::add3) + .def("add4", &Example1::add4) + .def("add5", &Example1::add5) + .def("add6", &Example1::add6) + .def("add7", &Example1::add7) + .def("add8", &Example1::add8) + .def("add9", &Example1::add9) + .def("add10", &Example1::add10) + .def("self1", &Example1::self1) + .def("self2", &Example1::self2) + .def("self3", &Example1::self3) + .def("self4", &Example1::self4) + .def("self5", &Example1::self5) + .def("internal1", &Example1::internal1) + .def("internal2", &Example1::internal2) + .def("internal3", &Example1::internal3) + .def("internal4", &Example1::internal4) + .def("internal5", &Example1::internal5) + .def("__str__", &Example1::toString) + .def_readwrite("value", &Example1::value); +} diff --git a/example/example1.py b/example/example1.py new file mode 100755 index 000000000..30cda8d37 --- /dev/null +++ b/example/example1.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import Example1 + +instance1 = Example1() +instance2 = Example1(32) +instance1.add1(instance2) +instance1.add2(instance2) +instance1.add3(instance2) +instance1.add4(instance2) +instance1.add5(instance2) +instance1.add6(32) +instance1.add7(32) +instance1.add8(32) +instance1.add9(32) +instance1.add10(32) + +print("Instance 1: " + str(instance1)) +print("Instance 2: " + str(instance2)) + +print(instance1.self1()) +print(instance1.self2()) +print(instance1.self3()) +print(instance1.self4()) +print(instance1.self5()) +print(instance1.internal1()) +print(instance1.internal2()) +print(instance1.internal3()) +print(instance1.internal4()) +print(instance1.internal5()) + +print("Instance 1, direct access = %i" % instance1.value) +instance1.value = 100 +print("Instance 1: " + str(instance1)) diff --git a/example/example1.ref b/example/example1.ref new file mode 100644 index 000000000..deeb40c6c --- /dev/null +++ b/example/example1.ref @@ -0,0 +1,28 @@ +Called Example1 default constructor.. +Called Example1 constructor with value 32.. +Called Example1 copy constructor with value 32.. +Called Example1 move constructor with value 32.. +Called Example1 move constructor with value 32.. +Called Example1 destructor (32) +Called Example1 destructor (0) +Called Example1 destructor (0) +Called Example1 copy constructor with value 320.. +Called Example1 copy constructor with value 320.. +Called Example1 destructor (320) +Called Example1 destructor (320) +Instance 1: Example1[value=320] +Instance 2: Example1[value=32] +Example1[value=320] +Example1[value=320] +Example1[value=320] +Example1[value=320] +Example1[value=320] +320 +320 +320 +320 +320 +Instance 1, direct access = 320 +Instance 1: Example1[value=100] +Called Example1 destructor (32) +Called Example1 destructor (100) diff --git a/example/example2.cpp b/example/example2.cpp new file mode 100644 index 000000000..d064fb359 --- /dev/null +++ b/example/example2.cpp @@ -0,0 +1,117 @@ +/* + example/example2.cpp2 -- Example 2: singleton design pattern, static + functions and variables, passing and interacting with Python types + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +class Example2 { +public: + static Example2 *new_instance() { + return new Example2(); + } + ~Example2() { + std::cout << "Destructing Example2" << std::endl; + } + + /* Create and return a Python dictionary */ + py::dict get_dict() { + py::dict dict; + dict[py::str("key")] = py::str("value"); + return dict; + } + + /* Create and return a C++ dictionary */ + std::map get_dict_2() { + std::map result; + result["key"] = "value"; + return result; + } + + /* Create, manipulate, and return a Python list */ + py::list get_list() { + py::list list; + list.append(py::str("value")); + cout << "Entry at positon 0: " << py::object(list[0]) << endl; + list[0] = py::str("overwritten"); + return list; + } + + /* C++ STL data types are automatically casted */ + std::vector get_list_2() { + std::vector list; + list.push_back("value"); + return list; + } + + /* Easily iterate over a dictionary using a C++11 range-based for loop */ + void print_dict(py::dict dict) { + for (auto item : dict) + std::cout << "key: " << item.first << ", value=" << item.second << std::endl; + } + + /* STL data types are automatically casted from Python */ + void print_dict_2(const std::map &dict) { + for (auto item : dict) + std::cout << "key: " << item.first << ", value=" << item.second << std::endl; + } + + /* Easily iterate over a list using a C++11 range-based for loop */ + void print_list(py::list list) { + int index = 0; + for (auto item : list) + std::cout << "list item " << index++ << ": " << item << std::endl; + } + + /* STL data types are automatically casted from Python */ + void print_list_2(std::vector &list) { + int index = 0; + for (auto item : list) + std::cout << "list item " << index++ << ": " << item << std::endl; + } + + /* pybind automatically translates between C++11 and Python tuples */ + std::pair pair_passthrough(std::pair input) { + return std::make_pair(input.second, input.first); + } + + /* pybind automatically translates between C++11 and Python tuples */ + std::tuple tuple_passthrough(std::tuple input) { + return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input)); + } + + void throw_exception() { + throw std::runtime_error("This exception was intentionally thrown."); + } + + static int value; + static const int value2; +}; + +int Example2::value = 0; +const int Example2::value2 = 5; + +void init_ex2(py::module &m) { + /* No constructor is explicitly defined below. An exception is raised when + trying to construct it directly from Python */ + py::class_(m, "Example2") + .def("get_dict", &Example2::get_dict, "Return a Python dictionary") + .def("get_dict_2", &Example2::get_dict_2, "Return a C++ dictionary") + .def("get_list", &Example2::get_list, "Return a Python list") + .def("get_list_2", &Example2::get_list_2, "Return a C++ list") + .def("print_dict", &Example2::print_dict, "Print entries of a Python dictionary") + .def("print_dict_2", &Example2::print_dict_2, "Print entries of a C++ dictionary") + .def("print_list", &Example2::print_list, "Print entries of a Python list") + .def("print_list_2", &Example2::print_list_2, "Print entries of a C++ list") + .def("pair_passthrough", &Example2::pair_passthrough, "Return a pair in reversed order") + .def("tuple_passthrough", &Example2::tuple_passthrough, "Return a triple in reversed order") + .def("throw_exception", &Example2::throw_exception, "Throw an exception") + .def_static("new_instance", &Example2::new_instance, "Return an instance") + .def_readwrite_static("value", &Example2::value, "Static value member") + .def_readonly_static("value2", &Example2::value2, "Static value member (readonly)"); +} diff --git a/example/example2.py b/example/example2.py new file mode 100755 index 000000000..b0f47079f --- /dev/null +++ b/example/example2.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +import sys, pydoc +sys.path.append('.') + +from example import Example2 + +Example2.value = 15 +print(Example2.value) +print(Example2.value2) + +try: + Example2() +except Exception as e: + print(e) + +try: + Example2.value2 = 15 +except Exception as e: + print(e) + +instance = Example2.new_instance() + +dict_result = instance.get_dict() +dict_result['key2'] = 'value2' +instance.print_dict(dict_result) + +dict_result = instance.get_dict_2() +dict_result['key2'] = 'value2' +instance.print_dict_2(dict_result) + +list_result = instance.get_list() +list_result.append('value2') +instance.print_list(list_result) + +list_result = instance.get_list_2() +list_result.append('value2') +instance.print_list_2(list_result) + +try: + instance.throw_exception() +except Exception as e: + print(e) + +print(instance.pair_passthrough((True, "test"))) +print(instance.tuple_passthrough((True, "test", 5))) + +print(pydoc.render_doc(Example2, "Help on %s")) diff --git a/example/example2.ref b/example/example2.ref new file mode 100644 index 000000000..8367f2066 --- /dev/null +++ b/example/example2.ref @@ -0,0 +1,91 @@ +key: key, value=value +key: key2, value=value2 +key: key, value=value +key: key2, value=value2 +Entry at positon 0: value +list item 0: overwritten +list item 1: value2 +list item 0: value +list item 1: value2 +15 +5 +example.Example2: No constructor defined! +can't set attribute +This exception was intentionally thrown. +('test', True) +(5, 'test', True) +Help on class Example2 in module example + +class EExxaammppllee22(builtins.object) + | Methods defined here: + | + | ____iinniitt____(self, /, *args, **kwargs) + | Initialize self. See help(type(self)) for accurate signature. + | + | ____nneeww____ = + | ggeett__ddiicctt(...) from builtins.PyCapsule + | Signature : get_dict(Example2) -> dict + | + | Return a Python dictionary + | + | ggeett__ddiicctt__22(...) from builtins.PyCapsule + | Signature : get_dict_2(Example2) -> dict + | + | Return a C++ dictionary + | + | ggeett__lliisstt(...) from builtins.PyCapsule + | Signature : get_list(Example2) -> list + | + | Return a Python list + | + | ggeett__lliisstt__22(...) from builtins.PyCapsule + | Signature : get_list_2(Example2) -> list + | + | Return a C++ list + | + | nneeww__iinnssttaannccee(...) from builtins.PyCapsule + | Signature : new_instance() -> Example2 + | + | Return an instance + | + | ppaaiirr__ppaasssstthhrroouugghh(...) from builtins.PyCapsule + | Signature : pair_passthrough(Example2, (bool, str)) -> (str, bool) + | + | Return a pair in reversed order + | + | pprriinntt__ddiicctt(...) from builtins.PyCapsule + | Signature : print_dict(Example2, dict) -> None + | + | Print entries of a Python dictionary + | + | pprriinntt__ddiicctt__22(...) from builtins.PyCapsule + | Signature : print_dict_2(Example2, dict) -> None + | + | Print entries of a C++ dictionary + | + | pprriinntt__lliisstt(...) from builtins.PyCapsule + | Signature : print_list(Example2, list) -> None + | + | Print entries of a Python list + | + | pprriinntt__lliisstt__22(...) from builtins.PyCapsule + | Signature : print_list_2(Example2, list) -> None + | + | Print entries of a C++ list + | + | tthhrrooww__eexxcceeppttiioonn(...) from builtins.PyCapsule + | Signature : throw_exception(Example2) -> None + | + | Throw an exception + | + | ttuuppllee__ppaasssstthhrroouugghh(...) from builtins.PyCapsule + | Signature : tuple_passthrough(Example2, (bool, str, int32_t)) -> (int32_t, str, bool) + | + | Return a triple in reversed order + | + | ---------------------------------------------------------------------- + | Data and other attributes defined here: + | + | ____iinnssttaannccee__ssiizzee____ = 1 + +Destructing Example2 diff --git a/example/example3.cpp b/example/example3.cpp new file mode 100644 index 000000000..fec5d30a6 --- /dev/null +++ b/example/example3.cpp @@ -0,0 +1,65 @@ +/* + example/example3.cpp -- Example 3: operator overloading + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" +#include + +class Vector2 { +public: + Vector2(float x, float y) : x(x), y(y) { std::cout << "Value constructor" << std::endl; } + Vector2(const Vector2 &v) : x(v.x), y(v.y) { std::cout << "Copy constructor" << std::endl; } + Vector2(Vector2 &&v) : x(v.x), y(v.y) { std::cout << "Move constructor" << std::endl; v.x = v.y = 0; } + ~Vector2() { std::cout << "Destructor." << std::endl; } + + std::string toString() const { + return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; + } + + void operator=(const Vector2 &v) { + cout << "Assignment operator" << endl; + x = v.x; + y = v.y; + } + + void operator=(Vector2 &&v) { + cout << "Move assignment operator" << endl; + x = v.x; y = v.y; v.x = v.y = 0; + } + + Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); } + Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y - v.y); } + Vector2 operator-(float value) const { return Vector2(x - value, y - value); } + Vector2 operator+(float value) const { return Vector2(x + value, y + value); } + Vector2 operator*(float value) const { return Vector2(x * value, y * value); } + Vector2 operator/(float value) const { return Vector2(x / value, y / value); } + Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; } + Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; } + Vector2& operator*=(float v) { x *= v; y *= v; return *this; } + Vector2& operator/=(float v) { x /= v; y /= v; return *this; } +private: + float x, y; +}; + +void init_ex3(py::module &m) { + py::class_(m, "Vector2") + .def(py::init()) + .def(py::self + py::self) + .def(py::self + float()) + .def(py::self - py::self) + .def(py::self - float()) + .def(py::self * float()) + .def(py::self / float()) + .def(py::self += py::self) + .def(py::self -= py::self) + .def(py::self *= float()) + .def(py::self /= float()) + .def("__str__", &Vector2::toString); + + m.attr("Vector") = m.attr("Vector2"); +} diff --git a/example/example3.py b/example/example3.py new file mode 100755 index 000000000..a88932057 --- /dev/null +++ b/example/example3.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import Vector2, Vector + +v1 = Vector2(1, 2) +v2 = Vector(3, -1) + +print("v1 = " + str(v1)) +print("v2 = " + str(v2)) +print("v1+v2 = " + str(v1+v2)) +print("v1-v2 = " + str(v1-v2)) +print("v1-8 = " + str(v1-8)) +print("v1+8 = " + str(v1+8)) +print("v1*8 = " + str(v1*8)) +print("v1/8 = " + str(v1/8)) + +v1 += v2 +v1 *= 2 + +print("(v1+v2)*2 = " + str(v1)) diff --git a/example/example3.ref b/example/example3.ref new file mode 100644 index 000000000..e45c110df --- /dev/null +++ b/example/example3.ref @@ -0,0 +1,37 @@ +Value constructor +Value constructor +Value constructor +Copy constructor +Destructor. +Destructor. +Value constructor +Copy constructor +Destructor. +Destructor. +Value constructor +Copy constructor +Destructor. +Destructor. +Value constructor +Copy constructor +Destructor. +Destructor. +Value constructor +Copy constructor +Destructor. +Destructor. +Value constructor +Copy constructor +Destructor. +Destructor. +v1 = [1.000000, 2.000000] +v2 = [3.000000, -1.000000] +v1+v2 = [4.000000, 1.000000] +v1-v2 = [-2.000000, 3.000000] +v1-8 = [-7.000000, -6.000000] +v1+8 = [9.000000, 10.000000] +v1*8 = [8.000000, 16.000000] +v1/8 = [0.125000, 0.250000] +(v1+v2)*2 = [8.000000, 2.000000] +Destructor. +Destructor. diff --git a/example/example4.cpp b/example/example4.cpp new file mode 100644 index 000000000..ed9d0da5a --- /dev/null +++ b/example/example4.cpp @@ -0,0 +1,60 @@ +/* + example/example4.cpp -- Example 4: global constants and functions, enumerations + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +enum EMyEnumeration { + EFirstEntry = 1, + ESecondEntry +}; + +class Example4 { +public: + enum EMode { + EFirstMode = 1, + ESecondMode + }; + + static void test_function(EMode mode) { + std::cout << "Example4::test_function(enum=" << mode << ")" << std::endl; + } +}; + +bool test_function1() { + std::cout << "test_function()" << std::endl; + return false; +} + +float test_function2(int i) { + std::cout << "test_function(" << i << ")" << std::endl; + return i / 2.f; +} + +void test_function3(EMyEnumeration k) { + std::cout << "test_function(enum=" << k << ")" << std::endl; +} + +void init_ex4(py::module &m) { + m.def("test_function", &test_function1); + m.def("test_function", &test_function2); + m.def("test_function", &test_function3); + m.attr("some_constant") = py::int_(14); + + py::enum_(m, "EMyEnumeration") + .value("EFirstEntry", EFirstEntry) + .value("ESecondEntry", ESecondEntry) + .export_values(); + + py::class_ ex4_class(m, "Example4"); + ex4_class.def_static("test_function", &Example4::test_function); + py::enum_(ex4_class, "EMode") + .value("EFirstMode", Example4::EFirstMode) + .value("ESecondMode", Example4::ESecondMode) + .export_values(); +} diff --git a/example/example4.py b/example/example4.py new file mode 100755 index 000000000..aa2a448a4 --- /dev/null +++ b/example/example4.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import test_function +from example import some_constant +from example import EMyEnumeration +from example import EFirstEntry +from example import Example4 + +print(EMyEnumeration) +print(EMyEnumeration.EFirstEntry) +print(EMyEnumeration.ESecondEntry) +print(EFirstEntry) + +print(test_function()) +print(test_function(7)) +print(test_function(EMyEnumeration.EFirstEntry)) +print(test_function(EMyEnumeration.ESecondEntry)) + +print(Example4.EMode) +print(Example4.EMode.EFirstMode) +print(Example4.EFirstMode) +Example4.test_function(Example4.EFirstMode) diff --git a/example/example4.ref b/example/example4.ref new file mode 100644 index 000000000..09935a96a --- /dev/null +++ b/example/example4.ref @@ -0,0 +1,16 @@ +test_function() +test_function(7) +test_function(enum=1) +test_function(enum=2) +Example4::test_function(enum=1) + +EMyEnumeration.EFirstEntry +EMyEnumeration.ESecondEntry +EMyEnumeration.EFirstEntry +False +3.5 +None +None + +EMode.EFirstMode +EMode.EFirstMode diff --git a/example/example5.cpp b/example/example5.cpp new file mode 100644 index 000000000..7d617793d --- /dev/null +++ b/example/example5.cpp @@ -0,0 +1,95 @@ +/* + example/example5.cpp -- Example 5: inheritance, callbacks, acquiring + and releasing the global interpreter lock + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + + +class Pet { +public: + Pet(const std::string &name, const std::string &species) + : m_name(name), m_species(species) {} + std::string name() const { return m_name; } + std::string species() const { return m_species; } +private: + std::string m_name; + std::string m_species; +}; + +class Dog : public Pet { +public: + Dog(const std::string &name) : Pet(name, "dog") {} + void bark() const { std::cout << "Woof!" << std::endl; } +}; + +void pet_print(const Pet &pet) { + std::cout << pet.name() + " is a " + pet.species() << std::endl; +} + +void dog_bark(const Dog &dog) { + dog.bark(); +} + +class Example5 { +public: + Example5(py::handle self, int state) + : self(self), state(state) { + cout << "Constructing Example5.." << endl; + } + + ~Example5() { + cout << "Destructing Example5.." << endl; + } + + void callback(int value) { + py::gil_scoped_acquire gil; + cout << "In Example5::callback() " << endl; + py::object method = self.attr("callback"); + method.call(state, value); + } +private: + py::handle self; + int state; +}; + +bool test_callback1(py::object func) { + func.call(); + return false; +} + +int test_callback2(py::object func) { + py::object result = func.call("Hello", true, 5); + return result.cast(); +} + +void test_callback3(Example5 *ex, int value) { + py::gil_scoped_release gil; + ex->callback(value); +} + +void init_ex5(py::module &m) { + py::class_ pet_class(m, "Pet"); + pet_class + .def(py::init()) + .def("name", &Pet::name) + .def("species", &Pet::species); + + py::class_(m, "Dog", pet_class) + .def(py::init()); + + m.def("pet_print", pet_print); + m.def("dog_bark", dog_bark); + + m.def("test_callback1", &test_callback1); + m.def("test_callback2", &test_callback2); + m.def("test_callback3", &test_callback3); + + py::class_(m, "Example5") + .def(py::init()); +} diff --git a/example/example5.py b/example/example5.py new file mode 100755 index 000000000..b119de975 --- /dev/null +++ b/example/example5.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import Pet +from example import Dog +from example import dog_bark +from example import pet_print + +polly = Pet('Polly', 'parrot') +molly = Dog('Molly') +print(polly.name() + " is a " + polly.species()) +pet_print(polly) +print(molly.name() + " is a " + molly.species()) +pet_print(molly) +dog_bark(molly) +try: + dog_bark(polly) +except Exception as e: + print('The following error is expected: ' + str(e)) + +from example import test_callback1 +from example import test_callback2 +from example import test_callback3 +from example import Example5 + +def func1(): + print('Callback function 1 called!') + +def func2(a, b, c): + print('Callback function 2 called : ' + str(a) + ", " + str(b) + ", "+ str(c)) + return c + +class MyCallback(Example5): + def __init__(self, value): + Example5.__init__(self, self, value) + + def callback(self, value1, value2): + print('got callback: %i %i' % (value1, value2)) + +print(test_callback1(func1)) +print(test_callback2(func2)) + +callback = MyCallback(3) +test_callback3(callback, 4) diff --git a/example/example5.ref b/example/example5.ref new file mode 100644 index 000000000..406112888 --- /dev/null +++ b/example/example5.ref @@ -0,0 +1,16 @@ +Polly is a parrot +Molly is a dog +Woof! +Constructing Example5.. +In Example5::callback() +Polly is a parrot +Molly is a dog +The following error is expected: Incompatible function arguments. The following argument types are supported: + 1. dog_bark(Dog) -> None + +Callback function 1 called! +False +Callback function 2 called : Hello, True, 5 +5 +got callback: 3 4 +Destructing Example5.. diff --git a/example/example6.cpp b/example/example6.cpp new file mode 100644 index 000000000..1e0359ace --- /dev/null +++ b/example/example6.cpp @@ -0,0 +1,175 @@ +/* + example/example6.cpp -- Example 6: supporting Pythons' sequence + protocol, iterators, etc. + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" +#include + +class Sequence { +public: + Sequence(size_t size) : m_size(size) { + std::cout << "Value constructor: Creating a sequence with " << m_size << " entries" << std::endl; + m_data = new float[size]; + memset(m_data, 0, sizeof(float) * size); + } + + Sequence(const std::vector &value) : m_size(value.size()) { + std::cout << "Value constructor: Creating a sequence with " << m_size << " entries" << std::endl; + m_data = new float[m_size]; + memcpy(m_data, &value[0], sizeof(float) * m_size); + } + + Sequence(const Sequence &s) : m_size(s.m_size) { + std::cout << "Copy constructor: Creating a sequence with " << m_size << " entries" << std::endl; + m_data = new float[m_size]; + memcpy(m_data, s.m_data, sizeof(float)*m_size); + } + + Sequence(Sequence &&s) : m_size(s.m_size), m_data(s.m_data) { + std::cout << "Move constructor: Creating a sequence with " << m_size << " entries" << std::endl; + s.m_size = 0; + s.m_data = nullptr; + } + + ~Sequence() { + std::cout << "Freeing a sequence with " << m_size << " entries" << std::endl; + delete[] m_data; + } + + Sequence &operator=(const Sequence &s) { + std::cout << "Assignment operator: Creating a sequence with " << s.m_size << " entries" << std::endl; + delete[] m_data; + m_size = s.m_size; + m_data = new float[m_size]; + memcpy(m_data, s.m_data, sizeof(float)*m_size); + return *this; + } + + Sequence &operator=(Sequence &&s) { + std::cout << "Move assignment operator: Creating a sequence with " << s.m_size << " entries" << std::endl; + if (&s != this) { + delete[] m_data; + m_size = s.m_size; + m_data = s.m_data; + s.m_size = 0; + s.m_data = nullptr; + } + return *this; + } + + bool operator==(const Sequence &s) const { + if (m_size != s.size()) + return false; + for (size_t i=0; i seq(m, "Sequence"); + + seq.def(py::init()) + .def(py::init&>()) + /// Bare bones interface + .def("__getitem__", [](const Sequence &s, size_t i) { + if (i >= s.size()) + throw py::index_error(); + return s[i]; + }) + .def("__setitem__", [](Sequence &s, size_t i, float v) { + if (i >= s.size()) + throw py::index_error(); + s[i] = v; + }) + .def("__len__", &Sequence::size) + /// Optional sequence protocol operations + .def("__iter__", [](py::object s) { return PySequenceIterator(s.cast(), s); }) + .def("__contains__", [](const Sequence &s, float v) { return s.contains(v); }) + .def("__reversed__", [](const Sequence &s) -> Sequence { return s.reversed(); }) + /// Slicing protocol (optional) + .def("__getitem__", [](const Sequence &s, py::slice slice) -> Sequence* { + py::ssize_t start, stop, step, slicelength; + if (!slice.compute(s.size(), &start, &stop, &step, &slicelength)) + throw py::error_already_set(); + Sequence *seq = new Sequence(slicelength); + for (int i=0; i(seq, "Iterator") + .def("__iter__", [](PySequenceIterator &it) -> PySequenceIterator& { return it; }) + .def("__next__", &PySequenceIterator::next); +} diff --git a/example/example6.py b/example/example6.py new file mode 100755 index 000000000..7dbadc4b1 --- /dev/null +++ b/example/example6.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import Sequence + +s = Sequence(5) +print("s = " + str(s)) +print("len(s) = " + str(len(s))) +print("s[0], s[3] = %f %f" % (s[0], s[3])) +print('12.34 in s: ' + str(12.34 in s)) +s[0], s[3] = 12.34, 56.78 +print('12.34 in s: ' + str(12.34 in s)) +print("s[0], s[3] = %f %f" % (s[0], s[3])) +rev = reversed(s) +rev2 = s[::-1] +print("rev[0], rev[1], rev[2], rev[3], rev[4] = %f %f %f %f %f" % (rev[0], rev[1], rev[2], rev[3], rev[4])) + +for i in rev: + print(i, end=' ') +print('') +for i in rev2: + print(i, end=' ') +print('') +print(rev == rev2) +rev[0::2] = Sequence([2.0, 2.0, 2.0]) +for i in rev: + print(i, end=' ') +print('') diff --git a/example/example6.ref b/example/example6.ref new file mode 100644 index 000000000..8986be6a6 --- /dev/null +++ b/example/example6.ref @@ -0,0 +1,18 @@ +Value constructor: Creating a sequence with 5 entries +Value constructor: Creating a sequence with 5 entries +Copy constructor: Creating a sequence with 5 entries +Freeing a sequence with 5 entries +s = +len(s) = 5 +s[0], s[3] = 0.000000 0.000000 +12.34 in s: False +12.34 in s: True +s[0], s[3] = 12.340000 56.779999 +rev[0], rev[1], rev[2], rev[3], rev[4] = 0.000000 56.779999 0.000000 0.000000 12.340000 +12.34000015258789 +0.0 +0.0 +56.779998779296875 +0.0 +Freeing a sequence with 5 entries +Freeing a sequence with 5 entries diff --git a/example/example7.cpp b/example/example7.cpp new file mode 100644 index 000000000..82ab3b656 --- /dev/null +++ b/example/example7.cpp @@ -0,0 +1,115 @@ +/* + example/example7.cpp -- Example 7: supporting Pythons' buffer protocol + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +class Matrix { +public: + Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) { + std::cout << "Value constructor: Creating a " << rows << "x" << cols << " matrix " << std::endl; + m_data = new float[rows*cols]; + memset(m_data, 0, sizeof(float) * rows * cols); + } + + Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) { + std::cout << "Copy constructor: Creating a " << m_rows << "x" << m_cols << " matrix " << std::endl; + m_data = new float[m_rows * m_cols]; + memcpy(m_data, s.m_data, sizeof(float) * m_rows * m_cols); + } + + Matrix(Matrix &&s) : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) { + std::cout << "Move constructor: Creating a " << m_rows << "x" << m_cols << " matrix " << std::endl; + s.m_rows = 0; + s.m_cols = 0; + s.m_data = nullptr; + } + + ~Matrix() { + std::cout << "Freeing a " << m_rows << "x" << m_cols << " matrix " << std::endl; + delete[] m_data; + } + + Matrix &operator=(const Matrix &s) { + std::cout << "Assignment operator : Creating a " << s.m_rows << "x" << s.m_cols << " matrix " << std::endl; + delete[] m_data; + m_rows = s.m_rows; + m_cols = s.m_cols; + m_data = new float[m_rows * m_cols]; + memcpy(m_data, s.m_data, sizeof(float) * m_rows * m_cols); + return *this; + } + + Matrix &operator=(Matrix &&s) { + std::cout << "Move assignment operator : Creating a " << s.m_rows << "x" << s.m_cols << " matrix " << std::endl; + if (&s != this) { + delete[] m_data; + m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data; + s.m_rows = 0; s.m_cols = 0; s.m_data = nullptr; + } + return *this; + } + + float operator()(size_t i, size_t j) const { + return m_data[i*m_cols + j]; + } + + float &operator()(size_t i, size_t j) { + return m_data[i*m_cols + j]; + } + + float *data() { return m_data; } + + size_t rows() const { return m_rows; } + size_t cols() const { return m_cols; } +private: + size_t m_rows; + size_t m_cols; + float *m_data; +}; + +void init_ex7(py::module &m) { + py::class_ mtx(m, "Matrix"); + + mtx.def(py::init()) + /// Construct from a buffer + .def("__init__", [](Matrix &v, py::buffer b) { + py::buffer_info info = b.request(); + if (info.format != py::format_descriptor::value() || info.ndim != 2) + throw std::runtime_error("Incompatible buffer format!"); + new (&v) Matrix(info.shape[0], info.shape[1]); + memcpy(v.data(), info.ptr, sizeof(float) * v.rows() * v.cols()); + }) + + .def("rows", &Matrix::rows) + .def("cols", &Matrix::cols) + + /// Bare bones interface + .def("__getitem__", [](const Matrix &m, std::pair i) { + if (i.first >= m.rows() || i.second >= m.cols()) + throw py::index_error(); + return m(i.first, i.second); + }) + .def("__setitem__", [](Matrix &m, std::pair i, float v) { + if (i.first >= m.rows() || i.second >= m.cols()) + throw py::index_error(); + m(i.first, i.second) = v; + }) + /// Provide buffer access + .def_buffer([](Matrix &m) -> py::buffer_info { + return py::buffer_info( + m.data(), /* Pointer to buffer */ + sizeof(float), /* Size of one scalar */ + py::format_descriptor::value(), /* Python struct-style format descriptor */ + 2, /* Number of dimensions */ + { m.rows(), m.cols() }, /* Buffer dimensions */ + { sizeof(float) * m.rows(), /* Strides (in bytes) for each index */ + sizeof(float) } + ); + }); +} diff --git a/example/example7.py b/example/example7.py new file mode 100755 index 000000000..565ceac63 --- /dev/null +++ b/example/example7.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import Matrix +import numpy as np + +m = Matrix(5, 5) + +print(m[2, 3]) +m[2, 3] = 4 +print(m[2, 3]) + +m2 = np.array(m, copy=False) +print(m2) +print(m2[2, 3]) +m2[2, 3] = 5 +print(m[2, 3]) + +m3 = np.array([[1,2,3],[4,5,6]]).astype(np.float32) +print(m3) +m4 = Matrix(m3) +for i in range(m4.rows()): + for j in range(m4.cols()): + print(m4[i, j], end = ' ') + print() diff --git a/example/example7.ref b/example/example7.ref new file mode 100644 index 000000000..6112cf6a8 --- /dev/null +++ b/example/example7.ref @@ -0,0 +1,11 @@ +Value constructor: Creating a 5x5 matrix +0.0 +4.0 +[[ 0. 0. 0. 0. 0.] + [ 0. 0. 0. 0. 0.] + [ 0. 0. 0. 4. 0.] + [ 0. 0. 0. 0. 0.] + [ 0. 0. 0. 0. 0.]] +4.0 +5.0 +Freeing a 5x5 matrix diff --git a/example/example8.cpp b/example/example8.cpp new file mode 100644 index 000000000..3aac43a34 --- /dev/null +++ b/example/example8.cpp @@ -0,0 +1,76 @@ +/* + example/example8.cpp -- Example 8: binding classes with + custom reference counting, implicit conversions between types + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" +#include "object.h" + +/// Object subclass +class MyObject : public Object { +public: + MyObject(int value) : value(value) { + std::cout << toString() << " constructor" << std::endl; + } + + std::string toString() const { + return "MyObject[" + std::to_string(value) + "]"; + } + +protected: + virtual ~MyObject() { + std::cout << toString() << " destructor" << std::endl; + } + +private: + int value; +}; + +/// Make pybind aware of the ref-counted wrapper type +namespace pybind { namespace detail { +template class type_caster> + : public type_caster_holder> { }; +}} + +Object *make_object_1() { return new MyObject(1); } +ref make_object_2() { return new MyObject(2); } +MyObject *make_myobject_4() { return new MyObject(4); } +ref make_myobject_5() { return new MyObject(5); } + +void print_object_1(const Object *obj) { std::cout << obj->toString() << std::endl; } +void print_object_2(ref obj) { std::cout << obj->toString() << std::endl; } +void print_object_3(const ref &obj) { std::cout << obj->toString() << std::endl; } +void print_object_4(const ref *obj) { std::cout << (*obj)->toString() << std::endl; } + +void print_myobject_1(const MyObject *obj) { std::cout << obj->toString() << std::endl; } +void print_myobject_2(ref obj) { std::cout << obj->toString() << std::endl; } +void print_myobject_3(const ref &obj) { std::cout << obj->toString() << std::endl; } +void print_myobject_4(const ref *obj) { std::cout << (*obj)->toString() << std::endl; } + +void init_ex8(py::module &m) { + py::class_> obj(m, "Object"); + obj.def("getRefCount", &Object::getRefCount); + + py::class_>(m, "MyObject", obj) + .def(py::init()); + + m.def("make_object_1", &make_object_1); + m.def("make_object_2", &make_object_2); + m.def("make_myobject_4", &make_myobject_4); + m.def("make_myobject_5", &make_myobject_5); + m.def("print_object_1", &print_object_1); + m.def("print_object_2", &print_object_2); + m.def("print_object_3", &print_object_3); + m.def("print_object_4", &print_object_4); + m.def("print_myobject_1", &print_myobject_1); + m.def("print_myobject_2", &print_myobject_2); + m.def("print_myobject_3", &print_myobject_3); + m.def("print_myobject_4", &print_myobject_4); + + py::implicitly_convertible(); +} diff --git a/example/example8.py b/example/example8.py new file mode 100644 index 000000000..9c295d29d --- /dev/null +++ b/example/example8.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +from example import MyObject +from example import make_object_1 +from example import make_object_2 +from example import make_myobject_4 +from example import make_myobject_5 +from example import print_object_1 +from example import print_object_2 +from example import print_object_3 +from example import print_object_4 +from example import print_myobject_1 +from example import print_myobject_2 +from example import print_myobject_3 +from example import print_myobject_4 + +for o in [make_object_1(), make_object_2(), MyObject(3)]: + print("Reference count = %i" % o.getRefCount()) + print_object_1(o) + print_object_2(o) + print_object_3(o) + print_object_4(o) + +for o in [make_myobject_4(), make_myobject_5(), MyObject(6), 7]: + print(o) + if not isinstance(o, int): + print_object_1(o) + print_object_2(o) + print_object_3(o) + print_object_4(o) + print_myobject_1(o) + print_myobject_2(o) + print_myobject_3(o) + print_myobject_4(o) diff --git a/example/example9.cpp b/example/example9.cpp new file mode 100644 index 000000000..0e070b1c2 --- /dev/null +++ b/example/example9.cpp @@ -0,0 +1,53 @@ +/* + example/example9.cpp -- Example 9: nested modules + and internal references + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#include "example.h" + +void submodule_func() { + std::cout << "submodule_func()" << std::endl; +} + +class A { +public: + A(int v) : v(v) { std::cout << "A constructor" << std::endl; } + ~A() { std::cout << "A destructor" << std::endl; } + A(const A&) { std::cout << "A copy constructor" << std::endl; } + std::string toString() { return "A[" + std::to_string(v) + "]"; } +private: + int v; +}; + +class B { +public: + B() { std::cout << "B constructor" << std::endl; } + ~B() { std::cout << "B destructor" << std::endl; } + B(const B&) { std::cout << "B copy constructor" << std::endl; } + A &get_a1() { return a1; } + A &get_a2() { return a2; } + + A a1{1}; + A a2{2}; +}; + +void init_ex9(py::module &m) { + py::module m_sub = m.def_submodule("submodule"); + m_sub.def("submodule_func", &submodule_func); + + py::class_(m_sub, "A") + .def(py::init()) + .def("__repr__", &A::toString); + + py::class_(m_sub, "B") + .def(py::init<>()) + .def("get_a1", &B::get_a1, "Return the internal A 1", py::return_value_policy::reference_internal) + .def("get_a2", &B::get_a2, "Return the internal A 2", py::return_value_policy::reference_internal) + .def_readwrite("a1", &B::a1) // def_readonly uses an internal reference return policy by default + .def_readwrite("a2", &B::a2); +} diff --git a/example/example9.py b/example/example9.py new file mode 100644 index 000000000..d8c654ebe --- /dev/null +++ b/example/example9.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +import sys +sys.path.append('.') + +import example + +print(example.__name__) +print(example.submodule.__name__) + +from example.submodule import * + +submodule_func() + +b = B() +print(b.get_a1()) +print(b.a1) +print(b.get_a2()) +print(b.a2) + +b.a1 = A(42) +b.a2 = A(43) + +print(b.get_a1()) +print(b.a1) +print(b.get_a2()) +print(b.a2) + diff --git a/example/object.h b/example/object.h new file mode 100644 index 000000000..8097bd671 --- /dev/null +++ b/example/object.h @@ -0,0 +1,160 @@ +#if !defined(__OBJECT_H) +#define __OBJECT_H + +#include + +/// Reference counted object base class +class Object { +public: + /// Default constructor + Object() { } + + /// Copy constructor + Object(const Object &) : m_refCount(0) {} + + /// Return the current reference count + int getRefCount() const { return m_refCount; }; + + /// Increase the object's reference count by one + void incRef() const { ++m_refCount; } + + /** \brief Decrease the reference count of + * the object and possibly deallocate it. + * + * The object will automatically be deallocated once + * the reference count reaches zero. + */ + void decRef(bool dealloc = true) const { + --m_refCount; + if (m_refCount == 0 && dealloc) + delete this; + else if (m_refCount < 0) + throw std::runtime_error("Internal error: reference count < 0!"); + } + + virtual std::string toString() const = 0; +protected: + /** \brief Virtual protected deconstructor. + * (Will only be called by \ref ref) + */ + virtual ~Object() { } +private: + mutable std::atomic m_refCount { 0 }; +}; + +/** + * \brief Reference counting helper + * + * The \a ref refeference template is a simple wrapper to store a + * pointer to an object. It takes care of increasing and decreasing + * the reference count of the object. When the last reference goes + * out of scope, the associated object will be deallocated. + * + * \ingroup libcore + */ +template class ref { +public: + /// Create a nullptr reference + ref() : m_ptr(nullptr) { std::cout << "Created empty ref" << std::endl; } + + /// Construct a reference from a pointer + ref(T *ptr) : m_ptr(ptr) { + std::cout << "Initialized ref from pointer " << ptr<< std::endl; + if (m_ptr) ((Object *) m_ptr)->incRef(); + } + + /// Copy constructor + ref(const ref &r) : m_ptr(r.m_ptr) { + std::cout << "Initialized ref from ref " << r.m_ptr << std::endl; + if (m_ptr) + ((Object *) m_ptr)->incRef(); + } + + /// Move constructor + ref(ref &&r) : m_ptr(r.m_ptr) { + std::cout << "Initialized ref with move from ref " << r.m_ptr << std::endl; + r.m_ptr = nullptr; + } + + /// Destroy this reference + ~ref() { + std::cout << "Destructing ref " << m_ptr << std::endl; + if (m_ptr) + ((Object *) m_ptr)->decRef(); + } + + /// Move another reference into the current one + ref& operator=(ref&& r) { + std::cout << "Move-assigning ref " << r.m_ptr << std::endl; + if (*this == r) + return *this; + if (m_ptr) + ((Object *) m_ptr)->decRef(); + m_ptr = r.m_ptr; + r.m_ptr = nullptr; + return *this; + } + + /// Overwrite this reference with another reference + ref& operator=(const ref& r) { + std::cout << "Assigning ref " << r.m_ptr << std::endl; + if (m_ptr == r.m_ptr) + return *this; + if (m_ptr) + ((Object *) m_ptr)->decRef(); + m_ptr = r.m_ptr; + if (m_ptr) + ((Object *) m_ptr)->incRef(); + return *this; + } + + /// Overwrite this reference with a pointer to another object + ref& operator=(T *ptr) { + std::cout << "Assigning ptr " << ptr << " to ref" << std::endl; + if (m_ptr == ptr) + return *this; + if (m_ptr) + ((Object *) m_ptr)->decRef(); + m_ptr = ptr; + if (m_ptr) + ((Object *) m_ptr)->incRef(); + return *this; + } + + /// Compare this reference with another reference + bool operator==(const ref &r) const { return m_ptr == r.m_ptr; } + + /// Compare this reference with another reference + bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; } + + /// Compare this reference with a pointer + bool operator==(const T* ptr) const { return m_ptr == ptr; } + + /// Compare this reference with a pointer + bool operator!=(const T* ptr) const { return m_ptr != ptr; } + + /// Access the object referenced by this reference + T* operator->() { return m_ptr; } + + /// Access the object referenced by this reference + const T* operator->() const { return m_ptr; } + + /// Return a C++ reference to the referenced object + T& operator*() { return *m_ptr; } + + /// Return a const C++ reference to the referenced object + const T& operator*() const { return *m_ptr; } + + /// Return a pointer to the referenced object + operator T* () { return m_ptr; } + + /// Return a const pointer to the referenced object + T* get() { return m_ptr; } + + /// Return a pointer to the referenced object + const T* get() const { return m_ptr; } +private: + T *m_ptr; +}; + +#endif /* __OBJECT_H */ diff --git a/example/run_test.py b/example/run_test.py new file mode 100644 index 000000000..1c47cc017 --- /dev/null +++ b/example/run_test.py @@ -0,0 +1,16 @@ +import subprocess, sys, os + +path = os.path.dirname(__file__) +if path != '': + os.chdir(path) + +name = sys.argv[1] +output = subprocess.check_output([sys.executable, name + ".py"]).decode('utf-8') +reference = open(name + '.ref', 'r').read() + +if output == reference: + print('Test "%s" succeeded.' % name) + exit(0) +else: + print('Test "%s" FAILED!' % name) + exit(-1) diff --git a/include/pybind/cast.h b/include/pybind/cast.h new file mode 100644 index 000000000..6b3b96e3a --- /dev/null +++ b/include/pybind/cast.h @@ -0,0 +1,526 @@ +/* + pybind/cast.h: Partial template specializations to cast between + C++ and Python types + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_CAST) +#define __PYBIND_CAST + +#include "pytypes.h" +#include "mpl.h" +#include "typeid.h" +#include +#include + +NAMESPACE_BEGIN(pybind) +NAMESPACE_BEGIN(detail) + +/// Generic type caster for objects stored on the heap +template class type_caster { +public: + typedef instance instance_type; + + static std::string name() { return type_id(); } + + type_caster() { + auto const& registered_types = get_internals().registered_types; + auto it = registered_types.find(type_id()); + if (it != registered_types.end()) + typeinfo = &it->second; + } + + bool load(PyObject *src, bool convert) { + if (src == nullptr || typeinfo == nullptr) + return false; + if (PyType_IsSubtype(Py_TYPE(src), typeinfo->type)) { + value = ((instance_type *) src)->value; + return true; + } + if (convert) { + for (auto &converter : typeinfo->implicit_conversions) { + temp = object(converter(src, typeinfo->type), false); + if (load(temp.ptr(), false)) + return true; + } + } + return false; + } + + static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) { + if (policy == return_value_policy::automatic) + policy = return_value_policy::copy; + return cast(&src, policy, parent); + } + + static PyObject *cast(const type *_src, return_value_policy policy, PyObject *parent) { + type *src = const_cast(_src); + if (src == nullptr) { + Py_INCREF(Py_None); + return Py_None; + } + // avoid an issue with internal references matching their parent's address + bool dont_cache = parent && ((instance *) parent)->value == (void *) src; + auto& internals = get_internals(); + auto it_instance = internals.registered_instances.find(src); + if (it_instance != internals.registered_instances.end() && !dont_cache) { + PyObject *inst = it_instance->second; + Py_INCREF(inst); + return inst; + } + auto it = internals.registered_types.find(type_id()); + if (it == internals.registered_types.end()) { + std::string msg = std::string("Unregistered type : ") + type_id(); + PyErr_SetString(PyExc_TypeError, msg.c_str()); + return nullptr; + } + auto &type_info = it->second; + instance_type *inst = (instance_type *) PyType_GenericAlloc(type_info.type, 0); + inst->value = src; + inst->owned = true; + inst->parent = nullptr; + if (policy == return_value_policy::automatic) + policy = return_value_policy::take_ownership; + handle_return_value_policy(inst, policy, parent); + PyObject *inst_pyobj = (PyObject *) inst; + type_info.init_holder(inst_pyobj); + if (!dont_cache) + internals.registered_instances[inst->value] = inst_pyobj; + return inst_pyobj; + } + + template ::value, int>::type = 0> + static void handle_return_value_policy(instance *inst, return_value_policy policy, PyObject *parent) { + if (policy == return_value_policy::copy) { + inst->value = new T(*(inst->value)); + } else if (policy == return_value_policy::reference) { + inst->owned = false; + } else if (policy == return_value_policy::reference_internal) { + inst->owned = false; + inst->parent = parent; + Py_XINCREF(parent); + } + } + + template ::value, int>::type = 0> + static void handle_return_value_policy(instance *inst, return_value_policy policy, PyObject *parent) { + if (policy == return_value_policy::copy) { + throw cast_error("return_value_policy = copy, but the object is non-copyable!"); + } else if (policy == return_value_policy::reference) { + inst->owned = false; + } else if (policy == return_value_policy::reference_internal) { + inst->owned = false; + inst->parent = parent; + Py_XINCREF(parent); + } + } + + operator type*() { return value; } + operator type&() { return *value; } +protected: + type *value = nullptr; + const type_info *typeinfo = nullptr; + object temp; +}; + +#define TYPE_CASTER(type, py_name) \ + protected: \ + type value; \ + public: \ + static std::string name() { return py_name; } \ + static PyObject *cast(const type *src, return_value_policy policy, PyObject *parent) { \ + return cast(*src, policy, parent); \ + } \ + operator type*() { return &value; } \ + operator type&() { return value; } \ + +#define TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \ + template <> class type_caster { \ + public: \ + bool load(PyObject *src, bool) { \ + value = (type) from_type(src); \ + if (value == (type) -1 && PyErr_Occurred()) { \ + PyErr_Clear(); \ + return false; \ + } \ + return true; \ + } \ + static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \ + return to_pytype((py_type) src); \ + } \ + TYPE_CASTER(type, #type); \ + }; + +TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong) +TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong) +TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong, PyLong_FromLongLong) +TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong, PyLong_FromUnsignedLongLong) + +#if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X +TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t) +TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t) +#endif + +TYPE_CASTER_NUMBER(float, float, PyFloat_AsDouble, PyFloat_FromDouble) +TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble) + +template <> class type_caster { +public: + bool load(PyObject *, bool) { return true; } + static PyObject *cast(mpl::detail::void_type, return_value_policy /* policy */, PyObject * /* parent */) { + Py_INCREF(Py_None); + return Py_None; + } + TYPE_CASTER(mpl::detail::void_type, "None"); +}; + +template <> class type_caster { +public: + bool load(PyObject *src, bool) { + if (src == Py_True) { value = true; return true; } + else if (src == Py_False) { value = false; return true; } + else return false; + } + static PyObject *cast(bool src, return_value_policy /* policy */, PyObject * /* parent */) { + PyObject *result = src ? Py_True : Py_False; + Py_INCREF(result); + return result; + } + TYPE_CASTER(bool, "bool"); +}; + +template <> class type_caster { +public: + bool load(PyObject *src, bool) { + const char *ptr = PyUnicode_AsUTF8(src); + if (!ptr) { PyErr_Clear(); return false; } + value = std::string(ptr); + return true; + } + static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) { + return PyUnicode_FromString(src.c_str()); + } + TYPE_CASTER(std::string, "str"); +}; + +template <> class type_caster { +public: + bool load(PyObject *src, bool) { + char *ptr = PyUnicode_AsUTF8(src); + if (!ptr) { PyErr_Clear(); return false; } + value = ptr; + return true; + } + + static PyObject *cast(const char *src, return_value_policy /* policy */, PyObject * /* parent */) { + return PyUnicode_FromString(src); + } + + static PyObject *cast(char src, return_value_policy /* policy */, PyObject * /* parent */) { + char str[2] = { src, '\0' }; + return PyUnicode_DecodeLatin1(str, 1, nullptr); + } + + static std::string name() { return "str"; } + + operator char*() { return value; } + operator char() { return *value; } +protected: + char *value; +}; + +template struct type_caster> { + typedef std::vector type; + typedef type_caster value_conv; +public: + bool load(PyObject *src, bool convert) { + if (!PyList_Check(src)) + return false; + size_t size = (size_t) PyList_GET_SIZE(src); + value.reserve(size); + value.clear(); + for (size_t i=0; i"); +}; + +template struct type_caster> { +public: + typedef std::map type; + typedef type_caster key_conv; + typedef type_caster value_conv; + + bool load(PyObject *src, bool convert) { + if (!PyDict_Check(src)) + return false; + + value.clear(); + PyObject *key_, *value_; + ssize_t pos = 0; + key_conv kconv; + value_conv vconv; + while (PyDict_Next(src, &pos, &key_, &value_)) { + if (!kconv.load(key_, convert) || !vconv.load(value_, convert)) + return false; + value[kconv] = vconv; + } + return true; + } + + static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) { + PyObject *dict = PyDict_New(); + for (auto const &kv: src) { + PyObject *key = key_conv::cast(kv.first, policy, parent); + PyObject *value = value_conv::cast(kv.second, policy, parent); + if (!key || !value || PyDict_SetItem(dict, key, value) < 0) { + Py_XDECREF(key); + Py_XDECREF(value); + Py_DECREF(dict); + return nullptr; + } + Py_DECREF(key); + Py_DECREF(value); + } + return dict; + } + TYPE_CASTER(type, "dict<" + key_conv::name() + ", " + value_conv::name() + ">"); +}; + +template class type_caster> { + typedef std::pair type; +public: + bool load(PyObject *src, bool convert) { + if (!PyTuple_Check(src) || PyTuple_Size(src) != 2) + return false; + if (!first.load(PyTuple_GetItem(src, 0), convert)) + return false; + return second.load(PyTuple_GetItem(src, 1), convert); + } + + static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) { + PyObject *o1 = type_caster::type>::cast(src.first, policy, parent); + PyObject *o2 = type_caster::type>::cast(src.second, policy, parent); + if (!o1 || !o2) { + Py_XDECREF(o1); + Py_XDECREF(o2); + return nullptr; + } + PyObject *tuple = PyTuple_New(2); + PyTuple_SetItem(tuple, 0, o1); + PyTuple_SetItem(tuple, 1, o2); + return tuple; + } + + static std::string name() { + return "(" + type_caster::name() + ", " + type_caster::name() + ")"; + } + + operator type() { + return type(first, second); + } +protected: + type_caster::type> first; + type_caster::type> second; +}; + +template class type_caster> { + typedef std::tuple type; +public: + enum { size = sizeof...(Tuple) }; + + bool load(PyObject *src, bool convert) { + return load(src, convert, typename mpl::make_index_sequence::type()); + } + + static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) { + return cast(src, policy, parent, typename mpl::make_index_sequence::type()); + } + + static std::string name() { + std::array names {{ + type_caster::type>::name()... + }}; + std::string result("("); + int counter = 0; + for (auto const &name : names) { + result += name; + if (++counter < size) + result += ", "; + } + result += ")"; + return result; + } + + operator type() { + return cast(typename mpl::make_index_sequence::type()); + } +protected: + template type cast(mpl::index_sequence) { + return type((Tuple) std::get(value)...); + } + + template bool load(PyObject *src, bool convert, mpl::index_sequence) { + if (!PyTuple_Check(src)) + return false; + if (PyTuple_Size(src) != size) + return false; + std::array results {{ + std::get(value).load(PyTuple_GetItem(src, Indices), convert)... + }}; + for (bool r : results) + if (!r) + return false; + return true; + } + + /* Implementation: Convert a C++ tuple into a Python tuple */ + template static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent, mpl::index_sequence) { + std::array results {{ + type_caster::type>::cast(std::get(src), policy, parent)... + }}; + bool success = true; + for (auto result : results) + if (result == nullptr) + success = false; + if (success) { + PyObject *tuple = PyTuple_New(size); + int counter = 0; + for (auto result : results) + PyTuple_SetItem(tuple, counter++, result); + return tuple; + } else { + for (auto result : results) { + Py_XDECREF(result); + } + return nullptr; + } + } + +protected: + std::tuple::type>...> value; +}; + +/// Type caster for holder types like std::shared_ptr, etc. +template class type_caster_holder : public type_caster { +public: + typedef type_caster parent; + bool load(PyObject *src, bool convert) { + if (!parent::load(src, convert)) + return false; + holder = holder_type(parent::value); + return true; + } + explicit operator type*() { return this->value; } + explicit operator type&() { return *(this->value); } + explicit operator holder_type&() { return holder; } + explicit operator holder_type*() { return &holder; } +protected: + holder_type holder; +}; + +template <> class type_caster { +public: + bool load(PyObject *src) { + value = handle(src); + return true; + } + static PyObject *cast(const handle &src, return_value_policy /* policy */, PyObject * /* parent */) { + src.inc_ref(); + return (PyObject *) src.ptr(); + } + TYPE_CASTER(handle, "handle"); +}; + +#define TYPE_CASTER_PYTYPE(name) \ + template <> class type_caster { \ + public: \ + bool load(PyObject *src, bool) { value = name(src, true); return true; } \ + static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \ + src.inc_ref(); return (PyObject *) src.ptr(); \ + } \ + TYPE_CASTER(name, #name); \ + }; + +TYPE_CASTER_PYTYPE(object) +TYPE_CASTER_PYTYPE(buffer) +TYPE_CASTER_PYTYPE(capsule) +TYPE_CASTER_PYTYPE(dict) +TYPE_CASTER_PYTYPE(float_) +TYPE_CASTER_PYTYPE(int_) +TYPE_CASTER_PYTYPE(list) +TYPE_CASTER_PYTYPE(slice) +TYPE_CASTER_PYTYPE(tuple) + +#undef TYPE_CASTER +#undef TYPE_CASTER_NUMBER +#undef TYPE_CASTER_PYTYPE + +NAMESPACE_END(detail) + +template inline T cast(PyObject *object) { + detail::type_caster::type> conv; + if (!conv.load(object, true)) + throw cast_error("Unable to cast Python object to C++ type"); + return conv; +} + +template inline object cast(const T &value, return_value_policy policy = return_value_policy::automatic, PyObject *parent = nullptr) { + if (policy == return_value_policy::automatic) + policy = std::is_pointer::value ? return_value_policy::take_ownership : return_value_policy::copy; + return object(detail::type_caster::type>::cast(value, policy, parent), false); +} + +template inline T handle::cast() { return pybind::cast(m_ptr); } + +template inline object handle::call(Args&&... args_) { + const size_t size = sizeof...(Args); + std::array args{ + { detail::type_caster::type>::cast( + std::forward(args_), return_value_policy::automatic, nullptr)... } + }; + bool fail = false; + for (auto result : args) + if (result == nullptr) + fail = true; + if (fail) { + for (auto result : args) { + Py_XDECREF(result); + } + throw cast_error("handle::call(): unable to convert input arguments to Python objects"); + } + PyObject *tuple = PyTuple_New(size); + int counter = 0; + for (auto result : args) + PyTuple_SetItem(tuple, counter++, result); + PyObject *result = PyObject_CallObject(m_ptr, tuple); + Py_DECREF(tuple); + return object(result, false); +} + +NAMESPACE_END(pybind) + +#endif /* __PYBIND_CAST */ diff --git a/include/pybind/common.h b/include/pybind/common.h new file mode 100644 index 000000000..8310096c3 --- /dev/null +++ b/include/pybind/common.h @@ -0,0 +1,149 @@ +/* + pybind/common.h -- Basic macros + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_COMMON_H) +#define __PYBIND_COMMON_H + +#if !defined(NAMESPACE_BEGIN) +#define NAMESPACE_BEGIN(name) namespace name { +#endif +#if !defined(NAMESPACE_END) +#define NAMESPACE_END(name) } +#endif + +#if !defined(PYTHON_EXPORT) +#if defined(WIN32) +#define PYTHON_EXPORT __declspec(dllexport) +#else +#define PYTHON_EXPORT __attribute__ ((visibility("default"))) +#endif +#endif + +#define PYTHON_PLUGIN(name) \ + extern "C" PYTHON_EXPORT PyObject *PyInit_##name() + +#include +#include +#include +#include +#include +#include +#include + +/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode +#if defined(_MSC_VER) +#define HAVE_ROUND +#pragma warning(push) +#pragma warning(disable: 4510 4610 4512) +#if _DEBUG +#define _DEBUG_MARKER +#undef _DEBUG +#endif +#endif +#include +#if defined(_MSC_VER) +#if defined(_DEBUG_MARKER) +#define _DEBUG +#undef _DEBUG_MARKER +#endif +#pragma warning(pop) +#endif + +NAMESPACE_BEGIN(pybind) + +typedef Py_ssize_t ssize_t; + +/// Approach used to cast a previously unknown C++ instance into a Python object +enum class return_value_policy : int { + /** Automatic: copy objects returned as values and take ownership of objects + returned as pointers */ + automatic = 0, + /** Reference the object and take ownership. Python will call the + destructor and delete operator when the reference count reaches zero */ + take_ownership, + /** Reference the object, but do not take ownership (dangerous when C++ code + deletes it and Python still has a nonzero reference count) */ + reference, + /** Reference the object, but do not take ownership. The object is considered + be owned by the C++ instance whose method or property returned it. The + Python object will increase the reference count of this 'parent' by 1 */ + reference_internal, + /// Create a new copy of the returned object, which will be owned by Python + copy +}; + +/// Format strings for basic number types +template struct format_descriptor { }; +template<> struct format_descriptor { static std::string value() { return "b"; }; }; +template<> struct format_descriptor { static std::string value() { return "B"; }; }; +template<> struct format_descriptor { static std::string value() { return "h"; }; }; +template<> struct format_descriptor { static std::string value() { return "H"; }; }; +template<> struct format_descriptor { static std::string value() { return "i"; }; }; +template<> struct format_descriptor { static std::string value() { return "I"; }; }; +template<> struct format_descriptor { static std::string value() { return "q"; }; }; +template<> struct format_descriptor { static std::string value() { return "Q"; }; }; +template<> struct format_descriptor { static std::string value() { return "f"; }; }; +template<> struct format_descriptor { static std::string value() { return "d"; }; }; + +/// Information record describing a Python buffer object +struct buffer_info { + void *ptr; + size_t itemsize; + std::string format; // for dense contents, this should be set to format_descriptor::value + int ndim; + std::vector shape; + std::vector strides; + + buffer_info(void *ptr, size_t itemsize, const std::string &format, + int ndim, const std::vector &shape, + const std::vector &strides) + : ptr(ptr), itemsize(itemsize), format(format), ndim(ndim), + shape(shape), strides(strides) {} +}; + +// C++ bindings of core Python exceptions +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::exception { public: error_already_set() {} }; +/// Thrown when pybind::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_BEGIN(detail) + +/// PyObject wrapper around generic types +template > struct instance { + PyObject_HEAD + type *value; + PyObject *parent; + bool owned : 1; + bool constructed : 1; + holder_type holder; +}; + +/// Additional type information which does not fit into the PyTypeObjet +struct type_info { + PyTypeObject *type; + size_t type_size; + void (*init_holder)(PyObject *); + std::function get_buffer; + std::vector implicit_conversions; +}; + +/// Internal data struture used to track registered instances and types +struct internals { + std::unordered_map registered_types; + std::unordered_map registered_instances; +}; + +inline internals &get_internals(); + +NAMESPACE_END(detail) +NAMESPACE_END(pybind) + +#endif /* __PYBIND_COMMON_H */ diff --git a/include/pybind/mpl.h b/include/pybind/mpl.h new file mode 100644 index 000000000..ff9c6ebfc --- /dev/null +++ b/include/pybind/mpl.h @@ -0,0 +1,190 @@ +/* + pybind/mpl.h: Simple library for type manipulation and template metaprogramming + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_MPL_H) +#define __PYBIND_MPL_H + +#include "common.h" +#include + +NAMESPACE_BEGIN(pybind) +NAMESPACE_BEGIN(mpl) + +/// Index sequence for convenient template metaprogramming involving tuples +template struct index_sequence { }; +template struct make_index_sequence : make_index_sequence { }; +template struct make_index_sequence <0, S...> { typedef index_sequence type; }; + +/// Helper template to strip away type modifiers +template struct normalize_type { typedef T type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; +template struct normalize_type { typedef typename normalize_type::type type; }; + +NAMESPACE_BEGIN(detail) + +/// Strip the class from a method type +template struct remove_class {}; +template struct remove_class { typedef R type(A...); }; +template struct remove_class { typedef R type(A...); }; + +/** + * \brief Convert a lambda function to a std::function + * From http://stackoverflow.com/questions/11893141/inferring-the-call-signature-of-a-lambda-or-arbitrary-callable-for-make-functio + */ +template struct lambda_signature_impl { + using type = typename remove_class< + decltype(&std::remove_reference::type::operator())>::type; +}; +template struct lambda_signature_impl { typedef R type(A...); }; +template struct lambda_signature_impl { typedef R type(A...); }; +template struct lambda_signature_impl { typedef R type(A...); }; +template using lambda_signature = typename lambda_signature_impl::type; +template using make_function_type = std::function>; + +NAMESPACE_END(detail) + +template detail::make_function_type make_function(F &&f) { + return detail::make_function_type(std::forward(f)); } + +NAMESPACE_BEGIN(detail) + +struct void_type { }; + +/// Helper functions for calling a function using a tuple argument while dealing with void/non-void return values +template struct tuple_dispatch { + typedef RetType return_type; + template return_type operator()(const Func &f, Arg && args, index_sequence) { + return f(std::get(std::forward(args))...); + } +}; + +/// Helper functions for calling a function using a tuple argument (special case for void return values) +template <> struct tuple_dispatch { + typedef void_type return_type; + template return_type operator()(const Func &f, Arg &&args, index_sequence) { + f(std::get(std::forward(args))...); + return return_type(); + } +}; + +NAMESPACE_END(detail) + +/// For lambda functions delegate to their 'operator()' +template struct function_traits : public function_traits> { }; + +/// Type traits for function pointers +template +struct function_traits { + enum { + nargs = sizeof...(Args), + is_method = 0, + is_const = 0 + }; + typedef std::function f_type; + typedef detail::tuple_dispatch dispatch_type; + typedef typename dispatch_type::return_type return_type; + typedef std::tuple args_type; + + template struct arg { + typedef typename std::tuple_element::type type; + }; + + static f_type cast(ReturnType (*func)(Args ...)) { return func; } + + static return_type dispatch(const f_type &f, args_type &&args) { + return dispatch_type()(f, std::move(args), + typename make_index_sequence::type()); + } +}; + +/// Type traits for ordinary methods +template +struct function_traits { + enum { + nargs = sizeof...(Args), + is_method = 1, + is_const = 0 + }; + typedef std::function f_type; + typedef detail::tuple_dispatch dispatch_type; + typedef typename dispatch_type::return_type return_type; + typedef std::tuple args_type; + + template struct arg { + typedef typename std::tuple_element::type type; + }; + + static f_type cast(ReturnType (ClassType::*func)(Args ...)) { return std::mem_fn(func); } + + static return_type dispatch(const f_type &f, args_type &&args) { + return dispatch_type()(f, std::move(args), + typename make_index_sequence::type()); + } +}; + +/// Type traits for const methods +template +struct function_traits { + enum { + nargs = sizeof...(Args), + is_method = 1, + is_const = 1 + }; + typedef std::function f_type; + typedef detail::tuple_dispatch dispatch_type; + typedef typename dispatch_type::return_type return_type; + typedef std::tuple args_type; + + template struct arg { + typedef typename std::tuple_element::type type; + }; + + static f_type cast(ReturnType (ClassType::*func)(Args ...) const) { + return std::mem_fn(func); + } + + static return_type dispatch(const f_type &f, args_type &&args) { + return dispatch_type()(f, std::move(args), + typename make_index_sequence::type()); + } +}; + +/// Type traits for std::functions +template +struct function_traits> { + enum { + nargs = sizeof...(Args), + is_method = 0, + is_const = 0 + }; + typedef std::function f_type; + typedef detail::tuple_dispatch dispatch_type; + typedef typename dispatch_type::return_type return_type; + typedef std::tuple args_type; + + template struct arg { + typedef typename std::tuple_element::type type; + }; + + static f_type cast(const f_type &func) { return func; } + + static return_type dispatch(const f_type &f, args_type &&args) { + return dispatch_type()(f, std::move(args), + typename make_index_sequence::type()); + } +}; + +NAMESPACE_END(mpl) +NAMESPACE_END(pybind) + +#endif /* __PYBIND_MPL_H */ diff --git a/include/pybind/operators.h b/include/pybind/operators.h new file mode 100644 index 000000000..08fcd991a --- /dev/null +++ b/include/pybind/operators.h @@ -0,0 +1,151 @@ +/* + pybind/operator.h: Metatemplates for operator overloading + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_OPERATOR) +#define __PYBIND_OPERATOR + +#include "pybind.h" +#include + +NAMESPACE_BEGIN(pybind) +NAMESPACE_BEGIN(detail) + +/// Enumeration with all supported operator types +enum op_id : int { + op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow, + op_lshift, op_rshift, op_and, op_xor, op_or, op_neg, + op_pos, op_abs, op_invert, op_int, op_long, op_float, + op_str, op_cmp, op_gt, op_ge, op_lt, op_le, op_eq, op_ne, + op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift, + op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool, + op_nonzero, op_repr, op_truediv +}; + +enum op_type : int { + op_l, /* base type on left */ + op_r, /* base type on right */ + op_u /* unary operator */ +}; + +struct self_t { }; + +/// Type for an unused type slot +struct undefined_t { }; + +static const self_t self = self_t(); + +/// Don't warn about an unused variable +inline self_t __self() { return self; } + +/// base template of operator implementations +template struct op_impl { }; + +/// Operator implementation generator +template struct op_ { + template void execute(pybind::class_ &class_, const char *doc, return_value_policy policy) const { + typedef typename std::conditional::value, base, L>::type L_type; + typedef typename std::conditional::value, base, R>::type R_type; + typedef op_impl op; + class_.def(op::name(), &op::execute, doc, policy); + } + template void execute_cast(pybind::class_ &class_, const char *doc, return_value_policy policy) const { + typedef typename std::conditional::value, base, L>::type L_type; + typedef typename std::conditional::value, base, R>::type R_type; + typedef op_impl op; + class_.def(op::name(), &op::execute_cast, doc, policy); + } +}; + +#define PYBIND_BINARY_OPERATOR(id, rid, op, expr) \ +template struct op_impl { \ + static char const* name() { return "__" #id "__"; } \ + static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \ + static B execute_cast(const L &l, const R &r) { return B(expr); } \ +}; \ +template struct op_impl { \ + static char const* name() { return "__" #rid "__"; } \ + static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \ + static B execute_cast(const L &l, const R &r) { return B(expr); } \ +}; \ +inline op_ op(const self_t &, const self_t &) { \ + return op_(); \ +}; \ +template op_ op(const self_t &, const T &) { \ + return op_(); \ +}; \ +template op_ op(const T &, const self_t &) { \ + return op_(); \ +}; + +#define PYBIND_INPLACE_OPERATOR(id, op, expr) \ +template struct op_impl { \ + static char const* name() { return "__" #id "__"; } \ + static auto execute(L &l, const R &r) -> decltype(expr) { return expr; } \ + static B execute_cast(L &l, const R &r) { return B(expr); } \ +}; \ +template op_ op(const self_t &, const T &) { \ + return op_(); \ +}; + +#define PYBIND_UNARY_OPERATOR(id, op, expr) \ +template struct op_impl { \ + static char const* name() { return "__" #id "__"; } \ + static auto execute(const L &l) -> decltype(expr) { return expr; } \ + static B execute_cast(const L &l) { return B(expr); } \ +}; \ +inline op_ op(const self_t &) { \ + return op_(); \ +}; + +PYBIND_BINARY_OPERATOR(sub, rsub, operator-, l - r) +PYBIND_BINARY_OPERATOR(add, radd, operator+, l + r) +PYBIND_BINARY_OPERATOR(mul, rmul, operator*, l * r) +PYBIND_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r) +PYBIND_BINARY_OPERATOR(mod, rmod, operator%, l % r) +PYBIND_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r) +PYBIND_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r) +PYBIND_BINARY_OPERATOR(and, rand, operator&, l & r) +PYBIND_BINARY_OPERATOR(xor, rxor, operator^, l ^ r) +PYBIND_BINARY_OPERATOR(eq, eq, operator==, l == r) +PYBIND_BINARY_OPERATOR(ne, ne, operator!=, l != r) +PYBIND_BINARY_OPERATOR(or, ror, operator|, l | r) +PYBIND_BINARY_OPERATOR(gt, lt, operator>, l > r) +PYBIND_BINARY_OPERATOR(ge, le, operator>=, l >= r) +PYBIND_BINARY_OPERATOR(lt, gt, operator<, l < r) +PYBIND_BINARY_OPERATOR(le, ge, operator<=, l <= r) +//PYBIND_BINARY_OPERATOR(pow, rpow, pow, std::pow(l, r)) +PYBIND_INPLACE_OPERATOR(iadd, operator+=, l += r) +PYBIND_INPLACE_OPERATOR(isub, operator-=, l -= r) +PYBIND_INPLACE_OPERATOR(imul, operator*=, l *= r) +PYBIND_INPLACE_OPERATOR(idiv, operator/=, l /= r) +PYBIND_INPLACE_OPERATOR(imod, operator%=, l %= r) +PYBIND_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r) +PYBIND_INPLACE_OPERATOR(irshift, operator>>=, l >>= r) +PYBIND_INPLACE_OPERATOR(iand, operator&=, l &= r) +PYBIND_INPLACE_OPERATOR(ixor, operator^=, l ^= r) +PYBIND_INPLACE_OPERATOR(ior, operator|=, l |= r) +PYBIND_UNARY_OPERATOR(neg, operator-, -l) +PYBIND_UNARY_OPERATOR(pos, operator+, +l) +PYBIND_UNARY_OPERATOR(abs, abs, std::abs(l)) +PYBIND_UNARY_OPERATOR(invert, operator~, ~l) +PYBIND_UNARY_OPERATOR(bool, operator!, !!l) +PYBIND_UNARY_OPERATOR(int, int_, (int) l) +PYBIND_UNARY_OPERATOR(float, float_, (double) l) + +#undef PYBIND_BINARY_OPERATOR +#undef PYBIND_INPLACE_OPERATOR +#undef PYBIND_UNARY_OPERATOR + +NAMESPACE_END(detail) + +using detail::self; + +NAMESPACE_END(pybind) + +#endif /* __PYBIND_OPERATOR */ diff --git a/include/pybind/pybind.h b/include/pybind/pybind.h new file mode 100644 index 000000000..ad92a8240 --- /dev/null +++ b/include/pybind/pybind.h @@ -0,0 +1,587 @@ +/* + pybind/pybind.h: Main header file of the C++11 python binding generator library + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_H) +#define __PYBIND_H + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +#pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning) +#pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name +#pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter +#pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted +#endif + +#include "cast.h" + +NAMESPACE_BEGIN(pybind) + +class function : public object { +private: + struct function_entry { + std::function impl; + std::string signature, doc; + bool is_constructor; + function_entry *next = nullptr; + }; +public: + PYTHON_OBJECT_DEFAULT(function, object, PyFunction_Check) + + template + function(const char *name, Func _func, bool is_method, + function overload_sibling = function(), const char *doc = nullptr, + return_value_policy policy = return_value_policy::automatic) { + /* Function traits extracted from the template type 'Func' */ + typedef mpl::function_traits f_traits; + + /* Suitable input and output casters */ + typedef typename detail::type_caster cast_in; + typedef typename detail::type_caster::type> cast_out; + typename f_traits::f_type func = f_traits::cast(_func); + + auto impl = [func, policy](PyObject *pyArgs) -> PyObject *{ + cast_in args; + if (!args.load(pyArgs, true)) + return nullptr; + PyObject *parent = policy != return_value_policy::reference_internal + ? nullptr : PyTuple_GetItem(pyArgs, 0); + return cast_out::cast( + f_traits::dispatch(func, (typename f_traits::args_type) args), + policy, parent); + }; + + /* Linked list of function call handlers (for overloading) */ + function_entry *entry = new function_entry(); + entry->impl = impl; + entry->signature = std::string(name) + cast_in::name() + std::string(" -> ") + cast_out::name(); + entry->is_constructor = !strcmp(name, "__init__"); + if (doc) entry->doc = doc; + + install_function(name, entry, is_method, overload_sibling); + } + +private: + static PyObject *dispatcher(PyObject *self, PyObject *args, PyObject * /* kwargs */) { + function_entry *overloads = (function_entry *) PyCapsule_GetPointer(self, nullptr); + PyObject *result = nullptr; + try { + for (function_entry *it = overloads; it != nullptr; it = it->next) { + if ((result = it->impl(args)) != nullptr) + break; + } + } catch (const error_already_set &) { return nullptr; + } catch (const index_error &e) { PyErr_SetString(PyExc_IndexError, e.what()); return nullptr; + } catch (const stop_iteration &e) { PyErr_SetString(PyExc_StopIteration, e.what()); return nullptr; + } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return nullptr; + } catch (...) { + PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!"); + return nullptr; + } + if (result) { + if (overloads->is_constructor) { + PyObject *inst = PyTuple_GetItem(args, 0); + const detail::type_info *type_info = + capsule(PyObject_GetAttrString((PyObject *) Py_TYPE(inst), + const_cast("__pybind__")), false); + type_info->init_holder(inst); + } + return result; + } else { + std::string signatures = "Incompatible function arguments. The " + "following argument types are supported:\n"; + int ctr = 0; + for (function_entry *it = overloads; it != nullptr; it = it->next) { + signatures += " "+ std::to_string(++ctr) + ". "; + signatures += it->signature; + signatures += "\n"; + } + PyErr_SetString(PyExc_TypeError, signatures.c_str()); + return nullptr; + } + } + + void install_function(const char *name, function_entry *entry, bool is_method, function overload_sibling) { + if (!overload_sibling.ptr() || !PyCFunction_Check(overload_sibling.ptr())) { + PyMethodDef *def = new PyMethodDef(); + memset(def, 0, sizeof(PyMethodDef)); + def->ml_name = strdup(name); + def->ml_meth = reinterpret_cast(*dispatcher); + def->ml_flags = METH_VARARGS | METH_KEYWORDS; + capsule entry_capsule(entry); + m_ptr = PyCFunction_New(def, entry_capsule.ptr()); + if (!m_ptr) + throw std::runtime_error("function::function(): Could not allocate function object"); + } else { + m_ptr = overload_sibling.ptr(); + inc_ref(); + capsule entry_capsule(PyCFunction_GetSelf(m_ptr), true); + function_entry *parent = (function_entry *) entry_capsule, *backup = parent; + while (parent->next) + parent = parent->next; + parent->next = entry; + entry = backup; + } + std::string signatures; + while (entry) { /* Create pydoc entry */ + signatures += "Signature : " + std::string(entry->signature) + "\n"; + if (!entry->doc.empty()) + signatures += "\n" + std::string(entry->doc) + "\n"; + if (entry->next) + signatures += "\n"; + entry = entry->next; + } + PyCFunctionObject *func = (PyCFunctionObject *) m_ptr; + if (func->m_ml->ml_doc) + std::free((char *) func->m_ml->ml_doc); + func->m_ml->ml_doc = strdup(signatures.c_str()); + if (is_method) { + m_ptr = PyInstanceMethod_New(m_ptr); + if (!m_ptr) + throw std::runtime_error("function::function(): Could not allocate instance method object"); + Py_DECREF(func); + } + } +}; + +class module : public object { +public: + PYTHON_OBJECT_DEFAULT(module, object, PyModule_Check) + + module(const char *name, const char *doc = nullptr) { + PyModuleDef *def = new PyModuleDef(); + memset(def, 0, sizeof(PyModuleDef)); + def->m_name = name; + def->m_doc = doc; + def->m_size = -1; + Py_INCREF(def); + m_ptr = PyModule_Create(def); + if (m_ptr == nullptr) + throw std::runtime_error("Internal error in module::module()"); + inc_ref(); + } + + template module& def(const char *name, Func f, const char *doc = nullptr) { + function func(name, f, false, (function) attr(name), doc); + func.inc_ref(); /* The following line steals a reference to 'func' */ + PyModule_AddObject(ptr(), name, func.ptr()); + return *this; + } + + module def_submodule(const char *name) { + std::string full_name = std::string(PyModule_GetName(m_ptr)) + + std::string(".") + std::string(name); + module result(PyImport_AddModule(full_name.c_str()), true); + attr(name) = result; + return result; + } +}; + +NAMESPACE_BEGIN(detail) +/* Forward declarations */ +enum op_id : int; +enum op_type : int; +struct undefined_t; +template struct op_; +template struct init; + +/// Basic support for creating new Python heap types +class custom_type : public object { +public: + PYTHON_OBJECT_DEFAULT(custom_type, object, PyType_Check) + + custom_type(object &scope, const char *name_, const std::string &type_name, + size_t type_size, size_t instance_size, + void (*init_holder)(PyObject *), const destructor &dealloc, + PyObject *parent, const char *doc) { + PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0); + PyObject *name = PyUnicode_FromString(name_); + if (type == nullptr || name == nullptr) + throw std::runtime_error("Internal error in custom_type::custom_type()"); + Py_INCREF(name); + std::string full_name(name_); + + pybind::str scope_name = (object) scope.attr("__name__"), + module_name = (object) scope.attr("__module__"); + + if (scope_name.check()) + full_name = std::string(scope_name) + "." + full_name; + if (module_name.check()) + full_name = std::string(module_name) + "." + full_name; + + type->ht_name = type->ht_qualname = name; + type->ht_type.tp_name = strdup(full_name.c_str()); + type->ht_type.tp_basicsize = instance_size; + type->ht_type.tp_doc = doc; + type->ht_type.tp_init = (initproc) init; + type->ht_type.tp_new = (newfunc) new_instance; + type->ht_type.tp_dealloc = dealloc; + type->ht_type.tp_flags |= + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; + type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC; + type->ht_type.tp_as_number = &type->as_number; + type->ht_type.tp_as_sequence = &type->as_sequence; + type->ht_type.tp_as_mapping = &type->as_mapping; + type->ht_type.tp_base = (PyTypeObject *) parent; + Py_XINCREF(parent); + + if (PyType_Ready(&type->ht_type) < 0) + throw std::runtime_error("Internal error in custom_type::custom_type()"); + m_ptr = (PyObject *) type; + + /* Needed by pydoc */ + if (((module &) scope).check()) + attr("__module__") = scope_name; + + auto &type_info = detail::get_internals().registered_types[type_name]; + type_info.type = (PyTypeObject *) m_ptr; + type_info.type_size = type_size; + type_info.init_holder = init_holder; + attr("__pybind__") = capsule(&type_info); + + scope.attr(name) = *this; + } + +protected: + /* Allocate a metaclass on demand (for static properties) */ + handle metaclass() { + auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type; + auto &ob_type = ht_type.ob_base.ob_base.ob_type; + if (ob_type == &PyType_Type) { + std::string name_ = std::string(ht_type.tp_name) + "_meta"; + PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0); + PyObject *name = PyUnicode_FromString(name_.c_str()); + if (type == nullptr || name == nullptr) + throw std::runtime_error("Internal error in custom_type::metaclass()"); + Py_INCREF(name); + type->ht_name = type->ht_qualname = name; + type->ht_type.tp_name = strdup(name_.c_str()); + type->ht_type.tp_base = &PyType_Type; + type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE; + type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC; + if (PyType_Ready(&type->ht_type) < 0) + throw std::runtime_error("Internal error in custom_type::metaclass()"); + ob_type = (PyTypeObject *) type; + Py_INCREF(type); + } + return handle((PyObject *) ob_type); + } + + static int init(void *self, PyObject *, PyObject *) { + std::string msg = std::string(Py_TYPE(self)->tp_name) + ": No constructor defined!"; + PyErr_SetString(PyExc_TypeError, msg.c_str()); + return -1; + } + + static PyObject *new_instance(PyTypeObject *type, PyObject *, PyObject *) { + const detail::type_info *type_info = capsule( + PyObject_GetAttrString((PyObject *) type, const_cast("__pybind__")), false); + instance *self = (instance *) PyType_GenericAlloc(type, 0); + self->value = ::operator new(type_info->type_size); + self->owned = true; + self->parent = nullptr; + self->constructed = false; + detail::get_internals().registered_instances[self->value] = (PyObject *) self; + return (PyObject *) self; + } + + static void dealloc(instance *self) { + if (self->value) { + bool dont_cache = self->parent && ((instance *) self->parent)->value == self->value; + if (!dont_cache) { // avoid an issue with internal references matching their parent's address + auto ®istered_instances = detail::get_internals().registered_instances; + auto it = registered_instances.find(self->value); + if (it == registered_instances.end()) + throw std::runtime_error("Deallocating unregistered instance!"); + registered_instances.erase(it); + } + Py_XDECREF(self->parent); + } + Py_TYPE(self)->tp_free((PyObject*) self); + } + + void install_buffer_funcs(const std::function &func) { + PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr; + type->ht_type.tp_as_buffer = &type->as_buffer; + type->as_buffer.bf_getbuffer = getbuffer; + type->as_buffer.bf_releasebuffer = releasebuffer; + ((detail::type_info *) capsule(attr("__pybind__")))->get_buffer = func; + } + + static int getbuffer(PyObject *obj, Py_buffer *view, int flags) { + auto const &info_func = ((detail::type_info *) capsule(handle(obj).attr("__pybind__")))->get_buffer; + if (view == nullptr || obj == nullptr || !info_func) { + PyErr_SetString(PyExc_BufferError, "Internal error"); + return -1; + } + memset(view, 0, sizeof(Py_buffer)); + buffer_info *info = info_func(obj); + view->obj = obj; + view->ndim = 1; + view->internal = info; + view->buf = info->ptr; + view->itemsize = info->itemsize; + view->len = view->itemsize; + for (auto s : info->shape) + view->len *= s; + if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) + view->format = const_cast(info->format.c_str()); + if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { + view->ndim = info->ndim; + view->strides = (Py_ssize_t *)&info->strides[0]; + view->shape = (Py_ssize_t *) &info->shape[0]; + } + Py_INCREF(view->obj); + return 0; + } + + static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; } +}; + +NAMESPACE_END(detail) + +template > class class_ : public detail::custom_type { +public: + typedef detail::instance instance_type; + + PYTHON_OBJECT(class_, detail::custom_type, PyType_Check) + + class_(object &scope, const char *name, const char *doc = nullptr) + : detail::custom_type(scope, name, type_id(), sizeof(type), + sizeof(instance_type), init_holder, dealloc, + nullptr, doc) { } + + class_(object &scope, const char *name, object &parent, + const char *doc = nullptr) + : detail::custom_type(scope, name, type_id(), sizeof(type), + sizeof(instance_type), init_holder, dealloc, + parent.ptr(), doc) { } + + template + class_ &def(const char *name, Func f, const char *doc = nullptr, + return_value_policy policy = return_value_policy::automatic) { + attr(name) = function(name, f, true, (function) attr(name), doc, policy); + return *this; + } + + template class_ & + def_static(const char *name, Func f, const char *doc = nullptr, + return_value_policy policy = return_value_policy::automatic) { + attr(name) = function(name, f, false, (function) attr(name), doc, policy); + return *this; + } + + template + class_ &def(const detail::op_ &op, const char *doc = nullptr, + return_value_policy policy = return_value_policy::automatic) { + op.template execute(*this, doc, policy); + return *this; + } + + template class_ & + def_cast(const detail::op_ &op, const char *doc = nullptr, + return_value_policy policy = return_value_policy::automatic) { + op.template execute_cast(*this, doc, policy); + return *this; + } + + template + class_ &def(const detail::init &init, const char *doc = nullptr) { + init.template execute(*this, doc); + return *this; + } + + class_& def_buffer(const std::function &func) { + install_buffer_funcs([func](PyObject *obj) -> buffer_info* { + detail::type_caster caster; + if (!caster.load(obj, false)) + return nullptr; + return new buffer_info(func(caster)); + }); + return *this; + } + + template + class_ &def_readwrite(const char *name, D C::*pm, + const char *doc = nullptr) { + function fget("", [=](C * ptr) -> D & { return ptr->*pm; }, true, + function(), doc, return_value_policy::reference_internal), + fset("", [=](C *ptr, const D &value) { ptr->*pm = value; }, true, function(), doc); + def_property(name, fget, fset, doc); + return *this; + } + + template + class_ &def_readonly(const char *name, const D C::*pm, + const char *doc = nullptr) { + function fget("", [=](C * ptr) -> const D & { return ptr->*pm; }, true, + function(), doc, return_value_policy::reference_internal); + def_property(name, fget, doc); + return *this; + } + + template + class_ &def_readwrite_static(const char *name, D *pm, + const char *doc = nullptr) { + function fget("", [=](object) -> D & { return *pm; }, true), + fset("", [=](object, const D &value) { *pm = value; }, true); + def_property_static(name, fget, fset, doc); + return *this; + } + + template + class_ &def_readonly_static(const char *name, const D *pm, + const char *doc = nullptr) { + function fget("", [=](object) -> const D & { return *pm; }, true); + def_property_static(name, fget, doc); + return *this; + } + + class_ &def_property(const char *name, const function &fget, + const char *doc = nullptr) { + def_property(name, fget, function(), doc); + return *this; + } + + class_ &def_property_static(const char *name, const function &fget, + const char *doc = nullptr) { + def_property_static(name, fget, function(), doc); + return *this; + } + + class_ &def_property(const char *name, const function &fget, + const function &fset, const char *doc = nullptr) { + object property( + PyObject_CallFunction((PyObject *)&PyProperty_Type, + const_cast("OOOs"), fget.ptr() ? fget.ptr() : Py_None, + fset.ptr() ? fset.ptr() : Py_None, Py_None, doc), false); + attr(name) = property; + return *this; + } + + class_ &def_property_static(const char *name, const function &fget, + const function &fset, + const char *doc = nullptr) { + object property( + PyObject_CallFunction((PyObject *)&PyProperty_Type, + const_cast("OOOs"), fget.ptr() ? fget.ptr() : Py_None, + fset.ptr() ? fset.ptr() : Py_None, Py_None, doc), false); + metaclass().attr(name) = property; + return *this; + } +private: + static void init_holder(PyObject *inst_) { + instance_type *inst = (instance_type *) inst_; + new (&inst->holder) holder_type(inst->value); + inst->constructed = true; + } + static void dealloc(PyObject *inst_) { + instance_type *inst = (instance_type *) inst_; + if (inst->owned) { + if (inst->constructed) + inst->holder.~holder_type(); + else + ::operator delete(inst->value); + } + custom_type::dealloc((detail::instance *) inst); + } +}; + +/// Binds C++ enumerations and enumeration classes to Python +template class enum_ : public class_ { +public: + enum_(object &scope, const char *name, const char *doc = nullptr) + : class_(scope, name, doc), m_parent(scope) { + auto entries = new std::unordered_map(); + this->def("__str__", [name, entries](Type value) -> std::string { + auto it = entries->find(value); + return std::string(name) + "." + + ((it == entries->end()) ? std::string("???") + : std::string(it->second)); + }); + m_entries = entries; + } + + /// Export enumeration entries into the parent scope + void export_values() { + PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict; + PyObject *key, *value; + Py_ssize_t pos = 0; + while (PyDict_Next(dict, &pos, &key, &value)) + if (PyObject_IsInstance(value, this->m_ptr)) + m_parent.attr(key) = value; + } + + /// Add an enumeration entry + enum_& value(char const* name, Type value) { + this->attr(name) = pybind::cast(value, return_value_policy::copy); + (*m_entries)[(int) value] = name; + return *this; + } +private: + std::unordered_map *m_entries; + object &m_parent; +}; + +NAMESPACE_BEGIN(detail) +template struct init { + template void execute(pybind::class_ &class_, const char *doc) const { + /// Function which calls a specific C++ in-place constructor + class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, doc); + } +}; +NAMESPACE_END(detail) + +template detail::init init() { return detail::init(); }; + +template void implicitly_convertible() { + auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject *{ + if (!detail::type_caster().load(obj, false)) + return nullptr; + tuple args(1); + args[0] = obj; + PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr); + if (result == nullptr) + PyErr_Clear(); + return result; + }; + std::string output_type_name = type_id(); + auto & registered_types = detail::get_internals().registered_types; + auto it = registered_types.find(output_type_name); + if (it == registered_types.end()) + throw std::runtime_error("implicitly_convertible: Unable to find type " + output_type_name); + it->second.implicit_conversions.push_back(implicit_caster); +} + +inline void init_threading() { PyEval_InitThreads(); } + +class gil_scoped_acquire { + PyGILState_STATE state; +public: + inline gil_scoped_acquire() { state = PyGILState_Ensure(); } + inline ~gil_scoped_acquire() { PyGILState_Release(state); } +}; + +class gil_scoped_release { + PyThreadState *state; +public: + inline gil_scoped_release() { state = PyEval_SaveThread(); } + inline ~gil_scoped_release() { PyEval_RestoreThread(state); } +}; + +NAMESPACE_END(pybind) + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#undef PYTHON_OBJECT +#undef PYTHON_OBJECT_DEFAULT + +#endif /* __PYBIND_H */ diff --git a/include/pybind/pytypes.h b/include/pybind/pytypes.h new file mode 100644 index 000000000..3a7b1cd59 --- /dev/null +++ b/include/pybind/pytypes.h @@ -0,0 +1,339 @@ +/* + pybind/typeid.h: Convenience wrapper classes for basic Python types + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_PYTYPES_H) +#define __PYBIND_PYTYPES_H + +#include "common.h" +#include + +NAMESPACE_BEGIN(pybind) + +/* A few forward declarations */ +class object; +class str; +class object; +class dict; +NAMESPACE_BEGIN(detail) +class accessor; +NAMESPACE_END(detail) + +/// Holds a reference to a Python object (no reference counting) +class handle { +public: + handle() : m_ptr(nullptr) { } + handle(const handle &other) : m_ptr(other.m_ptr) { } + handle(PyObject *ptr) : m_ptr(ptr) { } + PyObject *ptr() { return m_ptr; } + const PyObject *ptr() const { return m_ptr; } + void inc_ref() const { Py_XINCREF(m_ptr); } + void dec_ref() const { Py_XDECREF(m_ptr); } + int ref_count() const { return (int) Py_REFCNT(m_ptr); } + inline detail::accessor operator[](handle key); + 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; + template T cast(); + template object call(Args&&... args_); + operator bool() const { return m_ptr != nullptr; } +protected: + PyObject *m_ptr; +}; + +/// Holds a reference to a Python object (with reference counting) +class object : public handle { +public: + object() { } + object(const object &o) : handle(o) { inc_ref(); } + object(const handle &h, bool borrowed) : handle(h) { if (borrowed) inc_ref(); } + object(PyObject *ptr, bool borrowed) : handle(ptr) { if (borrowed) inc_ref(); } + object(object &&other) { m_ptr = other.m_ptr; other.m_ptr = nullptr; } + ~object() { dec_ref(); } + + object& operator=(object &other) { + Py_XINCREF(other.m_ptr); + Py_XDECREF(m_ptr); + m_ptr = other.m_ptr; + return *this; + } + + object& operator=(object &&other) { + if (this != &other) { + PyObject *temp = m_ptr; + m_ptr = other.m_ptr; + other.m_ptr = nullptr; + Py_XDECREF(temp); + } + return *this; + } +}; + +NAMESPACE_BEGIN(detail) +class accessor { +public: + accessor(PyObject *obj, PyObject *key, bool attr) + : obj(obj), key(key), attr(attr) { Py_INCREF(key); } + accessor(PyObject *obj, const char *key, bool attr) + : obj(obj), key(PyUnicode_FromString(key)), attr(attr) { } + accessor(const accessor &a) : obj(a.obj), key(a.key), attr(a.attr) + { Py_INCREF(key); } + ~accessor() { Py_DECREF(key); } + + void operator=(accessor o) { operator=(object(o)); } + + void operator=(const handle &h) { + if (attr) { + if (PyObject_SetAttr(obj, key, (PyObject *) h.ptr()) < 0) + throw std::runtime_error("Unable to set object attribute"); + } else { + if (PyObject_SetItem(obj, key, (PyObject *) h.ptr()) < 0) + throw std::runtime_error("Unable to set object item"); + } + } + + operator object() const { + object result(attr ? PyObject_GetAttr(obj, key) + : PyObject_GetItem(obj, key), false); + if (!result) PyErr_Clear(); + return result; + } + + operator bool() const { + if (attr) { + return (bool) PyObject_HasAttr(obj, key); + } else { + object result(PyObject_GetItem(obj, key), false); + if (!result) PyErr_Clear(); + return (bool) result; + } + }; + +private: + PyObject *obj; + PyObject *key; + bool attr; +}; + +struct list_accessor { +public: + list_accessor(PyObject *list, size_t index) : list(list), index(index) { } + void operator=(list_accessor o) { return operator=(object(o)); } + void operator=(const handle &o) { + o.inc_ref(); // PyList_SetItem steals a reference + if (PyList_SetItem(list, (ssize_t) index, (PyObject *) o.ptr()) < 0) + throw std::runtime_error("Unable to assign value in Python list!"); + } + operator object() const { + PyObject *result = PyList_GetItem(list, (ssize_t) index); + if (!result) + throw std::runtime_error("Unable to retrieve value from Python list!"); + return object(result, true); + } +private: + PyObject *list; + size_t index; +}; + +struct tuple_accessor { +public: + tuple_accessor(PyObject *tuple, size_t index) : tuple(tuple), index(index) { } + void operator=(tuple_accessor o) { return operator=(object(o)); } + void operator=(const handle &o) { + o.inc_ref(); // PyTuple_SetItem steals a reference + if (PyTuple_SetItem(tuple, (ssize_t) index, (PyObject *) o.ptr()) < 0) + throw std::runtime_error("Unable to assign value in Python tuple!"); + } + operator object() const { + PyObject *result = PyTuple_GetItem(tuple, (ssize_t) index); + if (!result) + throw std::runtime_error("Unable to retrieve value from Python tuple!"); + return object(result, true); + } +private: + PyObject *tuple; + size_t index; +}; + +class list_iterator { +public: + list_iterator(PyObject *list, ssize_t pos) : list(list), pos(pos) { } + list_iterator& operator++() { ++pos; return *this; } + object operator*() { return object(PyList_GetItem(list, pos), true); } + bool operator==(const list_iterator &it) const { return it.pos == pos; } + bool operator!=(const list_iterator &it) const { return it.pos != pos; } +private: + PyObject *list; + ssize_t pos; +}; + +struct dict_iterator { +public: + dict_iterator(PyObject *dict = nullptr, ssize_t pos = -1) : dict(dict), pos(pos) { } + dict_iterator& operator++() { + if (!PyDict_Next(dict, &pos, &key, &value)) + pos = -1; + return *this; + } + std::pair operator*() { + return std::make_pair(object(key, true), object(value, true)); + } + bool operator==(const dict_iterator &it) const { return it.pos == pos; } + bool operator!=(const dict_iterator &it) const { return it.pos != pos; } +private: + PyObject *dict, *key, *value; + ssize_t pos = 0; +}; + +NAMESPACE_END(detail) + +inline detail::accessor handle::operator[](handle key) { return detail::accessor(ptr(), key.ptr(), false); } +inline detail::accessor handle::operator[](const char *key) { return detail::accessor(ptr(), key, false); } +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); } + +#define PYTHON_OBJECT(Name, Parent, CheckFun) \ + Name(const handle &h, bool borrowed) : Parent(h, borrowed) { } \ + Name(const object& o): Parent(o) { } \ + Name(object&& o): Parent(std::move(o)) { } \ + Name& operator=(object&& o) { return static_cast(object::operator=(std::move(o))); } \ + Name& operator=(object& o) { return static_cast(object::operator=(o)); } \ + bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } + +#define PYTHON_OBJECT_DEFAULT(Name, Parent, CheckFun) \ + PYTHON_OBJECT(Name, Parent, CheckFun) \ + Name() : object() { } + +class str : public object { +public: + PYTHON_OBJECT_DEFAULT(str, object, PyUnicode_Check) + str(const char *s) : object(PyUnicode_FromString(s), false) { } + operator const char *() const { return PyUnicode_AsUTF8(m_ptr); } +}; + +inline pybind::str handle::str() const { return pybind::str(PyObject_Str(m_ptr), false); } +inline std::ostream &operator<<(std::ostream &os, const object &obj) { os << (const char *) obj.str(); return os; } + +class bool_ : public object { +public: + PYTHON_OBJECT_DEFAULT(bool_, object, PyBool_Check) + operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; } +}; + +class int_ : public object { +public: + PYTHON_OBJECT_DEFAULT(int_, object, PyLong_Check) + int_(int value) : object(PyLong_FromLong((long) value), false) { } + int_(size_t value) : object(PyLong_FromSize_t(value), false) { } + int_(ssize_t value) : object(PyLong_FromSsize_t(value), false) { } + operator int() const { return (int) PyLong_AsLong(m_ptr); } +}; + +class float_ : public object { +public: + PYTHON_OBJECT_DEFAULT(float_, object, PyFloat_Check) + float_(float 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 double() const { return (double) PyFloat_AsDouble(m_ptr); } +}; + +class slice : public object { +public: + PYTHON_OBJECT_DEFAULT(slice, object, PySlice_Check) + slice(ssize_t start_, ssize_t stop_, ssize_t step_) { + int_ start(start_), stop(stop_), step(step_); + m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr()); + } + bool compute(ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, ssize_t *slicelength) const { + return PySlice_GetIndicesEx(m_ptr, length, start, stop, step, slicelength) == 0; + } +}; + +class capsule : public object { +public: + PYTHON_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact) + capsule(void *value) : object(PyCapsule_New(value, nullptr, nullptr), false) { } + template operator T *() const { + T * result = static_cast(PyCapsule_GetPointer(m_ptr, nullptr)); + if (!result) throw std::runtime_error("Unable to extract capsule contents!"); + return result; + } +}; + +class tuple : public object { +public: + PYTHON_OBJECT_DEFAULT(tuple, object, PyTuple_Check) + tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { } + size_t size() const { return (size_t) PyTuple_Size(m_ptr); } + detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); } +}; + +class dict : public object { +public: + PYTHON_OBJECT(dict, object, PyDict_Check) + dict() : object(PyDict_New(), false) { } + size_t size() const { return (size_t) PyDict_Size(m_ptr); } + detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); } + detail::dict_iterator end() { return detail::dict_iterator(); } +}; + +class list : public object { +public: + PYTHON_OBJECT(list, object, PyList_Check) + list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { } + size_t size() const { return (size_t) PyList_Size(m_ptr); } + detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); } + detail::list_iterator end() { return detail::list_iterator(ptr(), (ssize_t) size()); } + detail::list_accessor operator[](size_t index) { return detail::list_accessor(ptr(), index); } + void append(const object &object) { PyList_Append(m_ptr, (PyObject *) object.ptr()); } +}; + +class buffer : public object { +public: + PYTHON_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer) + + buffer_info request(bool writable = false) { + int flags = PyBUF_STRIDES | PyBUF_FORMAT; + if (writable) flags |= PyBUF_WRITABLE; + view = new Py_buffer(); + if (PyObject_GetBuffer(m_ptr, view, flags) != 0) + throw error_already_set(); + std::vector shape(view->ndim), strides(view->ndim); + for (int i=0; indim; ++i) { + shape[i] = (size_t) view->shape[i]; + strides[i] = (size_t) view->strides[i]; + } + return buffer_info(view->buf, view->itemsize, view->format, + view->ndim, shape, strides); + } + ~buffer() { if (view) { PyBuffer_Release(view); delete view; } } +private: + Py_buffer *view = nullptr; +}; + +NAMESPACE_BEGIN(detail) +inline internals &get_internals() { + static internals *internals_ptr = nullptr; + if (internals_ptr) + return *internals_ptr; + handle builtins(PyEval_GetBuiltins()); + capsule caps(builtins["__pybind__"]); + if (caps.check()) { + internals_ptr = caps; + } else { + internals_ptr = new internals(); + builtins["__pybind__"] = capsule(internals_ptr); + } + return *internals_ptr; +} +NAMESPACE_END(detail) +NAMESPACE_END(pybind) + +#endif /* __PYBIND_PYTYPES_H */ diff --git a/include/pybind/typeid.h b/include/pybind/typeid.h new file mode 100644 index 000000000..ee0b023b8 --- /dev/null +++ b/include/pybind/typeid.h @@ -0,0 +1,53 @@ +/* + pybind/typeid.h: Compiler-independent access to type identifiers + + Copyright (c) 2015 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#if !defined(__PYBIND_TYPEID_H) +#define __PYBIND_TYPEID_H + +#include "common.h" +#include +#include +#if defined(__GNUG__) +#include +#endif + +NAMESPACE_BEGIN(pybind) +NAMESPACE_BEGIN(detail) +/// Erase all occurrences of a substring +inline void erase_all(std::string &string, const std::string &search) { + for (size_t pos = 0;;) { + pos = string.find(search, pos); + if (pos == std::string::npos) break; + string.erase(pos, search.length()); + } +} +NAMESPACE_END(detail) + +/// Return a string representation of a C++ type +template static std::string type_id() { + std::string name(typeid(T).name()); + #if defined(__GNUG__) + int status = 0; + std::unique_ptr res { + abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free }; + if (status == 0) + name = res.get(); + #else + detail::erase_all(name, "class "); + detail::erase_all(name, "struct "); + detail::erase_all(name, "enum "); + #endif + detail::erase_all(name, "pybind::"); + return name; +} + +NAMESPACE_END(pybind) + +#endif /* __PYBIND_TYPEID_H */ +