Use size_t for sizes in I/O classes
authorMikko Rasa <tdb@tdb.fi>
Sun, 29 Aug 2021 08:54:20 +0000 (11:54 +0300)
committerMikko Rasa <tdb@tdb.fi>
Sun, 29 Aug 2021 22:42:03 +0000 (01:42 +0300)
20 files changed:
source/fs/unix/filemonitor.cpp
source/fs/unix/filemonitor_platform.h
source/io/base.h
source/io/buffered.cpp
source/io/buffered.h
source/io/console.cpp
source/io/console.h
source/io/file.cpp
source/io/file.h
source/io/handle.h
source/io/memory.cpp
source/io/memory.h
source/io/pipe.cpp
source/io/pipe.h
source/io/slice.cpp
source/io/slice.h
source/io/unix/handle.cpp
source/io/windows/handle.cpp
source/io/zlibcompressed.cpp
source/io/zlibcompressed.h

index 70cfc4ec4b524e432a529aba08d6cacd366b5499..68cd7aebda419752bfcab37f51f451421a185049 100644 (file)
@@ -36,13 +36,13 @@ void INotify::remove_watch(int wd)
                throw system_error("inotify_rm_watch");
 }
 
-unsigned INotify::do_write(const char *, unsigned)
+size_t INotify::do_write(const char *, size_t)
 {
        check_access(IO::M_WRITE);
        return 0;
 }
 
-unsigned INotify::do_read(char *buf, unsigned size)
+size_t INotify::do_read(char *buf, size_t size)
 {
        return IO::sys_read(fd, buf, size);
 }
index 31b728ffd81b5ff56219aaf7ca8849b3aed34c9c..ed900bfeb7a2faa49f79197a5b9126719b546977 100644 (file)
@@ -20,8 +20,8 @@ public:
        virtual void set_inherit(bool) { }
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 
 public:
        virtual const IO::Handle &get_handle(IO::Mode) { return fd; }
index b6d1ff65a2a83f1b793d10fb5a4d36fd9f966efa..7bd5bd9e963a4be383f2407a50fdf8a6f1c07d3e 100644 (file)
@@ -1,6 +1,7 @@
 #ifndef MSP_IO_BASE_H_
 #define MSP_IO_BASE_H_
 
+#include <cstddef>
 #include <sigc++/sigc++.h>
 #include <msp/core/mutex.h>
 #include <msp/core/noncopyable.h>
@@ -69,25 +70,25 @@ public:
 protected:
        void check_access(Mode) const;
 
-       virtual unsigned do_write(const char *, unsigned) = 0;
-       virtual unsigned do_read(char *, unsigned) = 0;
+       virtual std::size_t do_write(const char *, std::size_t) = 0;
+       virtual std::size_t do_read(char *, std::size_t) = 0;
 
 public:
        /** Writes data from a buffer.  Subject to blocking.  Returns the number of
        bytes written, which may be zero for a non-blockin operation. */
-       unsigned write(const char *b, unsigned c) { return do_write(b, c); }
+       std::size_t write(const char *b, std::size_t c) { return do_write(b, c); }
 
        /** Writes a string.  This is identical to calling
        write(s.data(), s.size()). */
-       unsigned write(const std::string &s) { return do_write(s.data(), s.size()); }
+       std::size_t write(const std::string &s) { return do_write(s.data(), s.size()); }
 
        /** Writes a single character.  This is identical to calling
        write(&c, 1). */
-       virtual unsigned put(char c) { return do_write(&c, 1); }
+       virtual std::size_t put(char c) { return do_write(&c, 1); }
 
        /** Reads data into a buffer.  Subject to blocking.  Returns the number of
        bytes read, which may be zero for a non-blocking operation. */
-       unsigned read(char *b, unsigned c) { return do_read(b, c); }
+       std::size_t read(char *b, std::size_t c) { return do_read(b, c); }
 
        /** Reads characters up to the next linefeed or end-of-file.  The linefeed
        is not included in the line.  Returns true if a line was successfully read,
index 2836e4bbbaeb879de07be26bf5fba2ecea8fcad9..55c69a635cf69d0a6b8f41b0f2eec67a028b16e7 100644 (file)
@@ -61,7 +61,7 @@ void Buffered::flush()
                begin = end = buf;
 }
 
-unsigned Buffered::do_write(const char *data, unsigned size)
+size_t Buffered::do_write(const char *data, size_t size)
 {
        set_op(M_WRITE);
 
@@ -92,7 +92,7 @@ unsigned Buffered::do_write(const char *data, unsigned size)
        }
 }
 
-unsigned Buffered::do_read(char *data, unsigned size)
+size_t Buffered::do_read(char *data, size_t size)
 {
        set_op(M_READ);
 
@@ -110,7 +110,7 @@ unsigned Buffered::do_read(char *data, unsigned size)
        {
                // Give out whatever is in the buffer already
                memcpy(data, begin, end-begin);
-               unsigned ret = end-begin;
+               size_t ret = end-begin;
                begin = end = buf;
 
                data += ret;
@@ -119,10 +119,10 @@ unsigned Buffered::do_read(char *data, unsigned size)
                if(size<buf_size)
                {
                        // Fill the buffer and serve the rest of the request from it
-                       unsigned len = below.read(end, buf+buf_size-end);
+                       size_t len = below.read(end, buf+buf_size-end);
                        end += len;
 
-                       len = min(static_cast<unsigned>(end-begin), size);
+                       len = min<size_t>(end-begin, size);
                        memcpy(data, begin, len);
                        begin += len;
                        ret += len;
@@ -137,7 +137,7 @@ unsigned Buffered::do_read(char *data, unsigned size)
        }
 }
 
-unsigned Buffered::put(char c)
+size_t Buffered::put(char c)
 {
        set_op(M_WRITE);
 
@@ -190,7 +190,7 @@ void Buffered::set_op(Mode op)
        cur_op = op;
 }
 
-unsigned Buffered::get_current_size() const
+size_t Buffered::get_current_size() const
 {
        return end-begin;
 }
index da917e0c5a6585027a469ad4fa5dc814db517c29..cd742fee291ea4614c6f0a1d8190bb1d67bbfa49 100644 (file)
@@ -11,7 +11,7 @@ class Buffered: public Base, public sigc::trackable
 {
 private:
        Base &below;
-       unsigned buf_size;
+       std::size_t buf_size;
        char *buf;
        char *begin;
        char *end;
@@ -27,10 +27,10 @@ public:
        void flush();
 
 protected:
-       unsigned do_write(const char *, unsigned);
-       unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 public:
-       unsigned put(char);
+       virtual std::size_t put(char);
 
        bool getline(std::string &);
        int get();
@@ -41,7 +41,7 @@ private:
        void set_op(Mode);
 public:
        Mode get_current_op() const { return cur_op; }
-       unsigned get_current_size() const;
+       std::size_t get_current_size() const;
 };
 
 } // namespace IO
index a7417edcee8f186263c965363f4942d9b1f82768..abb872d12e41c915a3876250abe340ddec13bf52 100644 (file)
@@ -28,18 +28,18 @@ void Console::set_inherit(bool i)
        sys_set_inherit(handle, i);
 }
 
-unsigned Console::do_write(const char *buf, unsigned len)
+size_t Console::do_write(const char *buf, size_t len)
 {
        check_access(M_WRITE);
 
        return sys_write(handle, buf, len);
 }
 
-unsigned Console::do_read(char *buf, unsigned len)
+size_t Console::do_read(char *buf, size_t len)
 {
        check_access(M_READ);
 
-       unsigned ret = sys_read(handle, buf, len);
+       size_t ret = sys_read(handle, buf, len);
        if(ret==0)
                set_eof();
 
index 8feccfd2ffe74a2fd3e1e05d69310e887eb7c0d6..1200086014e4dae5a82196dd48667c31dfe551a3 100644 (file)
@@ -54,8 +54,8 @@ public:
        void redirect(Base &);
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 
 public:
        virtual const Handle &get_handle(Mode);
index 74b9f9fde19e49983e35098ea06c0c6c80bcfd0e..5ead278813d7bd73e8c9eae38282e8b07f1d0bd4 100644 (file)
@@ -38,7 +38,7 @@ void File::set_inherit(bool i)
        sys_set_inherit(handle, i);
 }
 
-unsigned File::do_write(const char *buf, unsigned size)
+size_t File::do_write(const char *buf, size_t size)
 {
        check_access(M_WRITE);
 
@@ -53,14 +53,14 @@ unsigned File::do_write(const char *buf, unsigned size)
        return sys_write(handle, buf, size);
 }
 
-unsigned File::do_read(char *buf, unsigned size)
+size_t File::do_read(char *buf, size_t size)
 {
        check_access(M_READ);
 
        if(size==0)
                return 0;
 
-       unsigned ret = sys_read(handle, buf, size);
+       size_t ret = sys_read(handle, buf, size);
        if(ret==0)
                set_eof();
 
@@ -107,23 +107,23 @@ void BufferedFile::set_inherit(bool)
        throw logic_error("BufferedFile::set_inherit");
 }
 
-unsigned BufferedFile::do_write(const char *buf, unsigned size)
+size_t BufferedFile::do_write(const char *buf, size_t size)
 {
-       unsigned ret = buffer.write(buf, size);
+       size_t ret = buffer.write(buf, size);
        position += ret;
        return ret;
 }
 
-unsigned BufferedFile::do_read(char *buf, unsigned size)
+size_t BufferedFile::do_read(char *buf, size_t size)
 {
-       unsigned ret = buffer.read(buf, size);
+       size_t ret = buffer.read(buf, size);
        position += ret;
        return ret;
 }
 
-unsigned BufferedFile::put(char c)
+size_t BufferedFile::put(char c)
 {
-       unsigned ret = buffer.put(c);
+       size_t ret = buffer.put(c);
        position += ret;
        return ret;
 }
index 85075d0cca6e8709db663012ced369dd5f0cda52..aeac6c8d265556974ddfee94febdb8ea5fd131b7 100644 (file)
@@ -61,8 +61,8 @@ public:
        virtual void set_inherit(bool);
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 
 public:
        virtual void sync();
@@ -97,10 +97,10 @@ public:
        virtual void set_inherit(bool);
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 public:
-       virtual unsigned put(char);
+       virtual std::size_t put(char);
 
        virtual bool getline(std::string &);
        virtual int get();
index 4b311f545f3212ff8755b7dbbf51c2889991d1b5..be2097e7f248d042c95312185ec40a25e3dca55b 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef MSP_IO_HANDLE_H_
 #define MSP_IO_HANDLE_H_
 
+#include <cstddef>
+
 namespace Msp {
 namespace IO {
 
@@ -30,8 +32,8 @@ public:
 
 void sys_set_blocking(Handle &, bool);
 void sys_set_inherit(Handle &, bool);
-unsigned sys_read(Handle &, char *, unsigned);
-unsigned sys_write(Handle &, const char *, unsigned);
+std::size_t sys_read(Handle &, char *, std::size_t);
+std::size_t sys_write(Handle &, const char *, std::size_t);
 void sys_close(Handle &);
 
 } // namespace IO
index eaaaeb1829dfc5a59b481ca32e6e48170a78cc53..616150f0ab72937e40989ae19dcdd401d5a95981 100644 (file)
@@ -8,7 +8,7 @@ using namespace std;
 namespace Msp {
 namespace IO {
 
-Memory::Memory(char *d, unsigned s, Mode m)
+Memory::Memory(char *d, size_t s, Mode m)
 {
        init(d, d+s, m);
 }
@@ -18,7 +18,7 @@ Memory::Memory(char *b, char *e, Mode m)
        init(b, e, m);
 }
 
-Memory::Memory(const char *cd, unsigned s)
+Memory::Memory(const char *cd, size_t s)
 {
        char *d = const_cast<char *>(cd);
        init(d, d+s, M_READ);
@@ -47,17 +47,17 @@ void Memory::set_inherit(bool)
        throw logic_error("Memory::set_inherit");
 }
 
-unsigned Memory::do_write(const char *buf, unsigned size)
+size_t Memory::do_write(const char *buf, size_t size)
 {
        check_access(M_WRITE);
 
-       size = min<unsigned>(size, end-pos);
+       size = min<size_t>(size, end-pos);
        memcpy(pos, buf, size);
        pos += size;
        return size;
 }
 
-unsigned Memory::do_read(char *buf, unsigned size)
+size_t Memory::do_read(char *buf, size_t size)
 {
        check_access(M_READ);
 
@@ -67,13 +67,13 @@ unsigned Memory::do_read(char *buf, unsigned size)
                return 0;
        }
 
-       size = min<unsigned>(size, end-pos);
+       size = min<size_t>(size, end-pos);
        memcpy(buf, pos, size);
        pos += size;
        return size;
 }
 
-unsigned Memory::put(char c)
+size_t Memory::put(char c)
 {
        check_access(M_WRITE);
 
index 4a6eca2ab44178636a0fa3016c97910f8834230f..5b9961c9a38728f7357fc1741e379c593589afdd 100644 (file)
@@ -14,9 +14,9 @@ private:
        char *pos;
 
 public:
-       Memory(char *, unsigned, Mode = M_RDWR);
+       Memory(char *, std::size_t, Mode = M_RDWR);
        Memory(char *, char *, Mode = M_RDWR);
-       Memory(const char *, unsigned);
+       Memory(const char *, std::size_t);
        Memory(const char *, const char *);
 private:
        void init(char *, char *, Mode);
@@ -26,10 +26,10 @@ public:
        virtual void set_inherit(bool);
 
 private:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 public:
-       virtual unsigned put(char);
+       virtual std::size_t put(char);
        virtual bool getline(std::string &);
        virtual int get();
 
index 1301b3ad0a8ce2a8554157d3d737bfa99b9bd06a..01bf20aaea32c056b33e2213dafdd1d0515c3f1e 100644 (file)
@@ -54,7 +54,7 @@ void Pipe::set_inherit(bool i)
        sys_set_inherit(write_handle, i);
 }
 
-unsigned Pipe::do_write(const char *buf, unsigned size)
+size_t Pipe::do_write(const char *buf, size_t size)
 {
        if(size==0)
                return 0;
@@ -62,12 +62,12 @@ unsigned Pipe::do_write(const char *buf, unsigned size)
        return sys_write(write_handle, buf, size);
 }
 
-unsigned Pipe::do_read(char *buf, unsigned size)
+size_t Pipe::do_read(char *buf, size_t size)
 {
        if(size==0)
                return 0;
 
-       unsigned ret = reader.read(buf, size);
+       size_t ret = reader.read(buf, size);
        if(ret==0)
                set_eof();
 
index 098e1190a63ecd1882e453c49fc727006b7c861e..5fc0b3d6006fa485c7c2f18ad2127cff064fdc1e 100644 (file)
@@ -27,8 +27,8 @@ public:
        virtual void set_inherit(bool);
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 
 public:
        virtual const Handle &get_handle(Mode);
index 3fbfc5756f4e5ff4173eaf30e6ceedc1a2815591..4007a5e22f1e83cd690c8e278c4a584b1d431aa4 100644 (file)
@@ -57,39 +57,39 @@ unsigned Slice::prepare_op(unsigned size, Mode m)
        return size;
 }
 
-unsigned Slice::do_write(const char *data, unsigned size)
+size_t Slice::do_write(const char *data, size_t size)
 {
        Base::Synchronize sync(below);
        size = prepare_op(size, M_WRITE);
        if(!size)
                return 0;
 
-       unsigned len = below.write(data, size);
+       size_t len = below.write(data, size);
        position += len;
        return len;
 }
 
-unsigned Slice::do_read(char *data, unsigned size)
+size_t Slice::do_read(char *data, size_t size)
 {
        Base::Synchronize sync(below);
        size = prepare_op(size, M_READ);
        if(!size)
                return 0;
 
-       unsigned len = below.read(data, size);
+       size_t len = below.read(data, size);
        if(!len && below.eof())
                set_eof();
        position += len;
        return len;
 }
 
-unsigned Slice::put(char c)
+size_t Slice::put(char c)
 {
        Base::Synchronize sync(below);
        if(!prepare_op(1, M_WRITE))
                return 0;
 
-       unsigned len = below.put(c);
+       size_t len = below.put(c);
        position += len;
        return len;
 }
index d5f0f748102748696ab2bdaf05abf0985a7a70a7..8ca4327415ff29f16d19decee872a7f0234185d9 100644 (file)
@@ -36,11 +36,11 @@ private:
 
        unsigned prepare_op(unsigned, Mode);
 protected:
-       virtual unsigned do_write(const char *, unsigned);
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
+       virtual std::size_t do_read(char *, std::size_t);
 
 public:
-       virtual unsigned put(char);
+       virtual std::size_t put(char);
        virtual int get();
 
        virtual const Handle &get_handle(Mode);
index cbffa48e62a7354522a8d9efb8fcafe8f8c36c60..c9bf3b1384f08dce4c2f44d2e4edfdc5fc4114be 100644 (file)
@@ -5,6 +5,8 @@
 #include "handle.h"
 #include "handle_private.h"
 
+using namespace std;
+
 namespace Msp {
 namespace IO {
 
@@ -20,9 +22,9 @@ void sys_set_inherit(Handle &handle, bool i)
        fcntl(*handle, F_SETFD, (flags&~O_CLOEXEC)|(i?O_CLOEXEC:0));
 }
 
-unsigned sys_read(Handle &handle, char *buf, unsigned size)
+size_t sys_read(Handle &handle, char *buf, size_t size)
 {
-       int ret = read(*handle, buf, size);
+       ssize_t ret = read(*handle, buf, size);
        if(ret==-1)
        {
                if(errno==EAGAIN)
@@ -34,9 +36,9 @@ unsigned sys_read(Handle &handle, char *buf, unsigned size)
        return ret;
 }
 
-unsigned sys_write(Handle &handle, const char *buf, unsigned size)
+size_t sys_write(Handle &handle, const char *buf, size_t size)
 {
-       int ret = write(*handle, buf, size);
+       ssize_t ret = write(*handle, buf, size);
        if(ret==-1)
        {
                if(errno==EAGAIN)
index e59de273a65ea07d3d42712f1d2394cdc0db018d..1cdf8ce208ed881d0d5510bc0efb3a93122640ca 100644 (file)
@@ -1,7 +1,11 @@
+#define NOMINMAX
+#include <limits>
 #include <msp/core/systemerror.h>
 #include "handle.h"
 #include "handle_private.h"
 
+using namespace std;
+
 namespace Msp {
 namespace IO {
 
@@ -13,8 +17,11 @@ void sys_set_inherit(Handle &, bool)
 {
 }
 
-unsigned sys_read(Handle &handle, char *buf, unsigned size)
+size_t sys_read(Handle &handle, char *buf, size_t size)
 {
+       if(size>numeric_limits<DWORD>::max())
+               throw invalid_argument("read");
+
        DWORD ret;
        if(ReadFile(*handle, buf, size, &ret, 0)==0)
                throw system_error("ReadFile");
@@ -22,8 +29,11 @@ unsigned sys_read(Handle &handle, char *buf, unsigned size)
        return ret;
 }
 
-unsigned sys_write(Handle &handle, const char *buf, unsigned size)
+size_t sys_write(Handle &handle, const char *buf, size_t size)
 {
+       if(size>numeric_limits<DWORD>::max())
+               throw invalid_argument("write");
+
        DWORD ret;
        if(WriteFile(*handle, buf, size, &ret, 0)==0)
                throw system_error("WriteFile");
index 3ad4f224a14f0ca9b9c2fb29d5e4df70a851c4b2..f477bdc46f180e3446f5ee898470c9519ad0fdff 100644 (file)
@@ -141,15 +141,15 @@ void ZlibCompressed::flush()
 #endif
 }
 
-unsigned ZlibCompressed::do_write(const char *data, unsigned size)
+size_t ZlibCompressed::do_write(const char *data, size_t size)
 {
        check_access(M_WRITE);
 
-       unsigned processed = 0;
+       size_t processed = 0;
 #ifdef WITH_ZLIB
        while(processed<size)
        {
-               unsigned free_in = (in_buffer+buffer_size-priv->stream.next_in);
+               size_t free_in = (in_buffer+buffer_size-priv->stream.next_in);
                if(free_in<size && priv->stream.next_in>in_buffer)
                {
                        // Not all of the data fits in the buffer, so make some more room
@@ -161,7 +161,7 @@ unsigned ZlibCompressed::do_write(const char *data, unsigned size)
                if(free_in)
                {
                        // Copy as much data into the input buffer as possible
-                       unsigned len = min(free_in, size-processed);
+                       size_t len = min(free_in, size-processed);
                        copy(data+processed, data+processed+len, priv->stream.next_in+priv->stream.avail_in);
                        priv->stream.avail_in += len;
                        processed += len;
@@ -196,12 +196,12 @@ bool ZlibCompressed::compress_data(int flush_mode)
        }
 
        // Write compressed data into the underlying object
-       unsigned len = 0;
+       size_t len = 0;
        if(priv->stream.next_out>out_buffer)
                len = below.write(reinterpret_cast<char *>(out_buffer), priv->stream.next_out-out_buffer);
        if(len>0)
        {
-               if(len<static_cast<unsigned>(priv->stream.next_out-out_buffer))
+               if(len<static_cast<size_t>(priv->stream.next_out-out_buffer))
                        copy(out_buffer+len, priv->stream.next_out, out_buffer);
                priv->stream.avail_out += len;
                priv->stream.next_out -= len;
@@ -217,23 +217,23 @@ bool ZlibCompressed::compress_data(int flush_mode)
 #endif
 }
 
-unsigned ZlibCompressed::do_read(char *data, unsigned size)
+size_t ZlibCompressed::do_read(char *data, size_t size)
 {
        check_access(M_READ);
 
-       unsigned processed = 0;
+       size_t processed = 0;
 #ifdef WITH_ZLIB
        while(processed<size)
        {
                if(priv->stream.next_out>out_buffer)
                {
                        // We have some pending output, give it out first
-                       unsigned len = min<unsigned>(priv->stream.next_out-out_buffer, size-processed);
+                       size_t len = min<size_t>(priv->stream.next_out-out_buffer, size-processed);
 
                        copy(out_buffer, out_buffer+len, data+processed);
                        processed += len;
 
-                       if(len<static_cast<unsigned>(priv->stream.next_out-out_buffer))
+                       if(len<static_cast<size_t>(priv->stream.next_out-out_buffer))
                                copy(out_buffer+len, priv->stream.next_out, out_buffer);
                        priv->stream.next_out -= len;
                        priv->stream.avail_out += len;
@@ -261,7 +261,7 @@ unsigned ZlibCompressed::do_read(char *data, unsigned size)
                                copy(priv->stream.next_in, priv->stream.next_in+priv->stream.avail_in, in_buffer);
                        priv->stream.next_in = in_buffer;
 
-                       unsigned len = below.read(reinterpret_cast<char *>(priv->stream.next_in), in_buffer+buffer_size-priv->stream.next_in);
+                       size_t len = below.read(reinterpret_cast<char *>(priv->stream.next_in), in_buffer+buffer_size-priv->stream.next_in);
                        priv->stream.avail_in += len;
                        if(!len && below.eof())
                                stream_end = true;
index af75aecd51d7d843d92390be68cb1a955e52e2a0..e4ae6e08f852f9b6228f7ff0f4b415d80a08de81 100644 (file)
@@ -34,7 +34,7 @@ private:
        struct Private;
 
        Base &below;
-       unsigned buffer_size;
+       std::size_t buffer_size;
        unsigned char *in_buffer;
        unsigned char *out_buffer;
        bool stream_end;
@@ -62,7 +62,7 @@ public:
        void flush();
 
 protected:
-       virtual unsigned do_write(const char *, unsigned);
+       virtual std::size_t do_write(const char *, std::size_t);
 
 private:
        /** Compresses data and writes it to the underlying object.  Returns true if
@@ -72,7 +72,7 @@ private:
        bool compress_data(int flush_mode);
 
 public:
-       virtual unsigned do_read(char *, unsigned);
+       virtual std::size_t do_read(char *, std::size_t);
 
        virtual const Handle &get_handle(Mode);
 };