Share enum signatures.

further reduces memory usage

diff --git a/gui/apitrace.cpp b/gui/apitrace.cpp
index a290006eff5c060d1712a57615b3bb92bf8e9c7d..723fad37be2918cac32d9a3ab2dcc4b4ae150deb 100644 (file)
--- a/gui/apitrace.cpp
+++ b/gui/apitrace.cpp
@@ -304,4 +304,19 @@ void ApiTrace::addSignature(unsigned id, ApiTraceCallSignature *signature)
     m_signatures[id] = signature;
 }
 
+ApiTraceEnumSignature * ApiTrace::enumSignature(unsigned id)
+{
+    if (id >= m_signatures.count()) {
+        m_enumSignatures.resize(id + 1);
+        return NULL;
+    } else {
+        return m_enumSignatures[id];
+    }
+}
+
+void ApiTrace::addEnumSignature(unsigned id, ApiTraceEnumSignature *signature)
+{
+    m_enumSignatures[id] = signature;
+}
+
 #include "apitrace.moc"

diff --git a/gui/apitrace.h b/gui/apitrace.h
index ba8e11b0243681b3848561cb250ffa4ca73591cc..e2c1451e733ff55d22cf47d600530fbb164a9efe 100644 (file)
--- a/gui/apitrace.h
+++ b/gui/apitrace.h
@@ -36,6 +36,10 @@ public:
     ApiTraceCallSignature *signature(unsigned id);
     void addSignature(unsigned id, ApiTraceCallSignature *signature);
 
+    ApiTraceEnumSignature *enumSignature(unsigned id);
+    void addEnumSignature(unsigned id, ApiTraceEnumSignature *signature);
+
+
     QList<ApiTraceCall*> calls() const;
     ApiTraceCall *callAt(int idx) const;
     ApiTraceCall *callWithIndex(int idx) const;
@@ -98,6 +102,7 @@ private:
 
     QSet<ApiTraceCall*> m_errors;
     QVector<ApiTraceCallSignature*> m_signatures;
+    QVector<ApiTraceEnumSignature*> m_enumSignatures;
 };
 
 #endif

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index 70794bc0ab9c35958eeac0058d5bf38224eee71d..ea1b3e2785e1a4293f2f09fa3dd99cc79a37597e 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);
@@ -398,7 +420,7 @@ void ApiArray::init(const Trace::Array *arr)
 
     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());
@@ -599,13 +621,13 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *call)
         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) {

diff --git a/gui/apitracecall.h b/gui/apitracecall.h
index 46e44b2e81eb1860dcb93dcff9dd2fc45993ca03..9d67febcf3f76ed327037f9c4c37ee80d974c945 100644 (file)
--- a/gui/apitracecall.h
+++ b/gui/apitracecall.h
@@ -16,6 +16,9 @@ class ApiTrace;
 class VariantVisitor : public Trace::Visitor
 {
 public:
+    VariantVisitor(ApiTrace *trace)
+        : m_trace(trace)
+    {}
     virtual void visit(Trace::Null *);
     virtual void visit(Trace::Bool *node);
     virtual void visit(Trace::SInt *node);
@@ -34,21 +37,37 @@ public:
         return m_variant;
     }
 private:
+    ApiTrace *m_trace;
     QVariant m_variant;
 };
 
+class ApiTraceEnumSignature
+{
+public:
+    ApiTraceEnumSignature(const QString &name = QString(),
+                          const QVariant &val=QVariant())\
+        : m_name(name),
+          m_value(val)
+    {}
+
+    QVariant value() const { return m_value; }
+    QString name() const { return m_name; }
+private:
+    QString m_name;
+    QVariant m_value;
+};
+
 class ApiEnum
 {
 public:
-    ApiEnum(const QString &name = QString(), const QVariant &val=QVariant());
+    ApiEnum(ApiTraceEnumSignature *sig=0);
 
     QString toString() const;
 
     QVariant value() const;
     QString name() const;
 private:
-    QString m_name;
-    QVariant m_value;
+    ApiTraceEnumSignature *m_sig;
 };
 Q_DECLARE_METATYPE(ApiEnum);