Support QByteArrayView arguments + return values

Author: usiems

generator/main.cpp

@@ -203,8 +203,12 @@ int main(int argc, char *argv[])
     printf("Parsing typesystem file [%s]\n", qPrintable(typesystemFileName));
     fflush(stdout);
     ReportHandler::setContext("Typesystem");
-    if (!TypeDatabase::instance()->parseFile(typesystemFileName, qtVersion))
+    if (TypeDatabase::instance()->parseFile(typesystemFileName, qtVersion)) {
+        TypeDatabase::instance()->finalSetup();
+    }
+    else {
         qFatal("Cannot parse file: '%s'", qPrintable(typesystemFileName));
+    }
 
     printf("PreProcessing - Generate [%s] using [%s] and include-paths [%s]\n",
       qPrintable(pp_file), qPrintable(fileName), qPrintable(args.value("include-paths")));

generator/typesystem.cpp

@@ -1573,6 +1573,19 @@ TypeDatabase::TypeDatabase() : m_suppressWarnings(true)
     addRemoveFunctionToTemplates(this);
 }
 
+void TypeDatabase::finalSetup()
+{
+  TypeEntry* byteArrayType = findType("QByteArray");
+  if (byteArrayType) {
+      // Support QByteArrayView as alternative parameter type.
+      // Using StringTypeEntry for it, because no wrappers are generated for those types
+      StringTypeEntry* e = new StringTypeEntry("QByteArrayView");
+      e->setPreferredConversion(false);
+      e->setEquivalentType(byteArrayType);
+      addType(e);
+  }
+}
+
 bool TypeDatabase::parseFile(const QString &filename, unsigned int qtVersion, bool generate)
 {
     QFile file(filename);

generator/typesystem.h

@@ -1234,6 +1234,7 @@ class TypeDatabase
     QString filename() const { return "typesystem.txt"; }
 
     bool parseFile(const QString &filename, unsigned int qtVersion, bool generate = true);
+    void finalSetup();
 
 private:
     bool m_suppressWarnings;

src/PythonQtConversion.cpp

@@ -57,9 +57,11 @@ int PythonQtConv::stringRefTypeId = 0;
 #else
 #include <QStringView>
 #include <QAnyStringView>
+#include <QByteArrayView>
 
 int PythonQtConv::stringViewTypeId = 0;
 int PythonQtConv::anyStringViewTypeId = 0;
+int PythonQtConv::byteArrayViewTypeId = 0;
 #endif
 
 QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;
@@ -399,6 +401,9 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
 
    if (PyObject_TypeCheck(obj, &PythonQtInstanceWrapper_Type) &&
        info.typeId != PythonQtMethodInfo::Variant &&
+#if QT_VERSION >= 0x060000
+       info.typeId != byteArrayViewTypeId &&  // this case is handled later on
+#endif
        !PythonQt::priv()->isPythonQtAnyObjectPtrMetaId(info.typeId)) {
      // if we have a Qt wrapper object and if we do not need a QVariant, we do the following:
      // (the Variant case is handled below in a switch)
@@ -597,13 +602,7 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
        break;
      case QMetaType::QByteArray:
        {
-         QByteArray bytes = PyObjGetBytes(obj, strict, ok);
-         if (!ok && !strict) {
-           // since Qt uses QByteArray in many places for identifier strings,
-           // we need to allow implicit conversion from unicode as well.
-           // We allow that for both Python 2.x and 3.x to be compatible.
-           bytes = PyObjGetString(obj, true, ok).toUtf8();
-         }
+         QByteArray bytes = PyObjGetBytesAllowString(obj, strict, ok);
          if (ok) {
            PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, QVariant(bytes), ptr);
            ptr = (void*)((QVariant*)ptr)->constData();
@@ -680,6 +679,7 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
          }
 #else
          if (info.typeId == stringViewTypeId) {
+           // Handle QStringView, which needs a reference to a persistent QString
            QString str = PyObjGetString(obj, strict, ok);
            if (ok) {
              void* ptr2 = nullptr;
@@ -694,7 +694,7 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
            }
          }
          else if (info.typeId == anyStringViewTypeId) {
-           // Handle QStringView et al, which need a reference to a persistent QString
+           // Handle QAnyStringView, which needs a reference to a persistent QString
            QString str = PyObjGetString(obj, strict, ok);
            if (ok) {
              void* ptr2 = nullptr;
@@ -708,6 +708,21 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
              return nullptr;
            }
          }
+         else if (info.typeId == byteArrayViewTypeId) {
+           // Handle QByteArrayView, which needs a reference to a persistent QByteArray
+           QByteArray ba = PyObjGetBytesAllowString(obj, strict, ok);
+           if (ok) {
+             void* ptr2 = nullptr;
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(ba), ptr2);
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,
+               QVariant::fromValue(QByteArrayView(*((const QByteArray*)((QVariant*)ptr2)->constData()))), ptr);
+             ptr = (void*)((QVariant*)ptr)->constData();
+             return ptr;
+           }
+           else {
+             return nullptr;
+           }
+         }
 #endif
 
          if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
@@ -847,6 +862,15 @@ QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok)
   // TODO: support buffer objects in general
   QByteArray r;
   ok = true;
+  if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
+    // check if we already have a QByteArray wrapper here
+    PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)val;
+    bool baOk;
+    QByteArray* baPtr = (QByteArray*)castWrapperTo(wrapper, "QByteArray", baOk);
+    if (baOk && baPtr) {
+      return *baPtr;
+    }
+  }
   if (PyBytes_Check(val)) {
     r = QByteArray(PyBytes_AS_STRING(val), PyBytes_GET_SIZE(val));
   } else {
@@ -855,6 +879,18 @@ QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok)
   return r;
 }
 
+QByteArray PythonQtConv::PyObjGetBytesAllowString(PyObject* val, bool strict, bool& ok)
+{
+  QByteArray bytes = PyObjGetBytes(val, strict, ok);
+  if (!ok && !strict) {
+    // since Qt uses QByteArray in many places for identifier strings,
+    // we need to allow implicit conversion from unicode as well.
+    // We allow that for both Python 2.x and 3.x to be compatible.
+    bytes = PyObjGetString(val, true, ok).toUtf8();
+  }
+  return bytes;
+}
+
 bool PythonQtConv::PyObjGetBool(PyObject* val, bool strict, bool &ok) {
   bool d = false;
   ok = false;
@@ -1560,17 +1596,23 @@ PyObject* PythonQtConv::createCopyFromMetaType( int type, const void* data )
 #if QT_VERSION < 0x060000
 PyObject* PythonQtConv::convertFromStringRef(const void* inObject, int /*metaTypeId*/)
 {
-  return PythonQtConv::QStringToPyObject(((QStringRef*)inObject)->toString());
+  return QStringToPyObject(((QStringRef*)inObject)->toString());
 }
 #else
 PyObject* PythonQtConv::convertFromStringView(const void* inObject, int /*metaTypeId*/)
 {
-  return PythonQtConv::QStringToPyObject(((QStringView*)inObject)->toString());
+  return QStringToPyObject(((QStringView*)inObject)->toString());
 }
 
 PyObject* PythonQtConv::convertFromAnyStringView(const void* inObject, int /*metaTypeId*/)
 {
-  return PythonQtConv::QStringToPyObject(((QAnyStringView*)inObject)->toString());
+  return QStringToPyObject(((QAnyStringView*)inObject)->toString());
+}
+
+PyObject* PythonQtConv::convertFromByteArrayView(const void* inObject, int)
+{
+  QByteArray ba = ((QByteArrayView*)inObject)->toByteArray();
+  return createCopyFromMetaType(QMetaType::QByteArray, &ba);
 }
 #endif
 
@@ -1634,6 +1676,8 @@ void PythonQtConv::registerStringViewTypes()
   PythonQtConv::registerMetaTypeToPythonConverter(stringViewTypeId, PythonQtConv::convertFromStringView);
   anyStringViewTypeId = qRegisterMetaType<QAnyStringView>("QAnyStringView");
   PythonQtConv::registerMetaTypeToPythonConverter(anyStringViewTypeId, PythonQtConv::convertFromAnyStringView);
+  byteArrayViewTypeId = qRegisterMetaType<QByteArrayView>("QByteArrayView");
+  PythonQtConv::registerMetaTypeToPythonConverter(byteArrayViewTypeId, PythonQtConv::convertFromByteArrayView);
 #endif
 }
 

src/PythonQtConversion.h

@@ -132,6 +132,8 @@ class PYTHONQT_EXPORT PythonQtConv {
   static QString PyObjGetString(PyObject* val, bool strict, bool &ok);
   //! get bytes from py object
   static QByteArray PyObjGetBytes(PyObject* val, bool strict, bool &ok);
+  //! get bytes from py object, also allows Python string
+  static QByteArray PyObjGetBytesAllowString(PyObject* val, bool strict, bool& ok);
   //! get int from py object
   static int     PyObjGetInt(PyObject* val, bool strict, bool &ok);
   //! get int64 from py object
@@ -190,6 +192,7 @@ class PYTHONQT_EXPORT PythonQtConv {
 #else
   static PyObject* convertFromStringView(const void* inObject, int /*metaTypeId*/);
   static PyObject* convertFromAnyStringView(const void* inObject, int /*metaTypeId*/);
+  static PyObject* convertFromByteArrayView(const void* inObject, int /*metaTypeId*/);
 #endif
 
   //! Returns the name of the equivalent CPP type (for signals and slots)
@@ -226,6 +229,7 @@ class PYTHONQT_EXPORT PythonQtConv {
 #else
   static int stringViewTypeId;
   static int anyStringViewTypeId;
+  static int byteArrayViewTypeId;
 #endif
 };