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>

18 files changed, 685 insertions, 6 deletions

diff --git a/sources/pyside2-tools b/sources/pyside2-tools
-Subproject f68388cf547c0d63a5d4a145f65aa9fa90529d5
+Subproject 413ecc73fbe6d6717ae2132e86648ac8b6da9d3
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 0c4e4a8bf..7cd9c371e 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -147,6 +147,23 @@ AbstractMetaType *AbstractMetaType::copy() const
     return cpy;
 }
 
+AbstractMetaTypeCList AbstractMetaType::nestedArrayTypes() const
+{
+    AbstractMetaTypeCList result;
+    switch (m_pattern) {
+    case ArrayPattern:
+        for (const AbstractMetaType *t = this; t->typeUsagePattern() == ArrayPattern; ) {
+            const AbstractMetaType *elt = t->arrayElementType();
+            result.append(elt);
+            t = elt;
+        }
+        break;
+    default:
+        break;
+    }
+    return result;
+}
+
 QString AbstractMetaType::cppSignature() const
 {
     if (m_cachedCppSignature.isEmpty())
@@ -2605,6 +2622,11 @@ bool AbstractMetaType::hasNativeId() const
     return (isQObject() || isValue() || isObject()) && typeEntry()->isNativeIdBased();
 }
 
+bool AbstractMetaType::isCppPrimitive() const
+{
+    return m_pattern == PrimitivePattern && m_typeEntry->isCppPrimitive();
+}
+
 bool AbstractMetaType::isTargetLangEnum() const
 {
     return isEnum() && !static_cast<const EnumTypeEntry *>(typeEntry())->forceInteger();
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index 921df4300..c838f97e2 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -399,6 +399,8 @@ public:
         return m_pattern == PrimitivePattern;
     }
 
+    bool isCppPrimitive() const;
+
     // returns true if the type is used as an enum
     bool isEnum() const
     {
@@ -558,6 +560,8 @@ public:
         m_arrayElementType = t;
     }
 
+    AbstractMetaTypeCList nestedArrayTypes() const;
+
     QString cppSignature() const;
 
     AbstractMetaType *copy() const;
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken2/ApiExtractor/abstractmetalang_typedefs.h
index da8369895..6522ba2dd 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang_typedefs.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang_typedefs.h
@@ -46,5 +46,6 @@ typedef QVector<AbstractMetaEnumValue *> AbstractMetaEnumValueList;
 typedef QVector<AbstractMetaField *> AbstractMetaFieldList;
 typedef QVector<AbstractMetaFunction *> AbstractMetaFunctionList;
 typedef QVector<AbstractMetaType *> AbstractMetaTypeList;
+typedef QVector<const AbstractMetaType *> AbstractMetaTypeCList;
 
 #endif // ABSTRACTMETALANG_TYPEDEFS_H
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index 91ed7eec5..1f576cfe4 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -2206,6 +2206,23 @@ const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction
     return argType;
 }
 
+static inline QString arrayHandleType(const AbstractMetaTypeCList &nestedArrayTypes)
+{
+    switch (nestedArrayTypes.size()) {
+    case 1:
+        return QStringLiteral("Shiboken::Conversions::ArrayHandle<")
+            + nestedArrayTypes.constLast()->minimalSignature()
+            + QLatin1Char('>');
+    case 2:
+        return QStringLiteral("Shiboken::Conversions::Array2Handle<")
+            + nestedArrayTypes.constLast()->minimalSignature()
+            + QStringLiteral(", ")
+            + QString::number(nestedArrayTypes.constFirst()->arrayElementCount())
+            + QLatin1Char('>');
+    }
+    return QString();
+}
+
 void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
                                                   const AbstractMetaType* type,
                                                   const QString& pyIn,
@@ -2227,7 +2244,13 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
                                      && !isCppPrimitive(type)
                                      && isNotContainerEnumOrFlags
                                      && !(treatAsPointer || isPointerOrObjectType);
-    QString typeName = getFullTypeNameWithoutModifiers(type);
+
+    const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes();
+    const bool isCppPrimitiveArray = !nestedArrayTypes.isEmpty()
+        && nestedArrayTypes.constLast()->isCppPrimitive();
+    QString typeName = isCppPrimitiveArray
+        ? arrayHandleType(nestedArrayTypes)
+        : getFullTypeNameWithoutModifiers(type);
 
     bool isProtectedEnum = false;
 
@@ -2244,7 +2267,9 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
     }
 
     s << INDENT << typeName;
-    if (treatAsPointer || isPointerOrObjectType) {
+    if (isCppPrimitiveArray) {
+        s << ' ' << cppOut;
+    } else if (treatAsPointer || isPointerOrObjectType) {
         s << "* " << cppOut;
         if (!defaultValue.isEmpty())
             s << " = " << defaultValue;
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index 8ec4474ad..b6242c57f 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -779,6 +779,13 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType* type)
         return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<const char*>()");
     if (isVoidPointer(type))
         return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<void*>()");
+    const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes();
+    if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) {
+        return QStringLiteral("Shiboken::Conversions::ArrayTypeConverter<")
+            + nestedArrayTypes.constLast()->minimalSignature()
+            + QLatin1String(">(") + QString::number(nestedArrayTypes.size())
+            + QLatin1Char(')');
+    }
     if (type->typeEntry()->isContainer()) {
         return convertersVariableName(type->typeEntry()->targetLangPackage())
                + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']');
@@ -1232,8 +1239,8 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
             return customCheck;
     }
 
+    QString result = QLatin1String("Shiboken::Conversions::");
     if (isWrapperType(metaType)) {
-        QString result = QLatin1String("Shiboken::Conversions::");
         if (isPointer(metaType) || isValueTypeWithCopyConstructorOnly(metaType))
             result += QLatin1String("isPythonToCppPointerConvertible");
         else if (metaType->referenceType() == LValueReference)
@@ -1244,8 +1251,18 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
             + cpythonTypeNameExt(metaType) + QLatin1String("), ");
         return result;
     }
-    return QStringLiteral("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
-              .arg(converterObject(metaType));
+    result += QLatin1String("isPythonToCppConvertible(") + converterObject(metaType);
+    // Write out array sizes if known
+    const AbstractMetaTypeCList nestedArrayTypes = metaType->nestedArrayTypes();
+    if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) {
+        const int dim1 = metaType->arrayElementCount();
+        const int dim2 = nestedArrayTypes.constFirst()->isArray()
+            ? nestedArrayTypes.constFirst()->arrayElementCount() : -1;
+        result += QLatin1String(", ") + QString::number(dim1)
+            + QLatin1String(", ") + QString::number(dim2);
+    }
+    result += QLatin1String(", ");
+    return result;
 }
 
 QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType)
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"
diff --git a/sources/shiboken2/tests/libsample/functions.cpp b/sources/shiboken2/tests/libsample/functions.cpp
index 4a15cdae8..7a91a7b62 100644
--- a/sources/shiboken2/tests/libsample/functions.cpp
+++ b/sources/shiboken2/tests/libsample/functions.cpp
@@ -28,7 +28,9 @@
 
 #include "functions.h"
 #include <string.h>
+#include <algorithm>
 #include <iostream>
+#include <numeric>
 
 using namespace std;
 
@@ -197,6 +199,16 @@ acceptOddBoolReference(OddBool& x)
     return x;
 }
 
+int sumIntArray(int array[4])
+{
+    return std::accumulate(array, array + 4, 0);
+}
+
+double sumDoubleArray(double array[4])
+{
+    return std::accumulate(array, array + 4, double(0));
+}
+
 ClassWithFunctionPointer::ClassWithFunctionPointer()
 {
     callFunctionPointer(0, &ClassWithFunctionPointer::doNothing);
diff --git a/sources/shiboken2/tests/libsample/functions.h b/sources/shiboken2/tests/libsample/functions.h
index 89a175bc4..69d4cdceb 100644
--- a/sources/shiboken2/tests/libsample/functions.h
+++ b/sources/shiboken2/tests/libsample/functions.h
@@ -81,6 +81,8 @@ LIBSAMPLE_API double acceptDouble(double x);
 LIBSAMPLE_API int acceptIntReference(int& x);
 LIBSAMPLE_API OddBool acceptOddBoolReference(OddBool& x);
 
+LIBSAMPLE_API int sumIntArray(int array[4]);
+LIBSAMPLE_API double sumDoubleArray(double array[4]);
 
 class LIBSAMPLE_API ClassWithFunctionPointer
 {
diff --git a/sources/shiboken2/tests/samplebinding/array_sequence_test.py b/sources/shiboken2/tests/samplebinding/array_sequence_test.py
new file mode 100644
index 000000000..3c6a23845
--- /dev/null
+++ b/sources/shiboken2/tests/samplebinding/array_sequence_test.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+#############################################################################
+##
+## Copyright (C) 2017 The Qt Company Ltd.
+## Contact: https://www.qt.io/licensing/
+##
+## This file is part of the test suite of PySide2.
+##
+## $QT_BEGIN_LICENSE:GPL-EXCEPT$
+## 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 General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU
+## General Public License version 3 as published by the Free Software
+## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+## 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-3.0.html.
+##
+## $QT_END_LICENSE$
+##
+#############################################################################
+
+'''Test case for Array types (PySequence).'''
+
+import unittest
+import sample
+
+class ArrayTester(unittest.TestCase):
+    '''Test case for arrays.'''
+
+    def testIntArray(self):
+        intList = [1, 2, 3, 4]
+        self.assertEqual(sample.sumIntArray(intList), 10)
+
+    def testDoubleArray(self):
+        doubleList = [1.2, 2.3, 3.4, 4.5]
+        self.assertEqual(sample.sumDoubleArray(doubleList), 11.4)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken2/tests/samplebinding/typesystem_sample.xml b/sources/shiboken2/tests/samplebinding/typesystem_sample.xml
index 0b5bd0d38..9db4a7928 100644
--- a/sources/shiboken2/tests/samplebinding/typesystem_sample.xml
+++ b/sources/shiboken2/tests/samplebinding/typesystem_sample.xml
@@ -501,6 +501,8 @@
     <function signature="gimmeInt()" />
     <function signature="gimmeDouble()" />
     <function signature="makeCString()" />
+    <function signature="sumIntArray(int[4])"/>
+    <function signature="sumDoubleArray(double[4])"/>
     <function signature="multiplyPair(std::pair&lt;double, double>)" />
     <function signature="returnCString()" />
     <function signature="overloadedFunc(double)" />