Merge branch 'master' into on-demand-loading

Conflicts:
	trace_snappyfile.cpp

diff --cc trace_file.hpp
Simple merge

diff --cc trace_snappyfile.cpp
index cea4e68,6a60441..db20abb
--- 1/trace_snappyfile.cpp
--- 2/trace_snappyfile.cpp
+++ b/trace_snappyfile.cpp
@@@ -189,38 -192,38 +194,39 @@@ void SnappyFile::rawFlush(
      m_stream.flush();
  }
  
- void SnappyFile::flushCache()
+ void SnappyFile::flushWriteCache()
  {
-     if (m_mode == File::Write) {
-         size_t inputLength = usedCacheSize();
+     size_t inputLength = usedCacheSize();
  
-         if (inputLength) {
-             size_t compressedLength;
+     if (inputLength) {
+         size_t compressedLength;
  
-             ::snappy::RawCompress(m_cache, inputLength,
-                                   m_compressedCache, &compressedLength);
+         ::snappy::RawCompress(m_cache, inputLength,
+                               m_compressedCache, &compressedLength);
  
-             writeCompressedLength(compressedLength);
-             m_stream.write(m_compressedCache, compressedLength);
-             m_cachePtr = m_cache;
-         }
-         assert(m_cachePtr == m_cache);
-     } else if (m_mode == File::Read) {
-         //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);
-             ::snappy::RawUncompress(m_compressedCache, compressedLength,
-                                     m_cache);
-         } else {
-             createCache(0);
-         }
+         writeCompressedLength(compressedLength);
+         m_stream.write(m_compressedCache, compressedLength);
+         m_cachePtr = m_cache;
+     }
+     assert(m_cachePtr == m_cache);
+ }
+ 
+ void SnappyFile::flushReadCache()
+ {
+     //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);
+         ::snappy::RawUncompress(m_compressedCache, compressedLength,
+                                 m_cache);
+     } else {
+         createCache(0);
      }
  }
  
@@@ -268,52 -271,3 +274,54 @@@ size_t SnappyFile::readCompressedLength
      }
      return length;
  }
-     flushCache();
 +
 +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
-             if (sizeToRead > 0)
-                 flushCache();
-             if (!m_cacheSize)
++    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(unsigned 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();
++            }
++            if (!m_cacheSize) {
 +                break;
++            }
 +        }
 +    }
 +
 +    return true;
 +}

diff --cc trace_snappyfile.hpp
Simple merge