That's what the C/STL/zlib/snappy ends up using so it avoids needless casting.
return m_gzFile != NULL;
}
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;
}
{
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;
}
{
return gzread(m_gzFile, buffer, length) != -1;
}
std::string filename() const;
bool open(const std::string &filename, File::Mode mode);
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;
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;
virtual int rawGetc() = 0;
virtual void rawClose() = 0;
virtual void rawFlush() = 0;
-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;
{
if (!m_isOpened || m_mode != File::Write) {
return false;
return rawWrite(buffer, 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;
{
if (!m_isOpened || m_mode != File::Read) {
return false;
protected:
virtual bool rawOpen(const std::string &filename, File::Mode mode);
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 int rawGetc();
virtual void rawClose();
virtual void rawFlush();
#include <assert.h>
#include <string.h>
#include <assert.h>
#include <string.h>
return m_stream.is_open();
}
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);
{
if (freeCacheSize() > length) {
memcpy(m_cachePtr, buffer, length);
while (sizeToWrite >= freeCacheSize()) {
int endSize = freeCacheSize();
int offset = length - sizeToWrite;
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;
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;
}
}
m_cachePtr += sizeToWrite;
}
}
-bool SnappyFile::rawRead(void *buffer, int length)
+bool SnappyFile::rawRead(void *buffer, size_t length)
{
if (endOfData()) {
return false;
{
if (endOfData()) {
return false;
memcpy(buffer, m_cachePtr, length);
m_cachePtr += length;
} else {
memcpy(buffer, m_cachePtr, length);
m_cachePtr += length;
} else {
- int sizeToRead = length;
- int offset = 0;
+ size_t sizeToRead = length;
+ size_t offset = 0;
- 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;
offset = length - sizeToRead;
memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
m_cachePtr += chunkSize;
-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);
}
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;
#include <string>
#include <fstream>
#include <string>
#include <fstream>
namespace snappy {
class File;
}
namespace snappy {
class File;
}
protected:
virtual bool rawOpen(const std::string &filename, File::Mode mode);
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:
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);
{
if (m_cacheSize > 0)
return m_cacheSize - (m_cachePtr - m_cache);
}
void flushCache();
void createCache(size_t size);
}
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;
private:
std::fstream m_stream;
char *m_cache;