pybind11::detail::nekarray_caster< Type, T > Struct Template Reference

Convert for Array<OneD, T> to Python list of objects for numeric types, self-array types and shared_ptr types. More...

#include <SharedArray.hpp>

Public Member Functions
	PYBIND11_TYPE_CASTER (Type, const_name("Array<OneD, ")+handle_type_name< T >::name+const_name(">"))
bool	load (handle src, bool enable)
template<typename U = T, std::enable_if_t< std::is_arithmetic_v< U >, bool > = true>
bool	load_impl (handle src, bool)
template<typename U = T, std::enable_if_t< is_shared_ptr< typename std::remove_const< U >::type >::value||is_nekarray_oned< U >::value, bool > = true>
bool	load_impl (handle src, bool)

Static Public Member Functions
static handle	cast (Nektar::Array< Nektar::OneD, T > const &arr, return_value_policy policy, handle parent)
static void	decrement (void *objPtr)
template<typename U = T, std::enable_if_t< std::is_arithmetic_v< U >, bool > = true>
static handle	cast_impl (Nektar::Array< Nektar::OneD, T > const &arr, return_value_policy, handle)
template<typename U = T, std::enable_if_t< is_shared_ptr< typename std::remove_const< U >::type >::value||is_nekarray_oned< U >::value, bool > = true>
static handle	cast_impl (Nektar::Array< Nektar::OneD, U > const &arr, return_value_policy, handle)

Detailed Description

template<typename Type, typename T>
struct pybind11::detail::nekarray_caster< Type, T >

Convert for Array<OneD, T> to Python list of objects for numeric types, self-array types and shared_ptr types.

Template Parameters

Type	The overall type Array<OneD, T>
T	The data type T

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

Member Function Documentation

cast()

template<typename Type , typename T >

static handle pybind11::detail::nekarray_caster< Type, T >::cast ( Nektar::Array< Nektar::OneD, T > const &  arr, return_value_policy  policy, handle  parent  )

inlinestatic

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

    {
        return cast_impl(arr, policy, parent);
    }

References pybind11::detail::nekarray_caster< Type, T >::cast_impl().

cast_impl() [1/2]

template<typename Type , typename T >

template<typename U = T, std::enable_if_t< std::is_arithmetic_v< U >, bool > = true>

static handle pybind11::detail::nekarray_caster< Type, T >::cast_impl ( Nektar::Array< Nektar::OneD, T > const &  arr, return_value_policy  , handle    )

inlinestatic

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

    {
        // Create a Python capsule to hold a pointer that contains a lightweight
        // copy of arr. Uhat way we guarantee Python will still have access to
        // the memory allocated inside arr even if arr is deallocated in C++.
        capsule c(new Nektar::Array<Nektar::OneD, U>(arr), [](void *ptr) {
            Nektar::Array<Nektar::OneD, U> *tmp =
                (Nektar::Array<Nektar::OneD, U> *)ptr;
            delete tmp;
        });
 
        // Create the NumPy array, passing the capsule. When we go out of scope,
        // c's reference count will have been reduced by 1, but array increases
        // the reference count when it assigns the base to the array.
        array_t<U> array({arr.size()}, {}, arr.data(), c);
 
        // This causes the array to be released without decreasing its reference
        // count, otherwise the array would be deallocated immediately when this
        // function returns.
        return array.release();
    }

Referenced by pybind11::detail::nekarray_caster< Type, T >::cast().

cast_impl() [2/2]

template<typename Type , typename T >

template<typename U = T, std::enable_if_t< is_shared_ptr< typename std::remove_const< U >::type >::value||is_nekarray_oned< U >::value, bool > = true>

static handle pybind11::detail::nekarray_caster< Type, T >::cast_impl ( Nektar::Array< Nektar::OneD, U > const &  arr, return_value_policy  , handle    )

inlinestatic

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

    {
        py::list tmp;
 
        for (std::size_t i = 0; i < arr.size(); ++i)
        {
            tmp.append(arr[i]);
        }
 
        return tmp.release();
    }

decrement()

template<typename Type , typename T >

static void pybind11::detail::nekarray_caster< Type, T >::decrement ( void *  objPtr )

inlinestatic

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

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

Referenced by pybind11::detail::nekarray_caster< Type, T >::load_impl().

load()

template<typename Type , typename T >

bool pybind11::detail::nekarray_caster< Type, T >::load ( handle  src, bool  enable  )

inline

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

    {
        return load_impl(src, enable);
    }

References pybind11::detail::nekarray_caster< Type, T >::load_impl().

load_impl() [1/2]

template<typename Type , typename T >

template<typename U = T, std::enable_if_t< std::is_arithmetic_v< U >, bool > = true>

bool pybind11::detail::nekarray_caster< Type, T >::load_impl ( handle  src, bool    )

inline

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

    {
        if (!array_t<U>::check_(src))
        {
            return false;
        }
 
        auto arr = array_t<U, array::c_style | array::forcecast>::ensure(src);
        if (!arr)
        {
            return false;
        }
 
        if (arr.ndim() != 1)
        {
            return false;
        }
 
        using nonconst_t = typename std::remove_const<U>::type;
        value            = Nektar::Array<Nektar::OneD, T>(arr.shape(0),
                                               (nonconst_t *)arr.data(),
                                               (void *)src.ptr(), &decrement);
 
        // We increase the refcount on src so that even if on the Python side we
        // go out of scope, the data will still exist in at least one reference
        // until it is no longer used on the C++ side.
        src.inc_ref();
 
        return true;
    }

References pybind11::detail::nekarray_caster< Type, T >::decrement().

Referenced by pybind11::detail::nekarray_caster< Type, T >::load().

load_impl() [2/2]

template<typename Type , typename T >

template<typename U = T, std::enable_if_t< is_shared_ptr< typename std::remove_const< U >::type >::value||is_nekarray_oned< U >::value, bool > = true>

bool pybind11::detail::nekarray_caster< Type, T >::load_impl ( handle  src, bool    )

inline

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

    {
        if (!py::isinstance<py::list>(src))
        {
            return false;
        }
 
        py::list l               = py::cast<py::list>(src);
        const std::size_t nItems = l.size();
 
        using nonconst_t = typename std::remove_const<U>::type;
        auto tmparr      = Nektar::Array<Nektar::OneD, nonconst_t>(nItems);
 
        // We'll need to construct a temporary vector to hold each item in the
        // list.
        try
        {
            for (std::size_t i = 0; i < nItems; ++i)
            {
                tmparr[i] = py::cast<nonconst_t>(l[i]);
            }
        }
        catch (...)
        {
            return false;
        }
 
        value = tmparr;
 
        return true;
    }

PYBIND11_TYPE_CASTER()

template<typename Type , typename T >

pybind11::detail::nekarray_caster< Type, T >::PYBIND11_TYPE_CASTER	(	Type	,
		const_name("Array<OneD, ")+handle_type_name< T >::name+const_name(">")
	)