PythonToOneDArray< T > Struct Template Reference

Converter for Python to Nektar::Array<OneD, T>. More...

#include <SharedArray.hpp>

Public Member Functions
	PythonToOneDArray ()
	Default constructor. More...

Static Public Member Functions
static void *	convertible (PyObject *objPtr)
	Determine whether the given objPtr is convertible to convertible to an Array type or not. More...
template<typename U = T, std::enable_if_t< std::is_arithmetic< U >::value > * = nullptr>
static bool	try_convertible (py::object &obj)
template<typename U = T, std::enable_if_t< is_shared_ptr< U >::value||is_nekarray_oned< U >::value > * = nullptr>
static bool	try_convertible (py::object &obj)
static void	decrement (void *objPtr)
static void	construct (PyObject *objPtr, py::converter::rvalue_from_python_stage1_data *data)
template<typename U = T, std::enable_if_t< std::is_arithmetic< U >::value > * = nullptr>
static void	construct_impl (PyObject *objPtr, py::converter::rvalue_from_python_stage1_data *data)
template<typename U = T, std::enable_if_t< is_shared_ptr< U >::value||is_nekarray_oned< U >::value > * = nullptr>
static void	construct_impl (PyObject *objPtr, py::converter::rvalue_from_python_stage1_data *data)

Detailed Description

template<typename T>
struct PythonToOneDArray< T >

Converter for Python to Nektar::Array<OneD, T>.

Definition at line 148 of file Python/BasicUtils/SharedArray.hpp.

Constructor & Destructor Documentation

PythonToOneDArray()

template<typename T >

PythonToOneDArray< T >::PythonToOneDArray ( )

inline

Default constructor.

Definition at line 151 of file Python/BasicUtils/SharedArray.hpp.

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

References PythonToOneDArray< T >::construct(), and PythonToOneDArray< T >::convertible().

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 246 of file Python/BasicUtils/SharedArray.hpp.

    {
        construct_impl(objPtr, data);
    }

References PythonToOneDArray< T >::construct_impl().

Referenced by PythonToOneDArray< T >::PythonToOneDArray().

construct_impl() [1/2]

template<typename T >

template<typename U = T, std::enable_if_t< std::is_arithmetic< U >::value > * = nullptr>

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

inlinestatic

Definition at line 254 of file Python/BasicUtils/SharedArray.hpp.

    {
        // 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(), nullptr));
        }
#endif
 
        void *storage =
            ((py::converter::rvalue_from_python_storage<Array<OneD, T>> *)data)
                ->storage.bytes;
        data->convertible = storage;
 
        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);
    }

References PythonToOneDArray< T >::decrement().

Referenced by PythonToOneDArray< T >::construct().

construct_impl() [2/2]

template<typename T >

template<typename U = T, std::enable_if_t< is_shared_ptr< U >::value||is_nekarray_oned< U >::value > * = nullptr>

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

inlinestatic

Definition at line 297 of file Python/BasicUtils/SharedArray.hpp.

    {
        using nonconst_t = typename std::remove_const<T>::type;
 
        py::object obj(py::handle<>(py::borrowed(objPtr)));
        py::list l = py::extract<py::list>(obj);
 
        const std::size_t nItems = py::len(l);
 
        // Allocate some storage for the Array.
        void *storage =
            ((py::converter::rvalue_from_python_storage<Array<OneD, nonconst_t>>
                  *)data)
                ->storage.bytes;
        Array<OneD, nonconst_t> *tmp =
            new (storage) Array<OneD, nonconst_t>(nItems);
        data->convertible = storage;
 
        // Fill the Array.
        for (std::size_t i = 0; i < nItems; ++i)
        {
            (*tmp)[i] = py::extract<nonconst_t>(l[i]);
        }
    }

convertible()

template<typename T >

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

inlinestatic

Determine whether the given objPtr is convertible to convertible to an Array type or not.

This is a top-level function: different data types are handled separately in the ::try_convertible functions.

Definition at line 164 of file Python/BasicUtils/SharedArray.hpp.

    {
        try
        {
            py::object obj((py::handle<>(py::borrowed(objPtr))));
            return try_convertible(obj) ? objPtr : nullptr;
        }
        catch (boost::python::error_already_set &)
        {
            py::handle_exception();
            PyErr_Clear();
            return nullptr;
        }
    }

References PythonToOneDArray< T >::try_convertible().

Referenced by PythonToOneDArray< T >::PythonToOneDArray().

decrement()

template<typename T >

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

inlinestatic

Definition at line 232 of file Python/BasicUtils/SharedArray.hpp.

    {
        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);
    }

Referenced by PythonToOneDArray< T >::construct_impl().

try_convertible() [1/2]

template<typename T >

template<typename U = T, std::enable_if_t< std::is_arithmetic< U >::value > * = nullptr>

static bool PythonToOneDArray< T >::try_convertible ( py::object &  obj )

inlinestatic

Definition at line 181 of file Python/BasicUtils/SharedArray.hpp.

    {
        np::ndarray array = py::extract<np::ndarray>(obj);
 
        // Check data types match
        np::dtype dtype =
            np::dtype::get_builtin<typename std::remove_const<U>::type>();
        if (dtype != array.get_dtype())
        {
            return false;
        }
 
        // Check shape is 1D
        if (array.get_nd() != 1)
        {
            return false;
        }
 
        return true;
    }

Referenced by PythonToOneDArray< T >::convertible().

try_convertible() [2/2]

template<typename T >

template<typename U = T, std::enable_if_t< is_shared_ptr< U >::value||is_nekarray_oned< U >::value > * = nullptr>

static bool PythonToOneDArray< T >::try_convertible ( py::object &  obj )

inlinestatic

Definition at line 205 of file Python/BasicUtils/SharedArray.hpp.

    {
        py::extract<py::list> list_conv(obj);
 
        if (!list_conv.check())
        {
            return false;
        }
 
        py::list l               = list_conv();
        const std::size_t nItems = py::len(l);
 
        // We'll need to construct a temporary vector to hold each item in the
        // list.
        for (std::size_t i = 0; i < nItems; ++i)
        {
            py::extract<T> item_conv(l[i]);
 
            if (!py::extract<T>(l[i]).check())
            {
                return false;
            }
        }
 
        return true;
    }