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>

2 files changed, 47 insertions, 5 deletions

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)