ostream: Simplified implementing ostreams.

Some functions are no longer necessary to implement. Moved some code to be
common among all ostreams.

--HG--
branch : HEAD

diff --git a/src/lib/ostream-buffer.c b/src/lib/ostream-buffer.c
index 68fa172cb662636fc3ab75f4917f0a85e7c4901f..0df709dfcdd9dfd231b5f1529888f36364725763 100644 (file)
--- a/src/lib/ostream-buffer.c
+++ b/src/lib/ostream-buffer.c
@@ -7,40 +7,8 @@
 struct buffer_ostream {
        struct ostream_private ostream;
        buffer_t *buf;
-       size_t max_buffer_size;
 };
 
-static void
-o_stream_buffer_set_max_buffer_size(struct iostream_private *stream,
-                                size_t max_size)
-{
-       struct buffer_ostream *bstream = (struct buffer_ostream *)stream;
-
-       bstream->max_buffer_size = max_size;
-}
-
-static void o_stream_buffer_cork(struct ostream_private *stream ATTR_UNUSED,
-                                bool set ATTR_UNUSED)
-{
-}
-
-static int o_stream_buffer_flush(struct ostream_private *stream ATTR_UNUSED)
-{
-       return 1;
-}
-
-static void
-o_stream_buffer_flush_pending(struct ostream_private *stream ATTR_UNUSED,
-                             bool set ATTR_UNUSED)
-{
-}
-
-static size_t
-o_stream_buffer_get_used_size(const struct ostream_private *stream ATTR_UNUSED)
-{
-       return 0;
-}
-
 static int o_stream_buffer_seek(struct ostream_private *stream, uoff_t offset)
 {
        stream->ostream.offset = offset;
@@ -67,7 +35,8 @@ o_stream_buffer_sendv(struct ostream_private *stream,
        unsigned int i;
 
        for (i = 0; i < iov_count; i++) {
-               left = bstream->max_buffer_size - stream->ostream.offset;
+               left = bstream->ostream.max_buffer_size -
+                       stream->ostream.offset;
                n = I_MIN(left, iov[i].iov_len);
                buffer_write(bstream->buf, stream->ostream.offset,
                             iov[i].iov_base, n);
@@ -79,30 +48,16 @@ o_stream_buffer_sendv(struct ostream_private *stream,
        return ret;
 }
 
-static off_t o_stream_buffer_send_istream(struct ostream_private *outstream,
-                                         struct istream *instream)
-{
-       return io_stream_copy(&outstream->ostream, instream, 1024);
-}
-
 struct ostream *o_stream_create_buffer(buffer_t *buf)
 {
        struct buffer_ostream *bstream;
 
        bstream = i_new(struct buffer_ostream, 1);
-       bstream->ostream.iostream.set_max_buffer_size =
-               o_stream_buffer_set_max_buffer_size;
-
-       bstream->ostream.cork = o_stream_buffer_cork;
-       bstream->ostream.flush = o_stream_buffer_flush;
-       bstream->ostream.flush_pending = o_stream_buffer_flush_pending;
-       bstream->ostream.get_used_size = o_stream_buffer_get_used_size;
+       bstream->ostream.max_buffer_size = (size_t)-1;
        bstream->ostream.seek = o_stream_buffer_seek;
        bstream->ostream.sendv = o_stream_buffer_sendv;
        bstream->ostream.write_at = o_stream_buffer_write_at;
-       bstream->ostream.send_istream = o_stream_buffer_send_istream;
 
        bstream->buf = buf;
-       bstream->max_buffer_size = (size_t)-1;
        return o_stream_create(&bstream->ostream);
 }

diff --git a/src/lib/ostream-file.c b/src/lib/ostream-file.c
index ff59d9fbab61e38630b44ab9a9c69608985da274..623059768a5e755b4fc7123e78ec02a5cac5cdce 100644 (file)
--- a/src/lib/ostream-file.c
+++ b/src/lib/ostream-file.c
@@ -37,7 +37,7 @@ struct file_ostream {
        uoff_t real_offset;
 
        unsigned char *buffer; /* ring-buffer */
-       size_t buffer_size, max_buffer_size, optimal_block_size;
+       size_t buffer_size, optimal_block_size;
        size_t head, tail; /* first unsent/unused byte */
 
        unsigned int full:1; /* if head == tail, is buffer empty or full? */
@@ -83,15 +83,6 @@ static void o_stream_file_destroy(struct iostream_private *stream)
        i_free(fstream->buffer);
 }
 
-static void
-o_stream_file_set_max_buffer_size(struct iostream_private *stream,
-                                 size_t max_size)
-{
-       struct file_ostream *fstream = (struct file_ostream *)stream;
-
-       fstream->max_buffer_size = max_size;
-}
-
 static size_t file_buffer_get_used_size(struct file_ostream *fstream)
 {
        if (fstream->head == fstream->tail)
@@ -420,13 +411,13 @@ static void o_stream_grow_buffer(struct file_ostream *fstream, size_t bytes)
        size_t size, new_size, end_size;
 
        size = nearest_power(fstream->buffer_size + bytes);
-       if (size > fstream->max_buffer_size) {
+       if (size > fstream->ostream.max_buffer_size) {
                /* limit the size */
-               size = fstream->max_buffer_size;
+               size = fstream->ostream.max_buffer_size;
        } else if (fstream->corked) {
                /* try to use optimal buffer size with corking */
                new_size = I_MIN(fstream->optimal_block_size,
-                                fstream->max_buffer_size);
+                                fstream->ostream.max_buffer_size);
                if (new_size > size)
                        size = new_size;
        }
@@ -545,7 +536,7 @@ static ssize_t o_stream_file_sendv(struct ostream_private *stream,
        }
 
        optimal_size = I_MIN(fstream->optimal_block_size,
-                            fstream->max_buffer_size);
+                            fstream->ostream.max_buffer_size);
        if (IS_STREAM_EMPTY(fstream) &&
            (!fstream->corked || size >= optimal_size)) {
                /* send immediately */
@@ -888,8 +879,6 @@ o_stream_create_fd_common(int fd, bool autoclose_fd)
 
        fstream->ostream.iostream.close = o_stream_file_close;
        fstream->ostream.iostream.destroy = o_stream_file_destroy;
-       fstream->ostream.iostream.set_max_buffer_size =
-               o_stream_file_set_max_buffer_size;
 
        fstream->ostream.cork = o_stream_file_cork;
        fstream->ostream.flush = o_stream_file_flush;
@@ -931,7 +920,7 @@ o_stream_create_fd(int fd, size_t max_buffer_size, bool autoclose_fd)
        off_t offset;
 
        fstream = o_stream_create_fd_common(fd, autoclose_fd);
-       fstream->max_buffer_size = max_buffer_size;
+       fstream->ostream.max_buffer_size = max_buffer_size;
        ostream = o_stream_create(&fstream->ostream);
 
        offset = lseek(fd, 0, SEEK_CUR);
@@ -948,7 +937,7 @@ o_stream_create_fd(int fd, size_t max_buffer_size, bool autoclose_fd)
        }
 
        if (max_buffer_size == 0)
-               fstream->max_buffer_size = fstream->optimal_block_size;
+               fstream->ostream.max_buffer_size = fstream->optimal_block_size;
 
        return ostream;
 }
@@ -964,7 +953,7 @@ o_stream_create_fd_file(int fd, uoff_t offset, bool autoclose_fd)
 
        fstream = o_stream_create_fd_common(fd, autoclose_fd);
        fstream_init_file(fstream);
-       fstream->max_buffer_size = fstream->optimal_block_size;
+       fstream->ostream.max_buffer_size = fstream->optimal_block_size;
        fstream->real_offset = offset;
        fstream->buffer_offset = offset;
 

diff --git a/src/lib/ostream-internal.h b/src/lib/ostream-internal.h
index 5637ff7f53e3d223490e32b9aaa451ca0c64837e..b81eeed432e63aba1c6e3616d84a3890f78517c5 100644 (file)
--- a/src/lib/ostream-internal.h
+++ b/src/lib/ostream-internal.h
@@ -24,6 +24,7 @@ struct ostream_private {
 
 /* data: */
        struct ostream ostream;
+       size_t max_buffer_size;
 
        stream_flush_callback_t *callback;
        void *context;

diff --git a/src/lib/ostream.c b/src/lib/ostream.c
index fff94e7861253d90331e88942070e15d4ecc7a31..bffda76843672323fbbbe6b794ef96f10ac2f570 100644 (file)
--- a/src/lib/ostream.c
+++ b/src/lib/ostream.c
@@ -48,7 +48,12 @@ void o_stream_unset_flush_callback(struct ostream *stream)
 
 void o_stream_set_max_buffer_size(struct ostream *stream, size_t max_size)
 {
-       io_stream_set_max_buffer_size(&stream->real_stream->iostream, max_size);
+       if (stream->real_stream->iostream.set_max_buffer_size != NULL) {
+               io_stream_set_max_buffer_size(&stream->real_stream->iostream,
+                                             max_size);
+       } else {
+               stream->real_stream->max_buffer_size = max_size;
+       }
 }
 
 void o_stream_cork(struct ostream *stream)
@@ -58,7 +63,8 @@ void o_stream_cork(struct ostream *stream)
        if (unlikely(stream->closed))
                return;
 
-       _stream->cork(_stream, TRUE);
+       if (_stream->cork != NULL)
+               _stream->cork(_stream, TRUE);
 }
 
 void o_stream_uncork(struct ostream *stream)
@@ -68,21 +74,24 @@ void o_stream_uncork(struct ostream *stream)
        if (unlikely(stream->closed))
                return;
 
-       _stream->cork(_stream, FALSE);
+       if (_stream->cork != NULL)
+               _stream->cork(_stream, FALSE);
 }
 
 int o_stream_flush(struct ostream *stream)
 {
        struct ostream_private *_stream = stream->real_stream;
-       int ret;
+       int ret = 1;
 
        if (unlikely(stream->closed))
                return -1;
 
        stream->stream_errno = 0;
-       if (unlikely((ret = _stream->flush(_stream)) < 0)) {
-               i_assert(stream->stream_errno != 0);
-               stream->last_failed_errno = stream->stream_errno;
+       if (_stream->flush != NULL) {
+               if (unlikely((ret = _stream->flush(_stream)) < 0)) {
+                       i_assert(stream->stream_errno != 0);
+                       stream->last_failed_errno = stream->stream_errno;
+               }
        }
        return ret;
 }
@@ -94,14 +103,16 @@ void o_stream_set_flush_pending(struct ostream *stream, bool set)
        if (unlikely(stream->closed))
                return;
 
-       _stream->flush_pending(_stream, set);
+       if (_stream->flush_pending != NULL)
+               _stream->flush_pending(_stream, set);
 }
 
 size_t o_stream_get_buffer_used_size(const struct ostream *stream)
 {
        const struct ostream_private *_stream = stream->real_stream;
 
-       return _stream->get_used_size(_stream);
+       return _stream->get_used_size == NULL ? 0 :
+               _stream->get_used_size(_stream);
 }
 
 int o_stream_seek(struct ostream *stream, uoff_t offset)
@@ -112,9 +123,15 @@ int o_stream_seek(struct ostream *stream, uoff_t offset)
                return -1;
 
        stream->stream_errno = 0;
-       if (unlikely(_stream->seek(_stream, offset) < 0)) {
-               i_assert(stream->stream_errno != 0);
-               stream->last_failed_errno = stream->stream_errno;
+       if (_stream->seek != NULL) {
+               if (unlikely(_stream->seek(_stream, offset) < 0)) {
+                       i_assert(stream->stream_errno != 0);
+                       stream->last_failed_errno = stream->stream_errno;
+               }
+       } else {
+               stream->stream_errno = EPIPE;
+               stream->last_failed_errno = EPIPE;
+               return -1;
        }
        return 1;
 }
@@ -196,9 +213,17 @@ int o_stream_pwrite(struct ostream *stream, const void *data, size_t size,
        return ret;
 }
 
+static off_t o_stream_default_send_istream(struct ostream_private *outstream,
+                                          struct istream *instream)
+{
+       return io_stream_copy(&outstream->ostream, instream, 1024);
+}
+
 struct ostream *o_stream_create(struct ostream_private *_stream)
 {
        _stream->ostream.real_stream = _stream;
+       if (_stream->send_istream == NULL)
+               _stream->send_istream = o_stream_default_send_istream;
 
        io_stream_init(&_stream->iostream);
        return &_stream->ostream;