X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=trace_snappyfile.cpp;h=4dbe42dc364264a8db0e717a1af17681b9af271e;hb=3176ebeffe825a5f998b13755c09cfa312b0e8d3;hp=7678401b80fc818eb40b0ba8feeee3c95cddacb3;hpb=8263960b845d1b8fa57465953a00fa7fb85b1d28;p=apitrace

diff --git a/trace_snappyfile.cpp b/trace_snappyfile.cpp
index 7678401..4dbe42d 100644
--- a/trace_snappyfile.cpp
+++ b/trace_snappyfile.cpp
@@ -28,6 +28,8 @@
 
 #include <snappy.h>
 
+#include <iostream>
+
 #include <assert.h>
 #include <string.h>
 
@@ -91,13 +93,17 @@ bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
 
     //read in the initial buffer if we're reading
     if (m_stream.is_open() && mode == File::Read) {
+        m_stream.seekg(0, std::ios::end);
+        m_endPos = m_stream.tellg();
+        m_stream.seekg(0, std::ios::beg);
+
         // read the snappy file identifier
         unsigned char byte1, byte2;
         m_stream >> byte1;
         m_stream >> byte2;
         assert(byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2);
 
-        flushCache();
+        flushReadCache();
     } else if (m_stream.is_open() && mode == File::Write) {
         // write the snappy file identifier
         m_stream << SNAPPY_BYTE1;
@@ -114,7 +120,7 @@ bool SnappyFile::rawWrite(const void *buffer, size_t length)
     } else if (freeCacheSize() == length) {
         memcpy(m_cachePtr, buffer, length);
         m_cachePtr += length;
-        flushCache();
+        flushWriteCache();
     } else {
         int sizeToWrite = length;
 
@@ -124,7 +130,7 @@ bool SnappyFile::rawWrite(const void *buffer, size_t length)
             memcpy(m_cachePtr, (const char*)buffer + offset, endSize);
             sizeToWrite -= endSize;
             m_cachePtr += endSize;
-            flushCache();
+            flushWriteCache();
         }
         if (sizeToWrite) {
             int offset = length - sizeToWrite;
@@ -154,10 +160,12 @@ bool SnappyFile::rawRead(void *buffer, size_t length)
             memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
             m_cachePtr += chunkSize;
             sizeToRead -= chunkSize;
-            if (sizeToRead > 0)
-                flushCache();
-            if (!m_cacheSize)
+            if (sizeToRead > 0) {
+                flushReadCache();
+            }
+            if (!m_cacheSize) {
                 break;
+            }
         }
     }
 
@@ -174,7 +182,9 @@ int SnappyFile::rawGetc()
 
 void SnappyFile::rawClose()
 {
-    flushCache();
+    if (m_mode == File::Write) {
+        flushWriteCache();
+    }
     m_stream.close();
     delete [] m_cache;
     m_cache = NULL;
@@ -183,36 +193,46 @@ void SnappyFile::rawClose()
 
 void SnappyFile::rawFlush()
 {
-    flushCache();
+    assert(m_mode == File::Write);
+    flushWriteCache();
     m_stream.flush();
 }
 
-void SnappyFile::flushCache()
+void SnappyFile::flushWriteCache()
 {
-    if (m_mode == File::Write) {
+    size_t inputLength = usedCacheSize();
+
+    if (inputLength) {
         size_t compressedLength;
 
-        ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(),
+        ::snappy::RawCompress(m_cache, inputLength,
                               m_compressedCache, &compressedLength);
 
         writeCompressedLength(compressedLength);
         m_stream.write(m_compressedCache, compressedLength);
         m_cachePtr = m_cache;
-    } else if (m_mode == File::Read) {
-        //assert(m_cachePtr == m_cache + m_cacheSize);
-        size_t compressedLength;
-        compressedLength = readCompressedLength();
+    }
+    assert(m_cachePtr == m_cache);
+}
 
-        if (compressedLength) {
-            m_stream.read((char*)m_compressedCache, compressedLength);
-            ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
-                                            &m_cacheSize);
-            createCache(m_cacheSize);
+void SnappyFile::flushReadCache(size_t skipLength)
+{
+    //assert(m_cachePtr == m_cache + m_cacheSize);
+    m_currentOffset.chunk = m_stream.tellg();
+    size_t compressedLength;
+    compressedLength = readCompressedLength();
+
+    if (compressedLength) {
+        m_stream.read((char*)m_compressedCache, compressedLength);
+        ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
+                                        &m_cacheSize);
+        createCache(m_cacheSize);
+        if (skipLength < m_cacheSize) {
             ::snappy::RawUncompress(m_compressedCache, compressedLength,
                                     m_cache);
-        } else {
-            createCache(0);
         }
+    } else {
+        createCache(0);
     }
 }
 
@@ -260,3 +280,59 @@ size_t SnappyFile::readCompressedLength()
     }
     return length;
 }
+
+bool SnappyFile::supportsOffsets() const
+{
+    return true;
+}
+
+File::Offset SnappyFile::currentOffset()
+{
+    m_currentOffset.offsetInChunk = m_cachePtr - m_cache;
+    return m_currentOffset;
+}
+
+void SnappyFile::setCurrentOffset(const File::Offset &offset)
+{
+    // to remove eof bit
+    m_stream.clear();
+    // seek to the start of a chunk
+    m_stream.seekg(offset.chunk, std::ios::beg);
+    // load the chunk
+    flushReadCache();
+    assert(m_cacheSize >= offset.offsetInChunk);
+    // seek within our cache to the correct location within the chunk
+    m_cachePtr = m_cache + offset.offsetInChunk;
+
+}
+
+bool SnappyFile::rawSkip(size_t length)
+{
+    if (endOfData()) {
+        return false;
+    }
+
+    if (freeCacheSize() >= length) {
+        m_cachePtr += length;
+    } else {
+        size_t sizeToRead = length;
+        while (sizeToRead) {
+            size_t chunkSize = std::min(freeCacheSize(), sizeToRead);
+            m_cachePtr += chunkSize;
+            sizeToRead -= chunkSize;
+            if (sizeToRead > 0) {
+                flushReadCache(sizeToRead);
+            }
+            if (!m_cacheSize) {
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+int SnappyFile::rawPercentRead()
+{
+    return 100 * (double(m_stream.tellg()) / double(m_endPos));
+}