Skip to content

Make handle and related classes const correct. #52

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
wjakob merged 1 commit into from Jan 10, 2016
Merged

Make handle and related classes const correct. #52

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions docs/reference.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,52 +59,52 @@ Without reference counting

Creates a :class:`handle` from the given raw Python object pointer.

.. function:: PyObject * handle::ptr()
.. function:: PyObject * handle::ptr() const

Return the ``PyObject *`` underlying a :class:`handle`.

.. function:: void handle::inc_ref()
.. function:: void handle::inc_ref() const

Manually increase the reference count of the Python object. Usually, it is
preferable to use the :class:`object` class which derives from
:class:`handle` and calls this function automatically.

.. function:: void handle::dec_ref()
.. function:: void handle::dec_ref() const

Manually decrease the reference count of the Python object. Usually, it is
preferable to use the :class:`object` class which derives from
:class:`handle` and calls this function automatically.

.. function:: void handle::ref_count()
.. function:: void handle::ref_count() const

Return the object's current reference count

.. function:: handle handle::get_type()
.. function:: handle handle::get_type() const

Return a handle to the Python type object underlying the instance

.. function detail::accessor handle::operator[](handle key)
.. function detail::accessor handle::operator[](handle key) const

Return an internal functor to invoke the object's sequence protocol.
Casting the returned ``detail::accessor`` instance to a :class:`handle` or
:class:`object` subclass causes a corresponding call to ``__getitem__``.
Assigning a :class:`handle` or :class:`object` subclass causes a call to
``__setitem__``.

.. function detail::accessor handle::operator[](const char *key)
.. function detail::accessor handle::operator[](const char *key) const

See the above function (the only difference is that they key is provided as
a string literal).

.. function detail::accessor handle::attr(handle key)
.. function detail::accessor handle::attr(handle key) const

Return an internal functor to access the object's attributes.
Casting the returned ``detail::accessor`` instance to a :class:`handle` or
:class:`object` subclass causes a corresponding call to ``__getattr``.
Assigning a :class:`handle` or :class:`object` subclass causes a call to
``__setattr``.

.. function detail::accessor handle::attr(const char *key)
.. function detail::accessor handle::attr(const char *key) const

See the above function (the only difference is that they key is provided as
a string literal).
Expand All @@ -123,7 +123,7 @@ Without reference counting
Attempt to cast the Python object into the given C++ type. A
:class:`cast_error` will be throw upon failure.

.. function:: template <typename ... Args> object handle::call(Args&&... args)
.. function:: template <typename ... Args> object handle::call(Args&&... args) const

Assuming the Python object is a function or implements the ``__call__``
protocol, ``call()`` invokes the underlying function, passing an arbitrary
Expand Down Expand Up @@ -169,7 +169,7 @@ With reference counting

.. function:: object::~object()

Constructor, which automatically calls :func:`handle::dec_ref()`.
Destructor, which automatically calls :func:`handle::dec_ref()`.

Convenience classes for specific Python types
=============================================
Expand Down
2 changes: 1 addition & 1 deletion include/pybind11/cast.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -597,7 +597,7 @@ template <typename T> inline object cast(const T &value, return_value_policy pol
template <typename T> inline T handle::cast() const { return pybind11::cast<T>(m_ptr); }
template <> inline void handle::cast() const { return; }

template <typename... Args> inline object handle::call(Args&&... args_) {
template <typename... Args> inline object handle::call(Args&&... args_) const {
const size_t size = sizeof...(Args);
std::array<PyObject *, size> args{
{ detail::type_caster<typename detail::decay<Args>::type>::cast(
Expand Down
2 changes: 1 addition & 1 deletion include/pybind11/numpy.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -129,7 +129,7 @@ template <typename T> class array_t : public array {
PYBIND11_OBJECT_CVT(array_t, array, is_non_null, m_ptr = ensure(m_ptr));
array_t() : array() { }
static bool is_non_null(PyObject *ptr) { return ptr != nullptr; }
PyObject *ensure(PyObject *ptr) {
static PyObject *ensure(PyObject *ptr) {
if (ptr == nullptr)
return nullptr;
API &api = lookup_api();
Expand Down
52 changes: 25 additions & 27 deletions include/pybind11/pytypes.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,21 +29,20 @@ class handle {
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; }
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); }
handle get_type() { return (PyObject *) Py_TYPE(m_ptr); }
inline iterator begin();
inline iterator end();
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);
handle get_type() const { return (PyObject *) Py_TYPE(m_ptr); }
inline iterator begin() const;
inline iterator end() const;
inline detail::accessor operator[](handle key) const;
inline detail::accessor operator[](const char *key) const;
inline detail::accessor attr(handle key) const;
inline detail::accessor attr(const char *key) const;
inline pybind11::str str() const;
template <typename T> T cast() const;
template <typename ... Args> object call(Args&&... args_);
template <typename ... Args> object call(Args&&... args_) const;
operator bool() const { return m_ptr != nullptr; }
bool check() const { return m_ptr != nullptr; }
protected:
Expand Down Expand Up @@ -88,7 +87,6 @@ class iterator : public object {
}
bool operator==(const iterator &it) const { return *it == **this; }
bool operator!=(const iterator &it) const { return *it != **this; }
object operator*() { return value; }
const object &operator*() const { return value; }
bool check() const { return PyIter_Check(ptr()); }
private:
Expand Down Expand Up @@ -201,7 +199,7 @@ struct dict_iterator {
pos = -1;
return *this;
}
std::pair<object, object> operator*() {
std::pair<object, object> operator*() const {
return std::make_pair(object(key, true), object(value, true));
}
bool operator==(const dict_iterator &it) const { return it.pos == pos; }
Expand Down Expand Up @@ -237,12 +235,12 @@ inline bool PyLong_Check_(PyObject *o) {

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); }
inline iterator handle::begin() { return iterator(PyObject_GetIter(ptr())); }
inline iterator handle::end() { return iterator(nullptr); }
inline detail::accessor handle::operator[](handle key) const { return detail::accessor(ptr(), key.ptr(), false); }
inline detail::accessor handle::operator[](const char *key) const { return detail::accessor(ptr(), key, false); }
inline detail::accessor handle::attr(handle key) const { return detail::accessor(ptr(), key.ptr(), true); }
inline detail::accessor handle::attr(const char *key) const { return detail::accessor(ptr(), key, true); }
inline iterator handle::begin() const { return iterator(PyObject_GetIter(ptr())); }
inline iterator handle::end() const { return iterator(nullptr); }

#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, CvtStmt) \
Name(const handle &h, bool borrowed) : Parent(h, borrowed) { CvtStmt; } \
Expand Down Expand Up @@ -375,42 +373,42 @@ class tuple : public object {
PYBIND11_OBJECT(tuple, object, PyTuple_Check)
tuple(size_t size = 0) : 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); }
detail::tuple_accessor operator[](size_t index) const { return detail::tuple_accessor(ptr(), index); }
};

class dict : public object {
public:
PYBIND11_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(); }
void clear() { PyDict_Clear(ptr()); }
detail::dict_iterator begin() const { return (++detail::dict_iterator(ptr(), 0)); }
detail::dict_iterator end() const { return detail::dict_iterator(); }
void clear() const { PyDict_Clear(ptr()); }
};

class list : public object {
public:
PYBIND11_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_accessor operator[](size_t index) { return detail::list_accessor(ptr(), index); }
void append(const object &object) { PyList_Append(m_ptr, (PyObject *) object.ptr()); }
detail::list_accessor operator[](size_t index) const { return detail::list_accessor(ptr(), index); }
void append(const object &object) const { PyList_Append(m_ptr, (PyObject *) object.ptr()); }
};

class set : public object {
public:
PYBIND11_OBJECT(set, object, PySet_Check)
set() : object(PySet_New(nullptr), false) { }
size_t size() const { return (size_t) PySet_Size(m_ptr); }
void add(const object &object) { PySet_Add(m_ptr, (PyObject *) object.ptr()); }
void clear() { PySet_Clear(ptr()); }
void add(const object &object) const { PySet_Add(m_ptr, (PyObject *) object.ptr()); }
void clear() const { PySet_Clear(ptr()); }
};

class function : public object {
public:
PYBIND11_OBJECT_DEFAULT(function, object, PyFunction_Check)

bool is_cpp_function() {
bool is_cpp_function() const {
PyObject *ptr = detail::get_function(m_ptr);
return ptr != nullptr && PyCFunction_Check(ptr);
}
Expand Down