QmlProfiler: Allow string data in events

The restriction to put all strings in the type data is becoming a
burden to further enhancements. Also, introduce proper ctors for all
event structs.

Change-Id: I42d3bac96155ac1ac183a2b82785ce0396c5a932
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>

src/plugins/qmlprofiler/qmlprofilerdatamodel.h

@@ -43,6 +43,15 @@ class QMLPROFILER_EXPORT QmlProfilerDataModel : public QObject
     Q_OBJECT
 public:
     struct QmlEventTypeData {
+        QmlEventTypeData(const QString &displayName = QString(),
+                         const QmlDebug::QmlEventLocation &location = QmlDebug::QmlEventLocation(),
+                         QmlDebug::Message message = QmlDebug::MaximumMessage,
+                         QmlDebug::RangeType rangeType = QmlDebug::MaximumRangeType,
+                         int detailType = -1, const QString &data = QString()) :
+            displayName(displayName), location(location), message(message), rangeType(rangeType),
+            detailType(detailType), data(data)
+        {}
+
         QString displayName;
         QmlDebug::QmlEventLocation location;
         QmlDebug::Message message;
@@ -52,17 +61,143 @@ public:
     };
 
     struct QmlEventData {
-        int typeIndex;
-        qint64 startTime;
-        qint64 duration;
-        qint64 numericData1;
-        qint64 numericData2;
-        qint64 numericData3;
-        qint64 numericData4;
-        qint64 numericData5;
+        QmlEventData(qint64 startTime = -1, qint64 duration = -1, int typeIndex = -1,
+                     qint64 num0 = 0, qint64 num1 = 0, qint64 num2 = 0, qint64 num3 = 0,
+                     qint64 num4 = 0) :
+            m_startTime(startTime), m_duration(duration), m_dataType(NumericData),
+            m_typeIndex(typeIndex)
+        {
+            m_numericData[0] = num0;
+            m_numericData[1] = num1;
+            m_numericData[2] = num2;
+            m_numericData[3] = num3;
+            m_numericData[4] = num4;
+        }
+
+        QmlEventData(qint64 startTime, qint64 duration, int typeIndex, const QString &data)
+            : m_startTime(startTime), m_duration(duration), m_typeIndex(typeIndex)
+        {
+            assignStringData(data);
+        }
+
+        QmlEventData(const QmlEventData &other) :
+            m_startTime(other.m_startTime), m_duration(other.m_duration),
+            m_dataType(other.m_dataType), m_typeIndex(other.m_typeIndex)
+        {
+            assignData(other);
+        }
+
+        QmlEventData &operator=(const QmlEventData &other)
+        {
+            if (this != &other) {
+                if (m_dataType == StringData)
+                    m_stringData.~QString();
+
+                m_startTime = other.m_startTime;
+                m_duration = other.m_duration;
+                m_typeIndex = other.m_typeIndex;
+                m_dataType = other.m_dataType;
+                assignData(other);
+            }
+            return *this;
+        }
+
+        ~QmlEventData()
+        {
+            if (m_dataType == StringData)
+                m_stringData.~QString();
+        }
+
+        qint64 startTime() const { return m_startTime; }
+        void setStartTime(qint64 startTime) { m_startTime = startTime; }
+
+        qint64 duration() const { return m_duration; }
+        void setDuration(qint64 duration) { m_duration = duration; }
+
+        int typeIndex() const { return m_typeIndex; }
+        void setTypeIndex(int typeIndex) { m_typeIndex = typeIndex; }
+
+        qint64 numericData(int i) const { return m_dataType == NumericData ? m_numericData[i] : 0; }
+        void setNumericData(int i, qint64 data)
+        {
+            if (m_dataType == StringData)
+                m_stringData.~QString();
+
+            m_dataType = NumericData;
+            m_numericData[i] = data;
+        }
+
+        QString stringData() const
+        {
+            switch (m_dataType) {
+            case NumericData: return QString();
+            case StringData: return m_stringData;
+            default: return QString::fromUtf8(m_characterData, m_characterDataLength);
+            }
+        }
+
+        void setStringData(const QString &data)
+        {
+            if (m_dataType == StringData)
+                m_stringData.~QString();
+
+            assignStringData(data);
+        }
+
+    private:
+
+        static const quint8 StringData = 254;
+        static const quint8 NumericData = 255;
+
+        qint64 m_startTime;
+        qint64 m_duration;
+        union {
+            qint64 m_numericData[5];
+            QString m_stringData;
+            char m_characterData[5 * sizeof(qint64) + 3];
+        };
+
+        union {
+            quint8 m_dataType;
+            quint8 m_characterDataLength;
+        };
+        qint32 m_typeIndex;
+
+        void assignData(const QmlEventData &other)
+        {
+            switch (m_dataType) {
+            case StringData:
+                new (&m_stringData) QString(other.m_stringData);
+                break;
+            case NumericData:
+                for (int i = 0; i < 5; ++i)
+                    m_numericData[i] = other.m_numericData[i];
+                break;
+            default:
+                memcpy(m_characterData, other.m_characterData, m_characterDataLength);
+                break;
+            }
+        }
+
+        void assignStringData(const QString &data)
+        {
+            QByteArray cdata = data.toUtf8();
+            if (cdata.length() <= (int)sizeof(m_characterData)) {
+                m_characterDataLength = cdata.length();
+                memcpy(m_characterData, cdata.constData(), m_characterDataLength);
+            } else {
+                m_dataType = StringData;
+                new (&m_stringData) QString(data);
+            }
+        }
     };
 
     struct QmlEventNoteData {
+        QmlEventNoteData(int typeIndex = -1, qint64 startTime = -1, qint64 duration = -1,
+                         const QString &text = QString()) :
+            typeIndex(typeIndex), startTime(startTime), duration(duration), text(text)
+        {}
+
         int typeIndex;
         qint64 startTime;
         qint64 duration;