Always use size_t for length in files.

That's what the C/STL/zlib/snappy ends up using so it avoids needless casting.

diff --git a/trace_file.cpp b/trace_file.cpp
index e20685812c5c6230c9e6f582f7ea2441bf5dfede..81b5d03c1f3f273f972f7b8b3d9db8be22f53336 100644 (file)
--- a/trace_file.cpp
+++ b/trace_file.cpp
@@ -106,12 +106,12 @@ bool ZLibFile::rawOpen(const std::string &filename, File::Mode mode)
     return m_gzFile != NULL;
 }
 
-bool ZLibFile::rawWrite(const void *buffer, int length)
+bool ZLibFile::rawWrite(const void *buffer, size_t length)
 {
     return gzwrite(m_gzFile, buffer, length) != -1;
 }
 
-bool ZLibFile::rawRead(void *buffer, int length)
+bool ZLibFile::rawRead(void *buffer, size_t length)
 {
     return gzread(m_gzFile, buffer, length) != -1;
 }

diff --git a/trace_file.hpp b/trace_file.hpp
index 5a98f606ce32bb5f0204d4c614adae21cbe1c050..c709050d6ab96371a957a818bddffc52389951d4 100644 (file)
--- a/trace_file.hpp
+++ b/trace_file.hpp
@@ -52,16 +52,16 @@ public:
     std::string filename() const;
 
     bool open(const std::string &filename, File::Mode mode);
-    bool write(const void *buffer, int length);
-    bool read(void *buffer, int length);
+    bool write(const void *buffer, size_t length);
+    bool read(void *buffer, size_t length);
     void close();
     void flush(void);
     int getc();
 
 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;
@@ -98,7 +98,7 @@ inline bool File::open(const std::string &filename, File::Mode mode)
     return m_isOpened;
 }
 
-inline bool File::write(const void *buffer, int length)
+inline bool File::write(const void *buffer, size_t length)
 {
     if (!m_isOpened || m_mode != File::Write) {
         return false;
@@ -106,7 +106,7 @@ inline bool File::write(const void *buffer, int length)
     return rawWrite(buffer, length);
 }
 
-inline bool File::read(void *buffer, int length)
+inline bool File::read(void *buffer, size_t length)
 {
     if (!m_isOpened || m_mode != File::Read) {
         return false;
@@ -143,8 +143,8 @@ public:
 
 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 --git a/trace_snappyfile.cpp b/trace_snappyfile.cpp
index 5804c3bbb2dc76f9e731554329745ee56b7b53de..f8016856b31c0550e300e2a180a1b1fe32f56ff2 100644 (file)
--- a/trace_snappyfile.cpp
+++ b/trace_snappyfile.cpp
@@ -30,6 +30,7 @@
 
 #include <assert.h>
 #include <string.h>
+#include <stdint.h>
 
 using namespace Trace;
 
@@ -105,7 +106,7 @@ bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
     return m_stream.is_open();
 }
 
-bool SnappyFile::rawWrite(const void *buffer, int length)
+bool SnappyFile::rawWrite(const void *buffer, size_t length)
 {
     if (freeCacheSize() > length) {
         memcpy(m_cachePtr, buffer, length);
@@ -120,14 +121,14 @@ bool SnappyFile::rawWrite(const void *buffer, int length)
         while (sizeToWrite >= freeCacheSize()) {
             int endSize = freeCacheSize();
             int offset = length - sizeToWrite;
-            memcpy(m_cachePtr, (char*)buffer + offset, endSize);
+            memcpy(m_cachePtr, (const char*)buffer + offset, endSize);
             sizeToWrite -= endSize;
             m_cachePtr += endSize;
             flushCache();
         }
         if (sizeToWrite) {
             int offset = length - sizeToWrite;
-            memcpy(m_cachePtr, (char*)buffer + offset, sizeToWrite);
+            memcpy(m_cachePtr, (const char*)buffer + offset, sizeToWrite);
             m_cachePtr += sizeToWrite;
         }
     }
@@ -135,7 +136,7 @@ bool SnappyFile::rawWrite(const void *buffer, int length)
     return true;
 }
 
-bool SnappyFile::rawRead(void *buffer, int length)
+bool SnappyFile::rawRead(void *buffer, size_t length)
 {
     if (endOfData()) {
         return false;
@@ -145,10 +146,10 @@ bool SnappyFile::rawRead(void *buffer, int length)
         memcpy(buffer, m_cachePtr, length);
         m_cachePtr += length;
     } else {
-        int sizeToRead = length;
-        int offset = 0;
+        size_t sizeToRead = length;
+        size_t offset = 0;
         while (sizeToRead) {
-            int chunkSize = std::min(freeCacheSize(), sizeToRead);
+            size_t chunkSize = std::min(freeCacheSize(), sizeToRead);
             offset = length - sizeToRead;
             memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
             m_cachePtr += chunkSize;
@@ -229,14 +230,16 @@ void SnappyFile::createCache(size_t size)
     m_cacheSize = size;
 }
 
-void SnappyFile::writeCompressedLength(uint32_t value)
+void SnappyFile::writeCompressedLength(size_t length)
 {
+    uint32_t value = length;
+    assert(value == length);
     m_stream.write((const char*)&value, sizeof value);
 }
 
-uint32_t SnappyFile::readCompressedLength()
+size_t SnappyFile::readCompressedLength()
 {
-    uint32_t len;
-    m_stream.read((char*)&len, sizeof len);
-    return len;
+    uint32_t length = 0;
+    m_stream.read((char*)&length, sizeof length);
+    return length;
 }

diff --git a/trace_snappyfile.hpp b/trace_snappyfile.hpp
index c8c415bf57b47dacf0ee47e4138fdd6f25063ab0..393fe0255ebe7eb2447ff6721449db6511ef2b7a 100644 (file)
--- a/trace_snappyfile.hpp
+++ b/trace_snappyfile.hpp
@@ -32,8 +32,6 @@
 #include <string>
 #include <fstream>
 
-#include <stdint.h>
-
 namespace snappy {
     class File;
 }
@@ -54,14 +52,14 @@ public:
 
 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();
 
 private:
-    inline int freeCacheSize() const
+    inline size_t freeCacheSize() const
     {
         if (m_cacheSize > 0)
             return m_cacheSize - (m_cachePtr - m_cache);
@@ -74,8 +72,8 @@ private:
     }
     void flushCache();
     void createCache(size_t size);
-    void writeCompressedLength(uint32_t  num);
-    uint32_t readCompressedLength();
+    void writeCompressedLength(size_t length);
+    size_t readCompressedLength();
 private:
     std::fstream m_stream;
     char *m_cache;