Handle QStringView et al as argument/return value

Author: usiems

generator/typesystem.cpp

@@ -1519,6 +1519,14 @@ TypeDatabase::TypeDatabase() : m_suppressWarnings(true)
     e->setPreferredConversion(false);
     addType(e);
 
+    e = new StringTypeEntry("QStringView");
+    e->setPreferredConversion(false);
+    addType(e);
+
+    e = new StringTypeEntry("QAnyStringView");
+    e->setPreferredConversion(false);
+    addType(e);
+
     e = new StringTypeEntry("QXmlStreamStringRef");
     e->setPreferredConversion(false);
     addType(e);

src/PythonQt.cpp

@@ -122,10 +122,7 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
     } else {
       qRegisterMetaType<quint32>("size_t");
     }
-#if QT_VERSION < 0x060000
-    int stringRefId = qRegisterMetaType<QStringRef>("QStringRef");
-    PythonQtConv::registerMetaTypeToPythonConverter(stringRefId, PythonQtConv::convertFromStringRef);
-#endif
+    PythonQtConv::registerStringViewTypes();
 
     int objectPtrListId = qRegisterMetaType<QList<PythonQtObjectPtr> >("QList<PythonQtObjectPtr>");
     PythonQtConv::registerMetaTypeToPythonConverter(objectPtrListId, PythonQtConv::convertFromQListOfPythonQtObjectPtr);

src/PythonQtConversion.cpp

@@ -48,6 +48,20 @@
 #include <climits>
 #include <limits>
 
+#if QT_VERSION < 0x060000
+#include <QStringRef>
+
+Q_DECLARE_METATYPE(QStringRef)
+
+int PythonQtConv::stringRefTypeId = 0;
+#else
+#include <QStringView>
+#include <QAnyStringView>
+
+int PythonQtConv::stringViewTypeId = 0;
+int PythonQtConv::anyStringViewTypeId = 0;
+#endif
+
 QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;
 QHash<int, PythonQtConvertPythonToMetaTypeCB*> PythonQtConv::_pythonToMetaTypeConverters;
 
@@ -633,19 +647,69 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
              // we have a exact enum type match:
              val = PyInt_AS_LONG(obj);
              ok = true;
-           } else if (!strict) {
+           }
+           else if (!strict) {
              // we try to get any integer, when not being strict. If we are strict, integers are not wanted because
              // we want an integer overload to be taken first!
              val = (unsigned int)PyObjGetLongLong(obj, false, ok);
            }
            if (ok) {
-             PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,frame, unsigned int, val, ptr);
+             PythonQtArgumentFrame_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame, unsigned int, val, ptr);
              return ptr;
-           } else {
+           }
+           else {
              return nullptr;
            }
          }
 
+         // Handle QStringView et al, which need a reference to a persistent QString
+#if QT_VERSION < 0x060000
+         if (info.typeId == stringRefTypeId) {
+           QString str = PyObjGetString(obj, strict, ok);
+           if (ok) {
+             void* ptr2 = nullptr;
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,
+               QVariant::fromValue(QStringRef((const QString*)((QVariant*)ptr2)->constData())), ptr);
+             ptr = (void*)((QVariant*)ptr)->constData();
+             return ptr;
+           }
+           else {
+             return nullptr;
+           }
+         }
+#else
+         if (info.typeId == stringViewTypeId) {
+           QString str = PyObjGetString(obj, strict, ok);
+           if (ok) {
+             void* ptr2 = nullptr;
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,
+               QVariant::fromValue(QStringView(*((const QString*)((QVariant*)ptr2)->constData()))), ptr);
+             ptr = (void*)((QVariant*)ptr)->constData();
+             return ptr;
+           }
+           else {
+             return nullptr;
+           }
+         }
+         else if (info.typeId == anyStringViewTypeId) {
+           // Handle QStringView et al, which need a reference to a persistent QString
+           QString str = PyObjGetString(obj, strict, ok);
+           if (ok) {
+             void* ptr2 = nullptr;
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(nullptr, frame, QVariant(str), ptr2);
+             PythonQtArgumentFrame_ADD_VARIANT_VALUE_IF_NEEDED(alreadyAllocatedCPPObject, frame,
+               QVariant::fromValue(QAnyStringView(*((const QString*)((QVariant*)ptr2)->constData()))), ptr);
+             ptr = (void*)((QVariant*)ptr)->constData();
+             return ptr;
+           }
+           else {
+             return nullptr;
+           }
+         }
+#endif
+
          if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
            // check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant
            if (info.isQList && (info.innerNamePointerCount == 1)) {
@@ -1498,6 +1562,16 @@ PyObject* PythonQtConv::convertFromStringRef(const void* inObject, int /*metaTyp
 {
   return PythonQtConv::QStringToPyObject(((QStringRef*)inObject)->toString());
 }
+#else
+PyObject* PythonQtConv::convertFromStringView(const void* inObject, int /*metaTypeId*/)
+{
+  return PythonQtConv::QStringToPyObject(((QStringView*)inObject)->toString());
+}
+
+PyObject* PythonQtConv::convertFromAnyStringView(const void* inObject, int /*metaTypeId*/)
+{
+  return PythonQtConv::QStringToPyObject(((QAnyStringView*)inObject)->toString());
+}
 #endif
 
 QByteArray PythonQtConv::getCPPTypeName(PyObject* type)
@@ -1550,6 +1624,19 @@ bool PythonQtConv::isStringType(PyTypeObject* type)
 #endif
 }
 
+void PythonQtConv::registerStringViewTypes()
+{
+#if QT_VERSION < 0x060000
+  stringRefTypeId = qRegisterMetaType<QStringRef>("QStringRef");
+  PythonQtConv::registerMetaTypeToPythonConverter(stringRefTypeId, PythonQtConv::convertFromStringRef);
+#else
+  stringViewTypeId = qRegisterMetaType<QStringView>("QStringView");
+  PythonQtConv::registerMetaTypeToPythonConverter(stringViewTypeId, PythonQtConv::convertFromStringView);
+  anyStringViewTypeId = qRegisterMetaType<QAnyStringView>("QAnyStringView");
+  PythonQtConv::registerMetaTypeToPythonConverter(anyStringViewTypeId, PythonQtConv::convertFromAnyStringView);
+#endif
+}
+
 PyObject* PythonQtConv::convertFromQListOfPythonQtObjectPtr(const void* inObject, int /*metaTypeId*/)
 {
   QList<PythonQtObjectPtr>& list = *((QList<PythonQtObjectPtr>*)inObject);

src/PythonQtConversion.h

@@ -187,6 +187,9 @@ class PYTHONQT_EXPORT PythonQtConv {
   static PyObject* convertFromQListOfPythonQtObjectPtr(const void* /* QList<PythonQtObjectPtr>* */ inObject, int /*metaTypeId*/);
 #if QT_VERSION < 0x060000
   static PyObject* convertFromStringRef(const void* inObject, int /*metaTypeId*/);
+#else
+  static PyObject* convertFromStringView(const void* inObject, int /*metaTypeId*/);
+  static PyObject* convertFromAnyStringView(const void* inObject, int /*metaTypeId*/);
 #endif
 
   //! Returns the name of the equivalent CPP type (for signals and slots)
@@ -195,6 +198,9 @@ class PYTHONQT_EXPORT PythonQtConv {
   //! Returns if the given object is a string (or unicode string)
   static bool isStringType(PyTypeObject* type);
 
+  //! Register QStringView like types, that need to be handled specially
+  static void registerStringViewTypes();
+
 protected:
   static QHash<int, PythonQtConvertMetaTypeToPythonCB*> _metaTypeToPythonConverters;
   static QHash<int, PythonQtConvertPythonToMetaTypeCB*> _pythonToMetaTypeConverters;
@@ -215,6 +221,12 @@ class PYTHONQT_EXPORT PythonQtConv {
   template <typename Map>
   static PyObject* mapToPython (const Map& m);
 
+#if QT_VERSION < 0x060000
+  static int stringRefTypeId;
+#else
+  static int stringViewTypeId;
+  static int anyStringViewTypeId;
+#endif
 };
 
 template<class ListType, class T>