Merge remote-tracking branch 'origin/master' into on-demand-loading

diff --cc trace_file.cpp
Simple merge

diff --cc trace_file.hpp
index 13b392cdaa8876729791fb641a2e1f747f2dca8b,c709050d6ab96371a957a818bddffc52389951d4..487121187fdd9dad368fe631445b3ffea218a80e
--- 1/trace_file.hpp
--- 2/trace_file.hpp
+++ b/trace_file.hpp
@@@ -67,15 -57,11 +67,15 @@@ public
      void close();
      void flush(void);
      int getc();
 +    bool skip(unsigned length);
  
 +    virtual bool supportsOffsets() const = 0;
 +    virtual File::Offset currentOffset();
 +    virtual void setCurrentOffset(const File::Offset &offset);
  protected:
      virtual bool rawOpen(const std::string &filename, File::Mode mode) = 0;
-     virtual bool rawWrite(const void *buffer, int length) = 0;
-     virtual bool rawRead(void *buffer, int length) = 0;
+     virtual bool rawWrite(const void *buffer, size_t length) = 0;
+     virtual bool rawRead(void *buffer, size_t length) = 0;
      virtual int rawGetc() = 0;
      virtual void rawClose() = 0;
      virtual void rawFlush() = 0;
@@@ -164,12 -141,10 +164,12 @@@ public
               File::Mode mode = File::Read);
      virtual ~ZLibFile();
  
 +
 +    virtual bool supportsOffsets() const;
  protected:
      virtual bool rawOpen(const std::string &filename, File::Mode mode);
-     virtual bool rawWrite(const void *buffer, int length);
-     virtual bool rawRead(void *buffer, int length);
+     virtual bool rawWrite(const void *buffer, size_t length);
+     virtual bool rawRead(void *buffer, size_t length);
      virtual int rawGetc();
      virtual void rawClose();
      virtual void rawFlush();

diff --cc trace_snappyfile.cpp
index 443ebe7c5040c131bf7eef72daeb84ace273b98b,7e7072543426851c125257d2c9d0b5e0367e3e86..c350013d7f1acc7e7ff1546fa860019f94d47762
--- 1/trace_snappyfile.cpp
--- 2/trace_snappyfile.cpp
+++ b/trace_snappyfile.cpp
@@@ -191,37 -190,34 +192,35 @@@ void SnappyFile::rawFlush(
  void SnappyFile::flushCache()
  {
      if (m_mode == File::Write) {
-         size_t compressedLength;
+         size_t inputLength = usedCacheSize();
  
-         ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(),
-                               m_compressedCache, &compressedLength);
+         if (inputLength) {
+             size_t compressedLength;
  
-         writeCompressedLength(compressedLength);
-         m_stream.write(m_compressedCache, compressedLength);
-         m_cachePtr = m_cache;
+             ::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) {
-         if (m_stream.eof())
-             return;
          //assert(m_cachePtr == m_cache + m_cacheSize);
 +        m_currentOffset.chunk = m_stream.tellg();
          size_t compressedLength;
          compressedLength = readCompressedLength();
-         m_stream.read((char*)m_compressedCache, compressedLength);
-         /*
-          * The reason we peek here is because the last read will
-          * read all the way until the last character, but that will not
-          * trigger m_stream.eof() to be set, so by calling peek
-          * we assure that if we in fact have read the entire stream
-          * then the m_stream.eof() is always set.
-          */
-         m_stream.peek();
-         ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
-                                         &m_cacheSize);
-         if (m_cache)
-             delete [] m_cache;
-         createCache(m_cacheSize);
-         ::snappy::RawUncompress(m_compressedCache, compressedLength,
-                                 m_cache);
+ 
+         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);
+         }
      }
  }
  
@@@ -232,63 -239,29 +242,78 @@@ void SnappyFile::createCache(size_t siz
      m_cacheSize = size;
  }
  
- void SnappyFile::writeCompressedLength(uint32_t value)
+ void SnappyFile::writeCompressedLength(size_t length)
  {
-     m_stream.write((const char*)&value, sizeof value);
+     unsigned char buf[4];
+     buf[0] = length & 0xff; length >>= 8;
+     buf[1] = length & 0xff; length >>= 8;
+     buf[2] = length & 0xff; length >>= 8;
+     buf[3] = length & 0xff; length >>= 8;
+     assert(length == 0);
+     m_stream.write((const char *)buf, sizeof buf);
  }
  
- uint32_t SnappyFile::readCompressedLength()
+ size_t SnappyFile::readCompressedLength()
  {
-     uint32_t len;
-     m_stream.read((char*)&len, sizeof len);
-     return len;
+     unsigned char buf[4];
+     size_t length;
+     m_stream.read((char *)buf, sizeof buf);
+     if (m_stream.fail()) {
+         length = 0;
+     } else {
+         length  =  (size_t)buf[0];
+         length |= ((size_t)buf[1] <<  8);
+         length |= ((size_t)buf[2] << 16);
+         length |= ((size_t)buf[3] << 24);
+     }
+     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
 +    flushCache();
 +    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 {
 +        int sizeToRead = length;
 +        while (sizeToRead) {
 +            int chunkSize = std::min(freeCacheSize(), sizeToRead);
 +            m_cachePtr += chunkSize;
 +            sizeToRead -= chunkSize;
 +            if (sizeToRead > 0)
 +                flushCache();
 +            if (!m_cacheSize)
 +                break;
 +        }
 +    }
 +
 +    return true;
 +}

diff --cc trace_snappyfile.hpp
index ecf39dedbe649a470f531aaba1bf56918812e797,61b7ab1b29435aeeb51c833a05958c82f3bcee32..398ff7900c335a4c7f3b55d8afe0e643c5651e49
--- 1/trace_snappyfile.hpp
--- 2/trace_snappyfile.hpp
+++ b/trace_snappyfile.hpp
@@@ -52,25 -52,28 +52,32 @@@ public
                 File::Mode mode = File::Read);
      virtual ~SnappyFile();
  
 +    virtual bool supportsOffsets() const;
 +    virtual File::Offset currentOffset();
 +    virtual void setCurrentOffset(const File::Offset &offset);
  protected:
      virtual bool rawOpen(const std::string &filename, File::Mode mode);
-     virtual bool rawWrite(const void *buffer, int length);
-     virtual bool rawRead(void *buffer, int length);
+     virtual bool rawWrite(const void *buffer, size_t length);
+     virtual bool rawRead(void *buffer, size_t length);
      virtual int rawGetc();
      virtual void rawClose();
      virtual void rawFlush();
 +    virtual bool rawSkip(unsigned length);
  
  private:
-     inline int freeCacheSize() const
+     inline size_t usedCacheSize() const
+     {
+         assert(m_cachePtr >= m_cache);
+         return m_cachePtr - m_cache;
+     }
+     inline size_t freeCacheSize() const
      {
-         if (m_cacheSize > 0)
-             return m_cacheSize - (m_cachePtr - m_cache);
-         else
+         assert(m_cacheSize >= usedCacheSize());
+         if (m_cacheSize > 0) {
+             return m_cacheSize - usedCacheSize();
+         } else {
              return 0;
+         }
      }
      inline bool endOfData() const
      {