Switch list to a vector.

[apitrace] / gui / apitracecall.cpp

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index 6a93d6d7b33526c4086fa5e1c7332832e639bc83..bdf55919334b9a149ae8263b9eeee68b7ca7a4fa 100644 (file)
--- a/gui/apitracecall.cpp
+++ b/gui/apitracecall.cpp
@@ -173,10 +173,21 @@ void VariantVisitor::visit(Trace::String *node)
 
 void VariantVisitor::visit(Trace::Enum *e)
 {
-    QVariant val = QVariant(e->sig->value);
+    ApiTraceEnumSignature *sig = 0;
 
-    m_variant = QVariant::fromValue(
-        ApiEnum(QString::fromStdString(e->sig->name), val));
+    if (m_trace) {
+        sig = m_trace->enumSignature(e->sig->id);
+    }
+    if (!sig) {
+        sig = new ApiTraceEnumSignature(
+            QString::fromStdString(e->sig->name),
+            QVariant(e->sig->value));
+        if (m_trace) {
+            m_trace->addEnumSignature(e->sig->id, sig);
+        }
+    }
+
+    m_variant = QVariant::fromValue(ApiEnum(sig));
 }
 
 void VariantVisitor::visit(Trace::Bitmask *bitmask)
@@ -214,25 +225,36 @@ void VariantVisitor::visit(Trace::Pointer *ptr)
 }
 
 
-ApiEnum::ApiEnum(const QString &name, const QVariant &val)
-    : m_name(name),
-      m_value(val)
+ApiEnum::ApiEnum(ApiTraceEnumSignature *sig)
+    : m_sig(sig)
 {
 }
 
 QString ApiEnum::toString() const
 {
-    return m_name;
+    if (m_sig) {
+        return m_sig->name();
+    }
+    Q_ASSERT(!"should never happen");
+    return QString();
 }
 
 QVariant ApiEnum::value() const
 {
-    return m_value;
+    if (m_sig) {
+        return m_sig->value();
+    }
+    Q_ASSERT(!"should never happen");
+    return QVariant();
 }
 
 QString ApiEnum::name() const
 {
-    return m_name;
+    if (m_sig) {
+        return m_sig->name();
+    }
+    Q_ASSERT(!"should never happen");
+    return QString();
 }
 
 unsigned long long ApiBitmask::value() const
@@ -353,7 +375,7 @@ void ApiStruct::init(const Trace::Struct *s)
 
     m_sig.name = QString::fromStdString(s->sig->name);
     for (unsigned i = 0; i < s->sig->num_members; ++i) {
-        VariantVisitor vis;
+        VariantVisitor vis(0);
         m_sig.memberNames.append(
             QString::fromStdString(s->sig->member_names[i]));
         s->members[i]->visit(vis);
@@ -396,8 +418,9 @@ void ApiArray::init(const Trace::Array *arr)
     if (!arr)
         return;
 
+    m_array.reserve(arr->values.size());
     for (int i = 0; i < arr->values.size(); ++i) {
-        VariantVisitor vis;
+        VariantVisitor vis(0);
         arr->values[i]->visit(vis);
 
         m_array.append(vis.variant());
@@ -534,41 +557,50 @@ void ApiTraceCallSignature::setHelpUrl(const QUrl &url)
 
 ApiTraceEvent::ApiTraceEvent()
     : m_type(ApiTraceEvent::None),
+      m_hasBinaryData(false),
+      m_binaryDataIndex(0),
+      m_state(0),
       m_staticText(0)
 {
 }
 
 ApiTraceEvent::ApiTraceEvent(Type t)
     : m_type(t),
+      m_hasBinaryData(false),
+      m_binaryDataIndex(0),
+      m_state(0),
       m_staticText(0)
 {
 }
 
 ApiTraceEvent::~ApiTraceEvent()
 {
+    delete m_state;
     delete m_staticText;
 }
 
 QVariantMap ApiTraceEvent::stateParameters() const
 {
-    return m_state.parameters();
+    if (m_state) {
+        return m_state->parameters();
+    } else {
+        return QVariantMap();
+    }
 }
 
-ApiTraceState ApiTraceEvent::state() const
+ApiTraceState *ApiTraceEvent::state() const
 {
     return m_state;
 }
 
-void ApiTraceEvent::setState(const ApiTraceState &state)
+void ApiTraceEvent::setState(ApiTraceState *state)
 {
     m_state = state;
 }
 
 ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *call)
     : ApiTraceEvent(ApiTraceEvent::Call),
-      m_parentFrame(parentFrame),
-      m_hasBinaryData(false),
-      m_binaryDataIndex(0)
+      m_parentFrame(parentFrame)
 {
     ApiTrace *trace = parentTrace();
 
@@ -576,26 +608,26 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *call)
 
     m_index = call->no;
 
-    QString name = QString::fromStdString(call->sig->name);
-    m_signature = trace->signature(name);
+    m_signature = trace->signature(call->sig->id);
 
     if (!m_signature) {
+        QString name = QString::fromStdString(call->sig->name);
         QStringList argNames;
         argNames.reserve(call->sig->num_args);
         for (int i = 0; i < call->sig->num_args; ++i) {
             argNames += QString::fromStdString(call->sig->arg_names[i]);
         }
         m_signature = new ApiTraceCallSignature(name, argNames);
-        trace->addSignature(m_signature);
+        trace->addSignature(call->sig->id, m_signature);
     }
     if (call->ret) {
-        VariantVisitor retVisitor;
+        VariantVisitor retVisitor(trace);
         call->ret->visit(retVisitor);
         m_returnValue = retVisitor.variant();
     }
     m_argValues.reserve(call->args.size());
     for (int i = 0; i < call->args.size(); ++i) {
-        VariantVisitor argVisitor;
+        VariantVisitor argVisitor(trace);
         call->args[i]->visit(argVisitor);
         m_argValues.append(argVisitor.variant());
         if (m_argValues[i].type() == QVariant::ByteArray) {
@@ -947,7 +979,7 @@ void ApiTraceFrame::addCall(ApiTraceCall *call)
     }
 }
 
-QList<ApiTraceCall*> ApiTraceFrame::calls() const
+QVector<ApiTraceCall*> ApiTraceFrame::calls() const
 {
     return m_calls;
 }
@@ -971,3 +1003,10 @@ int ApiTraceFrame::binaryDataSize() const
 {
     return m_binaryDataSize;
 }
+
+void ApiTraceFrame::setCalls(const QVector<ApiTraceCall*> &calls,
+                             quint64 binaryDataSize)
+{
+    m_calls = calls;
+    m_binaryDataSize = binaryDataSize;
+}