Spaces:
Runtime error
Runtime error
/* | |
tests/test_buffers.cpp -- supporting Pythons' buffer protocol | |
Copyright (c) 2016 Wenzel Jakob <[email protected]> | |
All rights reserved. Use of this source code is governed by a | |
BSD-style license that can be found in the LICENSE file. | |
*/ | |
TEST_SUBMODULE(buffers, m) { | |
// test_from_python / test_to_python: | |
class Matrix { | |
public: | |
Matrix(ssize_t rows, ssize_t cols) : m_rows(rows), m_cols(cols) { | |
print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix"); | |
m_data = new float[(size_t) (rows*cols)]; | |
memset(m_data, 0, sizeof(float) * (size_t) (rows * cols)); | |
} | |
Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) { | |
print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix"); | |
m_data = new float[(size_t) (m_rows * m_cols)]; | |
memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols)); | |
} | |
Matrix(Matrix &&s) : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) { | |
print_move_created(this); | |
s.m_rows = 0; | |
s.m_cols = 0; | |
s.m_data = nullptr; | |
} | |
~Matrix() { | |
print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix"); | |
delete[] m_data; | |
} | |
Matrix &operator=(const Matrix &s) { | |
print_copy_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix"); | |
delete[] m_data; | |
m_rows = s.m_rows; | |
m_cols = s.m_cols; | |
m_data = new float[(size_t) (m_rows * m_cols)]; | |
memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols)); | |
return *this; | |
} | |
Matrix &operator=(Matrix &&s) { | |
print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix"); | |
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()(ssize_t i, ssize_t j) const { | |
return m_data[(size_t) (i*m_cols + j)]; | |
} | |
float &operator()(ssize_t i, ssize_t j) { | |
return m_data[(size_t) (i*m_cols + j)]; | |
} | |
float *data() { return m_data; } | |
ssize_t rows() const { return m_rows; } | |
ssize_t cols() const { return m_cols; } | |
private: | |
ssize_t m_rows; | |
ssize_t m_cols; | |
float *m_data; | |
}; | |
py::class_<Matrix>(m, "Matrix", py::buffer_protocol()) | |
.def(py::init<ssize_t, ssize_t>()) | |
/// Construct from a buffer | |
.def(py::init([](py::buffer const b) { | |
py::buffer_info info = b.request(); | |
if (info.format != py::format_descriptor<float>::format() || info.ndim != 2) | |
throw std::runtime_error("Incompatible buffer format!"); | |
auto v = new Matrix(info.shape[0], info.shape[1]); | |
memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols())); | |
return v; | |
})) | |
.def("rows", &Matrix::rows) | |
.def("cols", &Matrix::cols) | |
/// Bare bones interface | |
.def("__getitem__", [](const Matrix &m, std::pair<ssize_t, ssize_t> 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<ssize_t, ssize_t> 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 */ | |
{ m.rows(), m.cols() }, /* Buffer dimensions */ | |
{ sizeof(float) * size_t(m.cols()), /* Strides (in bytes) for each index */ | |
sizeof(float) } | |
); | |
}) | |
; | |
// test_inherited_protocol | |
class SquareMatrix : public Matrix { | |
public: | |
SquareMatrix(ssize_t n) : Matrix(n, n) { } | |
}; | |
// Derived classes inherit the buffer protocol and the buffer access function | |
py::class_<SquareMatrix, Matrix>(m, "SquareMatrix") | |
.def(py::init<ssize_t>()); | |
// test_pointer_to_member_fn | |
// Tests that passing a pointer to member to the base class works in | |
// the derived class. | |
struct Buffer { | |
int32_t value = 0; | |
py::buffer_info get_buffer_info() { | |
return py::buffer_info(&value, sizeof(value), | |
py::format_descriptor<int32_t>::format(), 1); | |
} | |
}; | |
py::class_<Buffer>(m, "Buffer", py::buffer_protocol()) | |
.def(py::init<>()) | |
.def_readwrite("value", &Buffer::value) | |
.def_buffer(&Buffer::get_buffer_info); | |
class ConstBuffer { | |
std::unique_ptr<int32_t> value; | |
public: | |
int32_t get_value() const { return *value; } | |
void set_value(int32_t v) { *value = v; } | |
py::buffer_info get_buffer_info() const { | |
return py::buffer_info(value.get(), sizeof(*value), | |
py::format_descriptor<int32_t>::format(), 1); | |
} | |
ConstBuffer() : value(new int32_t{0}) { }; | |
}; | |
py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol()) | |
.def(py::init<>()) | |
.def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value) | |
.def_buffer(&ConstBuffer::get_buffer_info); | |
struct DerivedBuffer : public Buffer { }; | |
py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol()) | |
.def(py::init<>()) | |
.def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value) | |
.def_buffer(&DerivedBuffer::get_buffer_info); | |
struct BufferReadOnly { | |
const uint8_t value = 0; | |
BufferReadOnly(uint8_t value): value(value) {} | |
py::buffer_info get_buffer_info() { | |
return py::buffer_info(&value, 1); | |
} | |
}; | |
py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol()) | |
.def(py::init<uint8_t>()) | |
.def_buffer(&BufferReadOnly::get_buffer_info); | |
struct BufferReadOnlySelect { | |
uint8_t value = 0; | |
bool readonly = false; | |
py::buffer_info get_buffer_info() { | |
return py::buffer_info(&value, 1, readonly); | |
} | |
}; | |
py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol()) | |
.def(py::init<>()) | |
.def_readwrite("value", &BufferReadOnlySelect::value) | |
.def_readwrite("readonly", &BufferReadOnlySelect::readonly) | |
.def_buffer(&BufferReadOnlySelect::get_buffer_info); | |
} | |