PythonToOneDArray< T > Struct Template Reference

Public Member Functions
	PythonToOneDArray ()

Static Public Member Functions
static void *	convertible (PyObject *objPtr)
static void	decrement (void *objPtr)
static void	construct (PyObject *objPtr, py::converter::rvalue_from_python_stage1_data *data)

Detailed Description

template<typename T>
struct PythonToOneDArray< T >

Definition at line 82 of file SharedArray.cpp.

Constructor & Destructor Documentation

PythonToOneDArray()

template<typename T >

PythonToOneDArray< T >::PythonToOneDArray ( )

inline

Definition at line 84 of file SharedArray.cpp.

    {
        py::converter::registry::push_back(&convertible, &construct,
                                           py::type_id<Array<OneD, T>>());
    }

Member Function Documentation

construct()

template<typename T >

static void PythonToOneDArray< T >::construct ( PyObject *  objPtr, py::converter::rvalue_from_python_stage1_data *  data  )

inlinestatic

Definition at line 134 of file SharedArray.cpp.

    {
        // This has to be a _borrowed_ reference, otherwise at the end of this
        // scope it seems memory gets deallocated
        py::object obj((py::handle<>(py::borrowed(objPtr))));
        np::ndarray array = py::extract<np::ndarray>(obj);
 
        // If this array came from C++, extract the C++ array from PyCObject or
        // PyCapsule and ensure that we set up the C++ array to have a reference
        // to that object, so that it can be decremented as appropriate.
        py::object base     = array.get_base();
        Array<OneD, T> *ptr = nullptr;
 
#if PY_MAJOR_VERSION == 2
        if (PyCObject_Check(base.ptr()))
        {
            ptr = reinterpret_cast<Array<OneD, T> *>(
                PyCObject_AsVoidPtr(base.ptr()));
        }
#else
        if (PyCapsule_CheckExact(base.ptr()))
        {
            ptr = reinterpret_cast<Array<OneD, T> *>(
                PyCapsule_GetPointer(base.ptr(), 0));
        }
#endif
 
        void *storage =
            ((py::converter::rvalue_from_python_storage<Array<OneD, T>> *)data)
                ->storage.bytes;
        data->convertible = storage;
 
        // If array originated in C++, then we need to be careful to avoid
        // circular references. We therefore take a step to 'convert' this to a
        // Python array so that essentially the reference counting and memory
        // cleanup is done from the Python side.
        //
        // 1) Calling ToPythonArray to point to this numpy array. This ensures
        //    that any C++ arrays that share this memory also know to call the
        //    appropriate decrement function.
        // 2) Creating a new Array from ptr, since ptr will shortly be deleted.
        // 3) We call set_base to let the numpy array own its own data. This
        //    will, at the end of the function and after `base` goes out of
        //    scope, lead to ptr being deleted.
        //
        // After all of this references should be consistent between the C++
        // side and the Python side.
        if (ptr != nullptr)
        {
            ptr->ToPythonArray((void *)objPtr, &decrement);
            new (storage) Array<OneD, T>(*ptr);
            array.set_base(py::object());
        }
        else
        {
            // Otherwise, construct OneD array from numpy array
            using nonconst_t = typename std::remove_const<T>::type;
            new (storage)
                Array<OneD, T>(array.shape(0), (nonconst_t *)array.get_data(),
                               (void *)objPtr, &decrement);
        }
 
        py::incref(objPtr);
    }

convertible()

template<typename T >

static void* PythonToOneDArray< T >::convertible ( PyObject *  objPtr )

inlinestatic

Definition at line 89 of file SharedArray.cpp.

    {
        try
        {
            py::object obj((py::handle<>(py::borrowed(objPtr))));
            np::ndarray array = py::extract<np::ndarray>(obj);
 
            // Check data types match
            np::dtype dtype =
                np::dtype::get_builtin<typename boost::remove_const<T>::type>();
            if (dtype != array.get_dtype())
            {
                return 0;
            }
 
            // Check shape is 1D
            if (array.get_nd() != 1)
            {
                return 0;
            }
        }
        catch (boost::python::error_already_set &)
        {
            py::handle_exception();
            PyErr_Clear();
            return 0;
        }
 
        return objPtr;
    }

decrement()

template<typename T >

static void PythonToOneDArray< T >::decrement ( void *  objPtr )

inlinestatic

Definition at line 120 of file SharedArray.cpp.

    {
        if (!Py_IsInitialized())
        {
            // In deinitialisation phase, reference counters are not terribly
            // robust; decremementing counters here can lead to segfaults during
            // program exit in some cases.
            return;
        }
 
        // Otherwise decrement reference counter.
        py::decref((PyObject *)objPtr);
    }