[evolution-data-server] Kill CamelSeekableStream.

From: Matthew Barnes <mbarnes src gnome org>
To: commits-list gnome org
Cc:
Subject: [evolution-data-server] Kill CamelSeekableStream.
Date: Mon, 24 Jan 2011 02:21:06 +0000 (UTC)
commit d638e36ee527798211984849d822eebf8cd46b79
Author: Matthew Barnes <mbarnes redhat com>
Date:   Sun Jan 23 19:55:58 2011 -0500

    Kill CamelSeekableStream.
    
    CamelStreamFs and CamelStreamMem now implement the GSeekable interface.

 camel/Makefile.am                                  |    2 -
 camel/camel-mime-filter-save.h                     |    2 +-
 camel/camel-mime-parser.c                          |   10 +-
 camel/camel-multipart-signed.c                     |    7 +-
 camel/camel-seekable-stream.c                      |  182 --------------------
 camel/camel-seekable-stream.h                      |   97 -----------
 camel/camel-stream-buffer.h                        |    2 +-
 camel/camel-stream-fs.c                            |  124 +++++++------
 camel/camel-stream-fs.h                            |    6 +-
 camel/camel-stream-mem.c                           |   97 +++++++----
 camel/camel-stream-mem.h                           |    6 +-
 camel/camel-stream.c                               |    8 +-
 camel/camel.h                                      |    1 -
 camel/providers/imap/camel-imap-search.c           |    2 +-
 camel/providers/imapx/camel-imapx-server.c         |    4 +-
 docs/reference/camel/camel-docs.sgml               |    1 -
 docs/reference/camel/camel-sections.txt            |   20 --
 docs/reference/camel/camel.types                   |    1 -
 .../camel/tmpl/camel-seekable-stream.sgml          |   68 --------
 docs/reference/camel/tmpl/camel-unused.sgml        |   23 +++
 20 files changed, 182 insertions(+), 481 deletions(-)
---
diff --git a/camel/Makefile.am b/camel/Makefile.am
index 8aa2029..d4b2dd0 100644
--- a/camel/Makefile.am
+++ b/camel/Makefile.am
@@ -211,7 +211,6 @@ libcamel_1_2_la_SOURCES = 			\
 	camel-object-bag.c			\
 	camel-operation.c			\
 	camel-partition-table.c			\
-	camel-seekable-stream.c			\
 	camel-stream-buffer.c			\
 	camel-stream-filter.c			\
 	camel-stream-fs.c			\
@@ -281,7 +280,6 @@ libcamelinclude_HEADERS =			\
 	camel-operation.h			\
 	camel-partition-table.h			\
 	camel-search-private.h			\
-	camel-seekable-stream.h			\
 	camel-stream-buffer.h			\
 	camel-stream-filter.h			\
 	camel-stream-fs.h			\
diff --git a/camel/camel-mime-filter-save.h b/camel/camel-mime-filter-save.h
index 4da8213..f73c23b 100644
--- a/camel/camel-mime-filter-save.h
+++ b/camel/camel-mime-filter-save.h
@@ -28,7 +28,7 @@
 #define CAMEL_MIME_FILTER_SAVE_H
 
 #include <camel/camel-mime-filter.h>
-#include <camel/camel-seekable-stream.h>
+#include <camel/camel-stream.h>
 
 /* Standard GObject macros */
 #define CAMEL_TYPE_MIME_FILTER_SAVE \
diff --git a/camel/camel-mime-parser.c b/camel/camel-mime-parser.c
index 2756924..e6afd1b 100644
--- a/camel/camel-mime-parser.c
+++ b/camel/camel-mime-parser.c
@@ -37,7 +37,6 @@
 #include "camel-mime-filter.h"
 #include "camel-mime-parser.h"
 #include "camel-mime-utils.h"
-#include "camel-seekable-stream.h"
 #include "camel-stream.h"
 
 #define r(x)
@@ -961,12 +960,13 @@ folder_seek (struct _header_scan_state *s, goffset offset, gint whence)
 	goffset newoffset;
 
 	if (s->stream) {
-		if (CAMEL_IS_SEEKABLE_STREAM (s->stream)) {
+		if (G_IS_SEEKABLE (s->stream)) {
 			/* NOTE: assumes whence seekable stream == whence libc, which is probably
 			   the case (or bloody well should've been) */
-			newoffset = camel_seekable_stream_seek (
-				CAMEL_SEEKABLE_STREAM (s->stream),
-				offset, whence, NULL);
+			g_seekable_seek (
+				G_SEEKABLE (s->stream),
+				offset, whence, NULL, NULL);
+			newoffset = g_seekable_tell (G_SEEKABLE (s->stream));
 		} else {
 			newoffset = -1;
 			errno = EINVAL;
diff --git a/camel/camel-multipart-signed.c b/camel/camel-multipart-signed.c
index c249e70..788f560 100644
--- a/camel/camel-multipart-signed.c
+++ b/camel/camel-multipart-signed.c
@@ -56,7 +56,6 @@ multipart_signed_clip_stream (CamelMultipartSigned *mps,
 {
 	CamelDataWrapper *data_wrapper;
 	CamelStream *stream;
-	goffset position;
 	gchar *buffer;
 	gssize n_read;
 	gsize length;
@@ -64,9 +63,9 @@ multipart_signed_clip_stream (CamelMultipartSigned *mps,
 	data_wrapper = CAMEL_DATA_WRAPPER (mps);
 	stream = data_wrapper->stream;
 
-	position = camel_seekable_stream_seek (
-		CAMEL_SEEKABLE_STREAM (stream), start, G_SEEK_SET, error);
-	if (position < 0)
+	if (!g_seekable_seek (
+		G_SEEKABLE (stream), start,
+		G_SEEK_SET, cancellable, error))
 		return NULL;
 
 	length = end - start;
diff --git a/camel/camel-stream-buffer.h b/camel/camel-stream-buffer.h
index 62c23a7..f9d2f1f 100644
--- a/camel/camel-stream-buffer.h
+++ b/camel/camel-stream-buffer.h
@@ -31,7 +31,7 @@
 #define CAMEL_STREAM_BUFFER_H
 
 #include <stdio.h>
-#include <camel/camel-seekable-stream.h>
+#include <camel/camel-stream.h>
 
 /* Standard GObject macros */
 #define CAMEL_TYPE_STREAM_BUFFER \
diff --git a/camel/camel-stream-fs.c b/camel/camel-stream-fs.c
index d302ac7..146eac8 100644
--- a/camel/camel-stream-fs.c
+++ b/camel/camel-stream-fs.c
@@ -47,7 +47,12 @@ struct _CamelStreamFsPrivate {
 	gint fd;	/* file descriptor on the underlying file */
 };
 
-G_DEFINE_TYPE (CamelStreamFs, camel_stream_fs, CAMEL_TYPE_SEEKABLE_STREAM)
+/* Forward Declarations */
+static void camel_stream_fs_seekable_init (GSeekableIface *interface);
+
+G_DEFINE_TYPE_WITH_CODE (
+	CamelStreamFs, camel_stream_fs, CAMEL_TYPE_STREAM,
+	G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE, camel_stream_fs_seekable_init))
 
 static void
 stream_fs_finalize (GObject *object)
@@ -71,20 +76,13 @@ stream_fs_read (CamelStream *stream,
                 GError **error)
 {
 	CamelStreamFsPrivate *priv;
-	CamelSeekableStream *seekable;
 	gssize nread;
 
 	priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
-	seekable = CAMEL_SEEKABLE_STREAM (stream);
-
-	if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
-		n = MIN (seekable->bound_end - seekable->position, n);
 
 	nread = camel_read (priv->fd, buffer, n, cancellable, error);
 
-	if (nread > 0)
-		seekable->position += nread;
-	else if (nread == 0)
+	if (nread == 0)
 		stream->eos = TRUE;
 
 	return nread;
@@ -98,21 +96,10 @@ stream_fs_write (CamelStream *stream,
                  GError **error)
 {
 	CamelStreamFsPrivate *priv;
-	CamelSeekableStream *seekable;
-	gssize nwritten;
 
 	priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
-	seekable = CAMEL_SEEKABLE_STREAM (stream);
-
-	if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
-		n = MIN (seekable->bound_end - seekable->position, n);
-
-	nwritten = camel_write (priv->fd, buffer, n, cancellable, error);
 
-	if (nwritten > 0)
-		seekable->position += nwritten;
-
-	return nwritten;
+	return camel_write (priv->fd, buffer, n, cancellable, error);
 }
 
 static gint
@@ -164,60 +151,84 @@ stream_fs_close (CamelStream *stream,
 }
 
 static goffset
-stream_fs_seek (CamelSeekableStream *stream,
+stream_fs_tell (GSeekable *seekable)
+{
+	CamelStreamFsPrivate *priv;
+
+	priv = CAMEL_STREAM_FS_GET_PRIVATE (seekable);
+
+	return (goffset) lseek (priv->fd, 0, SEEK_CUR);
+}
+
+static gboolean
+stream_fs_can_seek (GSeekable *seekable)
+{
+	return TRUE;
+}
+
+static gboolean
+stream_fs_seek (GSeekable *seekable,
                 goffset offset,
                 GSeekType type,
+                GCancellable *cancellable,
                 GError **error)
 {
 	CamelStreamFsPrivate *priv;
 	goffset real = 0;
 
-	priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
+	priv = CAMEL_STREAM_FS_GET_PRIVATE (seekable);
 
 	switch (type) {
 	case G_SEEK_SET:
 		real = offset;
 		break;
 	case G_SEEK_CUR:
-		real = stream->position + offset;
+		real = g_seekable_tell (seekable) + offset;
 		break;
 	case G_SEEK_END:
-		if (stream->bound_end == CAMEL_STREAM_UNBOUND) {
-			real = lseek (priv->fd, offset, SEEK_END);
-			if (real != -1) {
-				if (real<stream->bound_start)
-					real = stream->bound_start;
-				stream->position = real;
-			} else
-				g_set_error (
-					error, G_IO_ERROR,
-					g_io_error_from_errno (errno),
-					"%s", g_strerror (errno));
-			return real;
+		real = lseek (priv->fd, offset, SEEK_END);
+		if (real == -1) {
+			g_set_error (
+				error, G_IO_ERROR,
+				g_io_error_from_errno (errno),
+				"%s", g_strerror (errno));
+			return FALSE;
 		}
-		real = stream->bound_end + offset;
-		break;
+		return TRUE;
 	}
 
-	if (stream->bound_end != CAMEL_STREAM_UNBOUND)
-		real = MIN (real, stream->bound_end);
-	real = MAX (real, stream->bound_start);
-
 	real = lseek (priv->fd, real, SEEK_SET);
 	if (real == -1) {
 		g_set_error (
 			error, G_IO_ERROR,
 			g_io_error_from_errno (errno),
 			"%s", g_strerror (errno));
-		return -1;
+		return FALSE;
 	}
 
-	if (real != stream->position && ((CamelStream *)stream)->eos)
-		((CamelStream *)stream)->eos = FALSE;
+	CAMEL_STREAM (seekable)->eos = FALSE;
+
+	return TRUE;
+}
+
+static gboolean
+stream_fs_can_truncate (GSeekable *seekable)
+{
+	return FALSE;
+}
 
-	stream->position = real;
+static gboolean
+stream_fs_truncate_fn (GSeekable *seekable,
+                       goffset offset,
+                       GCancellable *cancellable,
+                       GError **error)
+{
+	/* XXX Don't bother translating this.  Camel never calls it. */
+	g_set_error (
+		error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+		"Truncation is not supported");
 
-	return real;
+	return FALSE;
 }
 
 static void
@@ -225,7 +236,6 @@ camel_stream_fs_class_init (CamelStreamFsClass *class)
 {
 	GObjectClass *object_class;
 	CamelStreamClass *stream_class;
-	CamelSeekableStreamClass *seekable_stream_class;
 
 	g_type_class_add_private (class, sizeof (CamelStreamFsPrivate));
 
@@ -237,9 +247,16 @@ camel_stream_fs_class_init (CamelStreamFsClass *class)
 	stream_class->write = stream_fs_write;
 	stream_class->flush = stream_fs_flush;
 	stream_class->close = stream_fs_close;
+}
 
-	seekable_stream_class = CAMEL_SEEKABLE_STREAM_CLASS (class);
-	seekable_stream_class->seek = stream_fs_seek;
+static void
+camel_stream_fs_seekable_init (GSeekableIface *interface)
+{
+	interface->tell = stream_fs_tell;
+	interface->can_seek = stream_fs_can_seek;
+	interface->seek = stream_fs_seek;
+	interface->can_truncate = stream_fs_can_truncate;
+	interface->truncate_fn = stream_fs_truncate_fn;
 }
 
 static void
@@ -247,8 +264,6 @@ camel_stream_fs_init (CamelStreamFs *stream)
 {
 	stream->priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
 	stream->priv->fd = -1;
-
-	CAMEL_SEEKABLE_STREAM (stream)->bound_end = CAMEL_STREAM_UNBOUND;
 }
 
 /**
@@ -266,7 +281,6 @@ camel_stream_fs_new_with_fd (gint fd)
 {
 	CamelStreamFsPrivate *priv;
 	CamelStream *stream;
-	goffset offset;
 
 	if (fd == -1)
 		return NULL;
@@ -275,10 +289,6 @@ camel_stream_fs_new_with_fd (gint fd)
 	priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
 
 	priv->fd = fd;
-	offset = lseek (fd, 0, SEEK_CUR);
-	if (offset == -1)
-		offset = 0;
-	CAMEL_SEEKABLE_STREAM (stream)->position = offset;
 
 	return stream;
 }
diff --git a/camel/camel-stream-fs.h b/camel/camel-stream-fs.h
index 4d2e828..b2b82a1 100644
--- a/camel/camel-stream-fs.h
+++ b/camel/camel-stream-fs.h
@@ -34,7 +34,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-#include <camel/camel-seekable-stream.h>
+#include <camel/camel-stream.h>
 
 /* Standard GObject macros */
 #define CAMEL_TYPE_STREAM_FS \
@@ -62,12 +62,12 @@ typedef struct _CamelStreamFsClass CamelStreamFsClass;
 typedef struct _CamelStreamFsPrivate CamelStreamFsPrivate;
 
 struct _CamelStreamFs {
-	CamelSeekableStream parent;
+	CamelStream parent;
 	CamelStreamFsPrivate *priv;
 };
 
 struct _CamelStreamFsClass {
-	CamelSeekableStreamClass parent_class;
+	CamelStreamClass parent_class;
 };
 
 GType		camel_stream_fs_get_type	(void);
diff --git a/camel/camel-stream-mem.c b/camel/camel-stream-mem.c
index 89c078a..fbd5324 100644
--- a/camel/camel-stream-mem.c
+++ b/camel/camel-stream-mem.c
@@ -44,9 +44,15 @@ struct _CamelStreamMemPrivate {
 				   (only if we own it) */
 
 	GByteArray *buffer;
+	goffset position;
 };
 
-G_DEFINE_TYPE (CamelStreamMem, camel_stream_mem, CAMEL_TYPE_SEEKABLE_STREAM)
+/* Forward Declarations */
+static void camel_stream_mem_seekable_init (GSeekableIface *interface);
+
+G_DEFINE_TYPE_WITH_CODE (
+	CamelStreamMem, camel_stream_mem, CAMEL_TYPE_STREAM,
+	G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE, camel_stream_mem_seekable_init))
 
 /* could probably be a util method */
 static void
@@ -93,18 +99,14 @@ stream_mem_read (CamelStream *stream,
                  GError **error)
 {
 	CamelStreamMemPrivate *priv;
-	CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
 	gssize nread;
 
 	priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
 
-	if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
-		n = MIN (seekable->bound_end - seekable->position, n);
-
-	nread = MIN (n, priv->buffer->len - seekable->position);
+	nread = MIN (n, priv->buffer->len - priv->position);
 	if (nread > 0) {
-		memcpy (buffer, priv->buffer->data + seekable->position, nread);
-		seekable->position += nread;
+		memcpy (buffer, priv->buffer->data + priv->position, nread);
+		priv->position += nread;
 	} else
 		nread = 0;
 
@@ -119,22 +121,18 @@ stream_mem_write (CamelStream *stream,
                   GError **error)
 {
 	CamelStreamMemPrivate *priv;
-	CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
 	gssize nwrite = n;
 
 	priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
 
-	if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
-		nwrite = MIN (seekable->bound_end - seekable->position, n);
-
 	/* FIXME: we shouldn't use g_byte_arrays or g_malloc perhaps? */
-	if (seekable->position == priv->buffer->len) {
+	if (priv->position == priv->buffer->len) {
 		g_byte_array_append (priv->buffer, (const guint8 *)buffer, nwrite);
 	} else {
 		g_byte_array_set_size (priv->buffer, nwrite + priv->buffer->len);
-		memcpy (priv->buffer->data + seekable->position, buffer, nwrite);
+		memcpy (priv->buffer->data + priv->position, buffer, nwrite);
 	}
-	seekable->position += nwrite;
+	priv->position += nwrite;
 
 	return nwrite;
 }
@@ -143,30 +141,46 @@ static gboolean
 stream_mem_eos (CamelStream *stream)
 {
 	CamelStreamMemPrivate *priv;
-	CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (stream);
 
 	priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
 
-	return priv->buffer->len <= seekable_stream->position;
+	return priv->buffer->len <= priv->position;
 }
 
 static goffset
-stream_mem_seek (CamelSeekableStream *stream,
+stream_mem_tell (GSeekable *seekable)
+{
+	CamelStreamMemPrivate *priv;
+
+	priv = CAMEL_STREAM_MEM_GET_PRIVATE (seekable);
+
+	return priv->position;
+}
+
+static gboolean
+stream_mem_can_seek (GSeekable *seekable)
+{
+	return TRUE;
+}
+
+static gboolean
+stream_mem_seek (GSeekable *seekable,
                  goffset offset,
                  GSeekType type,
+                 GCancellable *cancellable,
                  GError **error)
 {
 	CamelStreamMemPrivate *priv;
 	goffset position;
 
-	priv = CAMEL_STREAM_MEM_GET_PRIVATE (stream);
+	priv = CAMEL_STREAM_MEM_GET_PRIVATE (seekable);
 
 	switch (type) {
 	case G_SEEK_SET:
 		position = offset;
 		break;
 	case G_SEEK_CUR:
-		position = stream->position + offset;
+		position = priv->position + offset;
 		break;
 	case G_SEEK_END:
 		position = (priv->buffer)->len + offset;
@@ -176,12 +190,7 @@ stream_mem_seek (CamelSeekableStream *stream,
 		break;
 	}
 
-	if (stream->bound_end != CAMEL_STREAM_UNBOUND)
-		position = MIN (position, stream->bound_end);
-	if (stream->bound_start != CAMEL_STREAM_UNBOUND)
-		position = MAX (position, 0);
-	else
-		position = MAX (position, stream->bound_start);
+	position = MAX (position, 0);
 
 	if (position > priv->buffer->len) {
 		gint oldlen = priv->buffer->len;
@@ -190,9 +199,29 @@ stream_mem_seek (CamelSeekableStream *stream,
 			position - oldlen);
 	}
 
-	stream->position = position;
+	priv->position = position;
+
+	return TRUE;
+}
+
+static gboolean
+stream_mem_can_truncate (GSeekable *seekable)
+{
+	return FALSE;
+}
+
+static gboolean
+stream_mem_truncate_fn (GSeekable *seekable,
+                        goffset offset,
+                        GCancellable *cancellable,
+                        GError **error)
+{
+	/* XXX Don't bother translating this.  Camel never calls it. */
+	g_set_error (
+		error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+		"Truncation is not supported");
 
-	return position;
+	return FALSE;
 }
 
 static void
@@ -200,7 +229,6 @@ camel_stream_mem_class_init (CamelStreamMemClass *class)
 {
 	GObjectClass *object_class;
 	CamelStreamClass *stream_class;
-	CamelSeekableStreamClass *seekable_stream_class;
 
 	g_type_class_add_private (class, sizeof (CamelStreamMemPrivate));
 
@@ -211,9 +239,16 @@ camel_stream_mem_class_init (CamelStreamMemClass *class)
 	stream_class->read = stream_mem_read;
 	stream_class->write = stream_mem_write;
 	stream_class->eos = stream_mem_eos;
+}
 
-	seekable_stream_class = CAMEL_SEEKABLE_STREAM_CLASS (class);
-	seekable_stream_class->seek = stream_mem_seek;
+static void
+camel_stream_mem_seekable_init (GSeekableIface *interface)
+{
+	interface->tell = stream_mem_tell;
+	interface->can_seek = stream_mem_can_seek;
+	interface->seek = stream_mem_seek;
+	interface->can_truncate = stream_mem_can_truncate;
+	interface->truncate_fn = stream_mem_truncate_fn;
 }
 
 static void
diff --git a/camel/camel-stream-mem.h b/camel/camel-stream-mem.h
index d66c8e6..75f92be 100644
--- a/camel/camel-stream-mem.h
+++ b/camel/camel-stream-mem.h
@@ -30,7 +30,7 @@
 #define CAMEL_STREAM_MEM_H
 
 #include <sys/types.h>
-#include <camel/camel-seekable-stream.h>
+#include <camel/camel-stream.h>
 
 /* Standard GObject macros */
 #define CAMEL_TYPE_STREAM_MEM \
@@ -58,12 +58,12 @@ typedef struct _CamelStreamMemClass CamelStreamMemClass;
 typedef struct _CamelStreamMemPrivate CamelStreamMemPrivate;
 
 struct _CamelStreamMem {
-	CamelSeekableStream parent;
+	CamelStream parent;
 	CamelStreamMemPrivate *priv;
 };
 
 struct _CamelStreamMemClass {
-	CamelSeekableStreamClass parent_class;
+	CamelStreamClass parent_class;
 };
 
 GType		camel_stream_mem_get_type	(void);
diff --git a/camel/camel-stream.c b/camel/camel-stream.c
index c649b26..5dc1fe9 100644
--- a/camel/camel-stream.c
+++ b/camel/camel-stream.c
@@ -80,7 +80,13 @@ static gint
 stream_reset (CamelStream *stream,
               GError **error)
 {
-	return 0;
+	gboolean success = TRUE;
+
+	if (G_IS_SEEKABLE (stream))
+		success = g_seekable_seek (
+			G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, error);
+
+	return success ? 0 : -1;
 }
 
 static void
diff --git a/camel/camel.h b/camel/camel.h
index c3ac9a2..9119bdc 100644
--- a/camel/camel.h
+++ b/camel/camel.h
@@ -105,7 +105,6 @@
 #include <camel/camel-sasl-ntlm.h>
 #include <camel/camel-sasl-plain.h>
 #include <camel/camel-sasl-popb4smtp.h>
-#include <camel/camel-seekable-stream.h>
 #include <camel/camel-service.h>
 #include <camel/camel-session.h>
 #include <camel/camel-smime-context.h>
diff --git a/camel/providers/imap/camel-imap-search.c b/camel/providers/imap/camel-imap-search.c
index baa5d66..9207381 100644
--- a/camel/providers/imap/camel-imap-search.c
+++ b/camel/providers/imap/camel-imap-search.c
@@ -245,7 +245,7 @@ save_match (CamelImapSearch *is, struct _match_record *mr)
 
 	if (camel_stream_write (stream, (gchar *)&header, sizeof (header), NULL, NULL) != sizeof (header)
 	    || camel_stream_write (stream, mr->matches->data, mr->matches->len*sizeof (guint32), NULL, NULL) != mr->matches->len*sizeof (guint32)
-	    || camel_seekable_stream_seek ((CamelSeekableStream *)stream, 0, G_SEEK_SET, NULL) == -1
+	    || !g_seekable_seek (G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL)
 	    || camel_stream_write (stream, (gchar *)&mark, sizeof (mark), NULL, NULL) != sizeof (mark)) {
 		d(printf(" saving failed, removing cache entry\n"));
 		camel_data_cache_remove(is->cache, "search/body-contains", mr->hash, NULL);
diff --git a/camel/providers/imapx/camel-imapx-server.c b/camel/providers/imapx/camel-imapx-server.c
index 9225c0c..d7d3ce3 100644
--- a/camel/providers/imapx/camel-imapx-server.c
+++ b/camel/providers/imapx/camel-imapx-server.c
@@ -1400,7 +1400,7 @@ imapx_untagged (CamelIMAPXServer *imap,
 			if (job && job->error == NULL) {
 				if (job->u.get_message.use_multi_fetch) {
 					job->u.get_message.body_offset = finfo->offset;
-					camel_seekable_stream_seek ((CamelSeekableStream *)job->u.get_message.stream, finfo->offset, G_SEEK_SET, NULL);
+					g_seekable_seek (G_SEEKABLE (job->u.get_message.stream), finfo->offset, G_SEEK_SET, NULL, NULL);
 				}
 
 				job->u.get_message.body_len = camel_stream_write_to_stream (finfo->body, job->u.get_message.stream, job->cancellable, &job->error);
@@ -3261,7 +3261,7 @@ imapx_command_fetch_message_done (CamelIMAPXServer *is, CamelIMAPXCommand *ic)
 		failed = TRUE;
 		job->u.get_message.body_len = -1;
 	} else  if (job->u.get_message.use_multi_fetch) {
-		gsize really_fetched = CAMEL_SEEKABLE_STREAM (job->u.get_message.stream)->position;
+		gsize really_fetched = g_seekable_tell (G_SEEKABLE (job->u.get_message.stream));
 		/* Don't automatically stop when we reach the reported message
 		   size -- some crappy servers (like Microsoft Exchange) have
 		   a tendency to lie about it. Keep going (one request at a
diff --git a/docs/reference/camel/camel-docs.sgml b/docs/reference/camel/camel-docs.sgml
index ce7c76a..9646f51 100644
--- a/docs/reference/camel/camel-docs.sgml
+++ b/docs/reference/camel/camel-docs.sgml
@@ -50,7 +50,6 @@
     <chapter id="Streams">
       <title>Streams</title>
       <xi:include href="xml/camel-stream.xml"/>
-      <xi:include href="xml/camel-seekable-stream.xml"/>
       <xi:include href="xml/camel-stream-buffer.xml"/>
       <xi:include href="xml/camel-stream-filter.xml"/>
       <xi:include href="xml/camel-stream-fs.xml"/>
diff --git a/docs/reference/camel/camel-sections.txt b/docs/reference/camel/camel-sections.txt
index a61adb4..49e09ad 100644
--- a/docs/reference/camel/camel-sections.txt
+++ b/docs/reference/camel/camel-sections.txt
@@ -1869,26 +1869,6 @@ camel_sexp_to_sql_sexp
 </SECTION>
 
 <SECTION>
-<FILE>camel-seekable-stream</FILE>
-<TITLE>CamelSeekableStream</TITLE>
-CamelSeekableStream
-CAMEL_STREAM_UNBOUND
-camel_seekable_stream_seek
-camel_seekable_stream_tell
-camel_seekable_stream_set_bounds
-<SUBSECTION Standard>
-CAMEL_SEEKABLE_STREAM
-CAMEL_IS_SEEKABLE_STREAM
-CAMEL_TYPE_SEEKABLE_STREAM
-CAMEL_SEEKABLE_STREAM_CLASS
-CAMEL_IS_SEEKABLE_STREAM_CLASS
-CAMEL_SEEKABLE_STREAM_GET_CLASS
-CamelSeekableStreamClass
-<SUBSECTION Private>
-camel_seekable_stream_get_type
-</SECTION>
-
-<SECTION>
 <FILE>camel-service</FILE>
 <TITLE>CamelService</TITLE>
 CamelService
diff --git a/docs/reference/camel/camel.types b/docs/reference/camel/camel.types
index 2350d98..e7ee97b 100644
--- a/docs/reference/camel/camel.types
+++ b/docs/reference/camel/camel.types
@@ -62,7 +62,6 @@ camel_sasl_login_get_type
 camel_sasl_ntlm_get_type
 camel_sasl_plain_get_type
 camel_sasl_popb4smtp_get_type
-camel_seekable_stream_get_type
 camel_service_get_type
 camel_session_get_type
 camel_smime_context_get_type
diff --git a/docs/reference/camel/tmpl/camel-unused.sgml b/docs/reference/camel/tmpl/camel-unused.sgml
index 8945604..9953772 100644
--- a/docs/reference/camel/tmpl/camel-unused.sgml
+++ b/docs/reference/camel/tmpl/camel-unused.sgml
@@ -3030,6 +3030,12 @@ streams
 </para>
 
 
+<!-- ##### MACRO CAMEL_STREAM_UNBOUND ##### -->
+<para>
+
+</para>
+
+
 <!-- ##### MACRO CAMEL_TCP_STREAM_SSL_ENABLE_SSL2 ##### -->
 <para>
 
@@ -4362,6 +4368,12 @@ streams
 @old_base: 
 @new: 
 
+<!-- ##### STRUCT CamelSeekableStream ##### -->
+<para>
+
+</para>
+
+
 <!-- ##### STRUCT CamelSeekableSubstream ##### -->
 <para>
 
@@ -8458,6 +8470,17 @@ streams
 @type: 
 @words: 
 
+<!-- ##### FUNCTION camel_seekable_stream_set_bounds ##### -->
+<para>
+
+</para>
+
+ stream: 
+ start: 
+ end: 
+ error: 
+ Returns: 
+
 <!-- ##### FUNCTION camel_seekable_substream_new ##### -->
 <para>
[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]