Encapsulate on parser state in structure.

So that parser users don't need to know what needs and needs not to be
saved/restored.

diff --git a/gui/traceloader.cpp b/gui/traceloader.cpp
index 77e8750e2a5cfd5eb61462aef782eaca502b284e..a6ffd2978709a11d61c0323b9e687e34421c1520 100644 (file)
--- a/gui/traceloader.cpp
+++ b/gui/traceloader.cpp
@@ -63,10 +63,9 @@ void TraceLoader::loadFrame(ApiTraceFrame *currentFrame)
         if (numOfCalls) {
             quint64 binaryDataSize = 0;
             QVector<ApiTraceCall*> calls(numOfCalls);
-            const FrameOffset &frameOffset = m_frameOffsets[frameIdx];
+            const FrameBookmark &frameBookmark = m_frameBookmarks[frameIdx];
 
-            m_parser.setCurrentOffset(frameOffset.start);
-            m_parser.setCurrentCallNumber(frameOffset.callNumber);
+            m_parser.setBookmark(frameBookmark.start);
 
             Trace::Call *call;
             int parsedCalls = 0;
@@ -132,16 +131,16 @@ bool TraceLoader::isCallAFrameMarker(const Trace::Call *call) const
 
 int TraceLoader::numberOfFrames() const
 {
-    return m_frameOffsets.size();
+    return m_frameBookmarks.size();
 }
 
 int TraceLoader::numberOfCallsInFrame(int frameIdx) const
 {
-    if (frameIdx > m_frameOffsets.size()) {
+    if (frameIdx > m_frameBookmarks.size()) {
         return 0;
     }
-    FrameOffsets::const_iterator itr =
-            m_frameOffsets.find(frameIdx);
+    FrameBookmarks::const_iterator itr =
+            m_frameBookmarks.find(frameIdx);
     return itr->numberOfCalls;
 }
 
@@ -170,55 +169,49 @@ void TraceLoader::scanTrace()
     ApiTraceFrame *currentFrame = 0;
 
     Trace::Call *call;
-    Trace::File::Offset startOffset;
+    Trace::ParseBookmark startBookmark;
     int numOfFrames = 0;
     int numOfCalls = 0;
-    unsigned callNum = 0;
     int lastPercentReport = 0;
 
-    startOffset = m_parser.currentOffset();
-    callNum = m_parser.currentCallNumber();
+    m_parser.getBookmark(startBookmark);
 
     while ((call = m_parser.scan_call())) {
         ++numOfCalls;
 
         if (isCallAFrameMarker(call)) {
-            Trace::File::Offset endOffset = m_parser.currentOffset();
-            FrameOffset frameOffset(startOffset);
-            frameOffset.numberOfCalls = numOfCalls;
-            frameOffset.callNumber = callNum;
+            FrameBookmark frameBookmark(startBookmark);
+            frameBookmark.numberOfCalls = numOfCalls;
 
             currentFrame = new ApiTraceFrame();
             currentFrame->number = numOfFrames;
             currentFrame->setNumChildren(numOfCalls);
             frames.append(currentFrame);
 
-            m_frameOffsets[numOfFrames] = frameOffset;
+            m_frameBookmarks[numOfFrames] = frameBookmark;
             ++numOfFrames;
 
             if (m_parser.percentRead() - lastPercentReport >= 5) {
                 emit parsed(m_parser.percentRead());
                 lastPercentReport = m_parser.percentRead();
             }
-            startOffset = endOffset;
-            callNum = m_parser.currentCallNumber();
+            m_parser.getBookmark(startBookmark);
             numOfCalls = 0;
         }
         delete call;
     }
 
     if (numOfCalls) {
-        //Trace::File::Offset endOffset = m_parser.currentOffset();
-        FrameOffset frameOffset(startOffset);
-        frameOffset.numberOfCalls = numOfCalls;
-        frameOffset.callNumber = callNum;
+        //Trace::File::Bookmark endBookmark = m_parser.currentBookmark();
+        FrameBookmark frameBookmark(startBookmark);
+        frameBookmark.numberOfCalls = numOfCalls;
 
         currentFrame = new ApiTraceFrame();
         currentFrame->number = numOfFrames;
         currentFrame->setNumChildren(numOfCalls);
         frames.append(currentFrame);
 
-        m_frameOffsets[numOfFrames] = frameOffset;
+        m_frameBookmarks[numOfFrames] = frameBookmark;
         ++numOfFrames;
     }
 

diff --git a/gui/traceloader.h b/gui/traceloader.h
index 791a19c8f3fc68bc5c0bd0cbc3832cc56743d020..86b7526348eef15ed99c4f4468b96332b8d727a4 100644 (file)
--- a/gui/traceloader.h
+++ b/gui/traceloader.h
@@ -38,18 +38,17 @@ signals:
     void frameLoaded(ApiTraceFrame *frame);
 
 private:
-    struct FrameOffset {
-        FrameOffset()
+    struct FrameBookmark {
+        FrameBookmark()
             : numberOfCalls(0)
         {}
-        FrameOffset(const Trace::File::Offset &s)
+        FrameBookmark(const Trace::ParseBookmark &s)
             : start(s),
               numberOfCalls(0)
         {}
 
-        Trace::File::Offset start;
+        Trace::ParseBookmark start;
         int numberOfCalls;
-        unsigned callNumber;
     };
     bool isCallAFrameMarker(const Trace::Call *call) const;
     int numberOfFrames() const;
@@ -64,8 +63,8 @@ private:
     QString m_fileName;
     ApiTrace::FrameMarker m_frameMarker;
 
-    typedef QMap<int, FrameOffset> FrameOffsets;
-    FrameOffsets m_frameOffsets;
+    typedef QMap<int, FrameBookmark> FrameBookmarks;
+    FrameBookmarks m_frameBookmarks;
 
     QHash<QString, QUrl> m_helpHash;
 

diff --git a/trace_loader.cpp b/trace_loader.cpp
index c16e59e33c2fd6f0f0658c48e93ab9c3eb709a66..c14d815382b4680b5b13eac008df33c828e6d8a7 100644 (file)
--- a/trace_loader.cpp
+++ b/trace_loader.cpp
@@ -25,16 +25,16 @@ void Loader::setFrameMarker(Loader::FrameMarker marker)
 
 int Loader::numberOfFrames() const
 {
-    return m_frameOffsets.size();
+    return m_frameBookmarks.size();
 }
 
 int Loader::numberOfCallsInFrame(int frameIdx) const
 {
-    if (frameIdx > m_frameOffsets.size()) {
+    if (frameIdx > m_frameBookmarks.size()) {
         return 0;
     }
-    FrameOffsets::const_iterator itr =
-        m_frameOffsets.find(frameIdx);
+    FrameBookmarks::const_iterator itr =
+        m_frameBookmarks.find(frameIdx);
     return itr->second.numberOfCalls;
 }
 
@@ -51,25 +51,21 @@ bool Loader::open(const char *filename)
     }
 
     Trace::Call *call;
-    File::Offset startOffset;
+    ParseBookmark startBookmark;
     int numOfFrames = 0;
     int numOfCalls = 0;
-    unsigned callNum = 0;
     int lastPercentReport = 0;
 
-    startOffset = m_parser.currentOffset();
-    callNum = m_parser.currentCallNumber();
+    m_parser.getBookmark(startBookmark);
 
     while ((call = m_parser.scan_call())) {
         ++numOfCalls;
 
         if (isCallAFrameMarker(call)) {
-            File::Offset endOffset = m_parser.currentOffset();
-            FrameOffset frameOffset(startOffset);
-            frameOffset.numberOfCalls = numOfCalls;
-            frameOffset.callNumber = callNum;
+            FrameBookmark frameBookmark(startBookmark);
+            frameBookmark.numberOfCalls = numOfCalls;
 
-            m_frameOffsets[numOfFrames] = frameOffset;
+            m_frameBookmarks[numOfFrames] = frameBookmark;
             ++numOfFrames;
 
             if (m_parser.percentRead() - lastPercentReport >= 5) {
@@ -78,8 +74,8 @@ bool Loader::open(const char *filename)
                           << "..."<<std::endl;
                 lastPercentReport = m_parser.percentRead();
             }
-            startOffset = endOffset;
-            callNum = m_parser.currentCallNumber();
+            
+            m_parser.getBookmark(startBookmark);
             numOfCalls = 0;
         }
         //call->dump(std::cout, color);
@@ -120,10 +116,9 @@ std::vector<Trace::Call *> Loader::frame(int idx)
 {
     int numOfCalls = numberOfCallsInFrame(idx);
     if (numOfCalls) {
-        const FrameOffset &frameOffset = m_frameOffsets[idx];
+        const FrameBookmark &frameBookmark = m_frameBookmarks[idx];
         std::vector<Trace::Call*> calls(numOfCalls);
-        m_parser.setCurrentOffset(frameOffset.start);
-        m_parser.setCurrentCallNumber(frameOffset.callNumber);
+        m_parser.setBookmark(frameBookmark.start);
 
         Trace::Call *call;
         int parsedCalls = 0;

diff --git a/trace_loader.hpp b/trace_loader.hpp
index 86a56bdd0cbf72c210500703b55ee8f270bf6fd3..9f74a9bde8e967d6de3e08a740bed1ce366a688b 100644 (file)
--- a/trace_loader.hpp
+++ b/trace_loader.hpp
@@ -38,18 +38,17 @@ public:
     std::vector<Trace::Call*> frame(int idx);
 
 private:
-    struct FrameOffset {
-        FrameOffset()
+    struct FrameBookmark {
+        FrameBookmark()
             : numberOfCalls(0)
         {}
-        FrameOffset(const File::Offset &s)
+        FrameBookmark(const ParseBookmark &s)
             : start(s),
               numberOfCalls(0)
         {}
 
-        File::Offset start;
+        ParseBookmark start;
         int numberOfCalls;
-        unsigned callNumber;
     };
     bool isCallAFrameMarker(const Trace::Call *call) const;
 
@@ -57,8 +56,8 @@ private:
     Trace::Parser m_parser;
     FrameMarker m_frameMarker;
 
-    typedef std::map<int, FrameOffset> FrameOffsets;
-    FrameOffsets m_frameOffsets;
+    typedef std::map<int, FrameBookmark> FrameBookmarks;
+    FrameBookmarks m_frameBookmarks;
 };
 
 }

diff --git a/trace_parser.hpp b/trace_parser.hpp
index 962c323d4d9ef379e8a0c074bf3962fcd813fc9d..d76ffb49868e208b21a59890cd5109c2905e6c58 100644 (file)
--- a/trace_parser.hpp
+++ b/trace_parser.hpp
@@ -37,6 +37,14 @@
 
 namespace Trace {
 
+
+struct ParseBookmark
+{
+    File::Offset offset;
+    unsigned next_call_no;
+};
+
+
 class Parser
 {
 protected:
@@ -92,24 +100,14 @@ public:
         return file->supportsOffsets();
     }
 
-    File::Offset currentOffset()
-    {
-        return file->currentOffset();
-    }
-
-    void setCurrentOffset(const File::Offset &offset)
-    {
-        file->setCurrentOffset(offset);
+    void getBookmark(ParseBookmark &bookmark) {
+        bookmark.offset = file->currentOffset();
+        bookmark.next_call_no = next_call_no;
     }
 
-    unsigned currentCallNumber() const
-    {
-        return next_call_no;
-    }
-
-    void setCurrentCallNumber(unsigned num)
-    {
-        next_call_no = num;
+    void setBookmark(const ParseBookmark &bookmark) {
+        file->setCurrentOffset(bookmark.offset);
+        next_call_no = bookmark.next_call_no;
     }
 
     int percentRead()