libshiboken: Add Array converters

Add a SbkArrayConverter struct which provides a list of
check functions that return a converter function
for an array of matching size.

Add simple array converters for arrays of C++ primitive types.

Instances of the ArrayHandle<>,  Array2Handle<> templates will be
generated which may point to internal data or allocated arrays.

Task-number: PYSIDE-354
Task-number: PYSIDE-516
Change-Id: I157606891fad345ccd7af6d4a9d4dcb0c634b2f4
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

8 files changed, 547 insertions, 1 deletions

diff --git a/sources/shiboken2/libshiboken/CMakeLists.txt b/sources/shiboken2/libshiboken/CMakeLists.txt
index 5363ccf42..3d27e643d 100644
--- a/sources/shiboken2/libshiboken/CMakeLists.txt
+++ b/sources/shiboken2/libshiboken/CMakeLists.txt
@@ -21,6 +21,7 @@ basewrapper.cpp
 debugfreehook.cpp
 gilstate.cpp
 helper.cpp
+sbkarrayconverter.cpp
 sbkconverter.cpp
 sbkenum.cpp
 sbkmodule.cpp
@@ -48,6 +49,7 @@ install(FILES
         conversions.h
         gilstate.h
         helper.h
+        sbkarrayconverter.h
         sbkconverter.h
         sbkenum.h
         sbkmodule.h
diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter.cpp b/sources/shiboken2/libshiboken/sbkarrayconverter.cpp
new file mode 100644
index 000000000..39b4ebbf5
--- /dev/null
+++ b/sources/shiboken2/libshiboken/sbkarrayconverter.cpp
@@ -0,0 +1,281 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of PySide2.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "sbkarrayconverter.h"
+#include "sbkarrayconverter_p.h"
+#include "helper.h"
+#include "sbkconverter.h"
+#include "sbkconverter_p.h"
+
+#include <longobject.h>
+#include <floatobject.h>
+
+#include <algorithm>
+
+static SbkArrayConverter *ArrayTypeConverters[Shiboken::Conversions::SBK_ARRAY_IDX_SIZE] [2] = {};
+
+namespace Shiboken {
+namespace Conversions {
+
+// Check whether Predicate is true for all elements of a sequence
+template <class Predicate>
+static bool sequenceAllOf(PyObject *pyIn, Predicate p)
+{
+    const Py_ssize_t size = PySequence_Size(pyIn);
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        PyObject *item = PySequence_GetItem(pyIn, i);
+        const bool ok = p(item);
+        Py_XDECREF(item);
+        if (!ok)
+            return false;
+    }
+    return true;
+}
+
+// Convert a sequence to output iterator
+template <class T, class Converter>
+inline void convertPySequence(PyObject *pyIn, Converter c, T *out)
+{
+    const Py_ssize_t size = PySequence_Size(pyIn);
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        PyObject *item = PySequence_GetItem(pyIn, i);
+        *out++ = c(item);
+        Py_XDECREF(item);
+    }
+}
+
+// Internal, for usage by numpy
+SbkArrayConverter *createArrayConverter(IsArrayConvertibleToCppFunc toCppCheckFunc)
+{
+    SbkArrayConverter *result = new SbkArrayConverter;
+    result->toCppConversions.push_back(toCppCheckFunc);
+    return result;
+}
+
+static PythonToCppFunc unimplementedArrayCheck(PyObject *, int, int)
+{
+    warning(PyExc_RuntimeWarning, 0, "SbkConverter: Unimplemented C++ array type.");
+    return nullptr;
+}
+
+SbkArrayConverter *unimplementedArrayConverter()
+{
+    static SbkArrayConverter *result = createArrayConverter(unimplementedArrayCheck);
+    return result;
+}
+
+// Integers
+
+static inline bool intCheck(PyObject *pyIn)
+{
+#ifdef IS_PY3K
+    return PyLong_Check(pyIn);
+#else
+    return PyInt_Check(pyIn);
+#endif
+}
+
+static short toShort(PyObject *pyIn) { return short(PyLong_AsLong(pyIn)); }
+
+static void sequenceToCppShortArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<short> *handle = reinterpret_cast<ArrayHandle<short> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, toShort, handle->data());
+}
+
+static inline bool sequenceSizeCheck(PyObject *pyIn, int expectedSize = -1)
+{
+    if (expectedSize >= 0) {
+        const int size = int(PySequence_Size(pyIn));
+        if (size < expectedSize) {
+            warning(PyExc_RuntimeWarning, 0, "A sequence of size %d was passed to a function that expects %d.",
+                   size, expectedSize);
+            return false;
+        }
+    }
+    return true;
+}
+
+static inline bool intArrayCheck(PyObject *pyIn, int expectedSize = -1)
+{
+    return PySequence_Check(pyIn) && sequenceAllOf(pyIn, intCheck)
+        && sequenceSizeCheck(pyIn, expectedSize);
+}
+
+static PythonToCppFunc sequenceToCppShortArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppShortArray : nullptr;
+}
+
+static short toUnsignedShort(PyObject *pyIn) { return static_cast<unsigned short>(PyLong_AsUnsignedLong(pyIn)); }
+
+static void sequenceToCppUnsignedShortArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<unsigned short> *handle = reinterpret_cast<ArrayHandle<unsigned short> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, toUnsignedShort, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppUnsignedShortArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppUnsignedShortArray : nullptr;
+}
+
+static void sequenceToCppIntArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<int> *handle = reinterpret_cast<ArrayHandle<int> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, _PyLong_AsInt, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppIntArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppIntArray : nullptr;
+}
+
+static void sequenceToCppUnsignedArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<unsigned> *handle = reinterpret_cast<ArrayHandle<unsigned> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, PyLong_AsUnsignedLong, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppUnsignedArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppUnsignedArray : nullptr;
+}
+
+static void sequenceToCppLongLongArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<long long> *handle = reinterpret_cast<ArrayHandle<long long> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, PyLong_AsLongLong, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppLongLongArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppLongLongArray : nullptr;
+}
+
+static void sequenceToCppUnsignedLongLongArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<unsigned long long> *handle = reinterpret_cast<ArrayHandle<unsigned long long> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, PyLong_AsUnsignedLongLong, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppUnsignedLongLongArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return intArrayCheck(pyIn, dim1) ? sequenceToCppUnsignedLongLongArray : nullptr;
+}
+
+// Float
+
+static inline bool floatCheck(PyObject *pyIn) { return PyFloat_Check(pyIn); }
+
+static inline bool floatArrayCheck(PyObject *pyIn, int expectedSize = -1)
+{
+    return PySequence_Check(pyIn) && sequenceAllOf(pyIn, floatCheck)
+        && sequenceSizeCheck(pyIn, expectedSize);
+}
+
+static void sequenceToCppDoubleArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<double> *handle = reinterpret_cast<ArrayHandle<double> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, PyFloat_AsDouble, handle->data());
+}
+
+static inline float pyToFloat(PyObject *pyIn) { return float(PyFloat_AsDouble(pyIn)); }
+
+static void sequenceToCppFloatArray(PyObject *pyIn, void *cppOut)
+{
+    ArrayHandle<float> *handle = reinterpret_cast<ArrayHandle<float> *>(cppOut);
+    handle->allocate(PySequence_Size(pyIn));
+    convertPySequence(pyIn, pyToFloat, handle->data());
+}
+
+static PythonToCppFunc sequenceToCppFloatArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return floatArrayCheck(pyIn, dim1) ? sequenceToCppFloatArray : nullptr;
+}
+
+static PythonToCppFunc sequenceToCppDoubleArrayCheck(PyObject *pyIn, int dim1, int /* dim2 */)
+{
+    return floatArrayCheck(pyIn, dim1) ? sequenceToCppDoubleArray : nullptr;
+}
+
+void initArrayConverters()
+{
+    SbkArrayConverter **start = &ArrayTypeConverters[0][0];
+    std::fill(start, start + sizeof(ArrayTypeConverters) / sizeof(ArrayTypeConverters[0][0]), nullptr);
+    // Populate 1-dimensional sequence converters
+    ArrayTypeConverters[SBK_DOUBLE_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppDoubleArrayCheck);
+    ArrayTypeConverters[SBK_FLOAT_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppFloatArrayCheck);
+    ArrayTypeConverters[SBK_SHORT_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppShortArrayCheck);
+    ArrayTypeConverters[SBK_UNSIGNEDSHORT_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppUnsignedShortArrayCheck);
+    ArrayTypeConverters[SBK_INT_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppIntArrayCheck);
+    ArrayTypeConverters[SBK_UNSIGNEDINT_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppUnsignedArrayCheck);
+    ArrayTypeConverters[SBK_LONGLONG_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppLongLongArrayCheck);
+    ArrayTypeConverters[SBK_UNSIGNEDLONGLONG_ARRAY_IDX][0] =
+        createArrayConverter(sequenceToCppUnsignedLongLongArrayCheck);
+}
+
+SbkArrayConverter *arrayTypeConverter(int index, int dimension)
+{
+    SbkArrayConverter *c = ArrayTypeConverters[index][dimension - 1];
+    return c ? c : unimplementedArrayConverter();
+}
+
+// Internal, for usage by numpy
+void setArrayTypeConverter(int index, int dimension, SbkArrayConverter *c)
+{
+    ArrayTypeConverters[index][dimension - 1] = c;
+}
+
+} // namespace Conversions
+} // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter.h b/sources/shiboken2/libshiboken/sbkarrayconverter.h
new file mode 100644
index 000000000..f3d3e5f98
--- /dev/null
+++ b/sources/shiboken2/libshiboken/sbkarrayconverter.h
@@ -0,0 +1,171 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of PySide2.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SBKARRAYCONVERTERS_H
+#define SBKARRAYCONVERTERS_H
+
+#include "sbkpython.h"
+#include "shibokenmacros.h"
+
+extern "C" {
+struct SbkArrayConverter;
+}
+
+namespace Shiboken {
+namespace Conversions {
+
+enum : int {
+    SBK_UNIMPLEMENTED_ARRAY_IDX,
+    SBK_DOUBLE_ARRAY_IDX,
+    SBK_FLOAT_ARRAY_IDX,
+    SBK_SHORT_ARRAY_IDX,
+    SBK_UNSIGNEDSHORT_ARRAY_IDX,
+    SBK_INT_ARRAY_IDX,
+    SBK_UNSIGNEDINT_ARRAY_IDX,
+    SBK_LONGLONG_ARRAY_IDX,
+    SBK_UNSIGNEDLONGLONG_ARRAY_IDX,
+    SBK_ARRAY_IDX_SIZE
+};
+
+/**
+ * ArrayHandle is the type expected by shiboken2's array converter
+ * functions. It provides access to array data which it may own
+ * (in the case of conversions from PySequence) or a flat pointer
+ * to internal data (in the case of array modules like numpy).
+ */
+
+template <class T>
+class ArrayHandle
+{
+    ArrayHandle(const ArrayHandle &) = delete;
+    ArrayHandle& operator=(const ArrayHandle &) = delete;
+public:
+    ArrayHandle() {}
+    ~ArrayHandle() { destroy(); }
+
+    void allocate(Py_ssize_t size);
+    void setData(T *d, size_t size);
+
+    size_t size() const { return m_size; }
+    T *data() const { return m_data; }
+    operator T*() const { return m_data; }
+
+private:
+    void destroy();
+
+    T *m_data = nullptr;
+    Py_ssize_t m_size = 0;
+    bool m_owned = false;
+};
+
+/**
+ * Similar to ArrayHandle for fixed size 2 dimensional arrays.
+ * columns is the size of the last dimension
+ * It only has a setData() methods since it will be used for numpy only.
+ */
+
+template <class T, int columns>
+class Array2Handle
+{
+public:
+    typedef T RowType[columns];
+
+    Array2Handle() {}
+
+    operator RowType*() const { return m_rows; }
+
+    void setData(RowType *d) { m_rows = d; }
+
+private:
+   RowType *m_rows = nullptr;
+};
+
+/// Returns the converter for an array type.
+LIBSHIBOKEN_API SbkArrayConverter *arrayTypeConverter(int index, int dimension = 1);
+
+template <class T>
+struct ArrayTypeIndex{
+    enum : int { index = SBK_UNIMPLEMENTED_ARRAY_IDX };
+};
+
+template <> struct ArrayTypeIndex<double> { enum : int { index = SBK_DOUBLE_ARRAY_IDX }; };
+template <> struct ArrayTypeIndex<float> { enum : int { index = SBK_FLOAT_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<short> { enum : int { index = SBK_SHORT_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<unsigned short> { enum : int { index = SBK_UNSIGNEDSHORT_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<int> { enum : int { index = SBK_INT_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<unsigned> { enum : int { index = SBK_UNSIGNEDINT_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<long long> { enum : int { index = SBK_LONGLONG_ARRAY_IDX };};
+template <> struct ArrayTypeIndex<unsigned long long> { enum : int { index = SBK_UNSIGNEDLONGLONG_ARRAY_IDX };};
+
+template<typename T> SbkArrayConverter *ArrayTypeConverter(int dimension)
+{ return arrayTypeConverter(ArrayTypeIndex<T>::index, dimension); }
+
+// ArrayHandle methods
+template<class T>
+void ArrayHandle<T>::allocate(Py_ssize_t size)
+{
+    destroy();
+    m_data = new T[size];
+    m_size = size;
+    m_owned = true;
+}
+
+template<class T>
+void ArrayHandle<T>::setData(T *d, size_t size)
+{
+    destroy();
+    m_data = d;
+    m_size = size;
+    m_owned = false;
+}
+
+template<class T>
+void ArrayHandle<T>::destroy()
+{
+    if (m_owned)
+        delete [] m_data;
+    m_data = nullptr;
+    m_size = 0;
+    m_owned = false;
+}
+
+} // namespace Conversions
+} // namespace Shiboken
+
+#endif // SBKARRAYCONVERTERS_H
diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter_p.h b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h
new file mode 100644
index 000000000..9384fbcf5
--- /dev/null
+++ b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of PySide2.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SBKARRAYCONVERTER_P_H
+#define SBKARRAYCONVERTER_P_H
+
+#include "sbkconverter_p.h"
+#include <vector>
+
+extern "C"
+{
+
+typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject*, int dim1, int dim2);
+/**
+ *  \internal
+ *  Private structure of SbkArrayConverter.
+ */
+
+struct SbkArrayConverter
+{
+    std::vector<IsArrayConvertibleToCppFunc> toCppConversions;
+};
+
+} // extern "C"
+
+#endif // SBKARRAYCONVERTER_P_H
diff --git a/sources/shiboken2/libshiboken/sbkconverter.cpp b/sources/shiboken2/libshiboken/sbkconverter.cpp
index 2a51edd76..b86e09fa2 100644
--- a/sources/shiboken2/libshiboken/sbkconverter.cpp
+++ b/sources/shiboken2/libshiboken/sbkconverter.cpp
@@ -39,6 +39,7 @@
 
 #include "sbkconverter.h"
 #include "sbkconverter_p.h"
+#include "sbkarrayconverter_p.h"
 #include "basewrapper_p.h"
 #include "autodecref.h"
 #include "sbkdbg.h"
@@ -54,6 +55,8 @@ static ConvertersMap converters;
 namespace Shiboken {
 namespace Conversions {
 
+void initArrayConverters();
+
 void init()
 {
     static SbkConverter* primitiveTypeConverters[] = {
@@ -95,9 +98,11 @@ void init()
     converters["unsigned long"] = primitiveTypeConverters[SBK_UNSIGNEDLONG_IDX];
     converters["unsigned short"] = primitiveTypeConverters[SBK_UNSIGNEDSHORT_IDX];
     converters["void*"] = primitiveTypeConverters[SBK_VOIDPTR_IDX];
+
+    initArrayConverters();
 }
 
-static SbkConverter* createConverterObject(PyTypeObject* type,
+SbkConverter *createConverterObject(PyTypeObject *type,
                                            PythonToCppFunc toCppPointerConvFunc,
                                            IsConvertibleToCppFunc toCppPointerCheckFunc,
                                            CppToPythonFunc pointerToPythonFunc,
@@ -254,6 +259,17 @@ PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject
     return IsPythonToCppConvertible(converter, pyIn);
 }
 
+PythonToCppFunc isPythonToCppConvertible(const SbkArrayConverter *converter,
+                                         int dim1, int dim2, PyObject *pyIn)
+{
+    assert(pyIn);
+    for (IsArrayConvertibleToCppFunc f : converter->toCppConversions) {
+        if (PythonToCppFunc c = f(pyIn, dim1, dim2))
+            return c;
+    }
+    return nullptr;
+}
+
 PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjectType *type, PyObject *pyIn)
 {
     if (pyIn != Py_None) {
diff --git a/sources/shiboken2/libshiboken/sbkconverter.h b/sources/shiboken2/libshiboken/sbkconverter.h
index 7489b930d..18b6bbcf3 100644
--- a/sources/shiboken2/libshiboken/sbkconverter.h
+++ b/sources/shiboken2/libshiboken/sbkconverter.h
@@ -67,6 +67,7 @@ extern "C"
  *  using the functions provided by the converter API.
  */
 struct SbkConverter;
+struct SbkArrayConverter;
 
 /**
  *  Given a void pointer to a C++ object, this function must return
@@ -241,6 +242,8 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjec
 
 /// This is the same as isPythonToCppValueConvertible function.
 LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkArrayConverter *converter,
+                                                         int dim1, int dim2, PyObject *pyIn);
 
 /**
  *  Returns the C++ pointer for the \p pyIn object cast to the type passed via \p desiredType.
diff --git a/sources/shiboken2/libshiboken/sbkconverter_p.h b/sources/shiboken2/libshiboken/sbkconverter_p.h
index b38561780..fd1f7b6b2 100644
--- a/sources/shiboken2/libshiboken/sbkconverter_p.h
+++ b/sources/shiboken2/libshiboken/sbkconverter_p.h
@@ -571,4 +571,14 @@ struct Primitive<void*> : OnePrimitive<void*>
     }
 };
 
+namespace Shiboken {
+namespace Conversions {
+SbkConverter *createConverterObject(PyTypeObject *type,
+                                    PythonToCppFunc toCppPointerConvFunc,
+                                    IsConvertibleToCppFunc toCppPointerCheckFunc,
+                                    CppToPythonFunc pointerToPythonFunc,
+                                    CppToPythonFunc copyToPythonFunc);
+} // namespace Conversions
+} // namespace Shiboken
+
 #endif // SBK_CONVERTER_P_H
diff --git a/sources/shiboken2/libshiboken/shiboken.h b/sources/shiboken2/libshiboken/shiboken.h
index 2738bf51f..5bdef1b86 100644
--- a/sources/shiboken2/libshiboken/shiboken.h
+++ b/sources/shiboken2/libshiboken/shiboken.h
@@ -48,6 +48,7 @@
 #include "gilstate.h"
 #include "threadstatesaver.h"
 #include "helper.h"
+#include "sbkarrayconverter.h"
 #include "sbkconverter.h"
 #include "sbkenum.h"
 #include "sbkmodule.h"