evolution/camel/camel-simple-data-wrapper-stream.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* camel-simple-data-wrapper-stream.c
 *
 * Copyright 1999, 2000 HelixCode (http://www.helixcode.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Ettore Perazzoli
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "camel-simple-data-wrapper-stream.h"


static CamelStreamClass *parent_class = NULL;


/* CamelStream methods.  */

static	gint 
read (CamelStream *stream,
      gchar *buffer,
      gint n)
{
	CamelSimpleDataWrapperStream *wrapper_stream;
	CamelSimpleDataWrapper *wrapper;
	GByteArray *array;
	gint len;

	wrapper_stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (stream);
	wrapper = wrapper_stream->wrapper;
	g_return_val_if_fail (wrapper != NULL, -1);
	array = wrapper->byte_array;

	len = MIN (n, array->len - wrapper_stream->current_position);
	if (len > 0) {
		memcpy (buffer, wrapper_stream->current_position + array->data, len);
		wrapper_stream->current_position += len;
		return len;
	} else {
		return 0;
	}
}

static	gint 
write (CamelStream *stream,
       const gchar *buffer,
       gint n)
{
	CamelSimpleDataWrapperStream *wrapper_stream;
	CamelSimpleDataWrapper *wrapper;
	GByteArray *array;
	gint len;
	const gchar *buffer_next;
	gint left;

	wrapper_stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (stream);
	wrapper = wrapper_stream->wrapper;
	g_return_val_if_fail (wrapper != NULL, -1);
	array = wrapper->byte_array;

	len = MIN (n, array->len - wrapper_stream->current_position);
	if (len > 0) {
		memcpy (array->data, buffer, len);
		buffer_next = buffer + len;
		left = n - len;
	} else {
		/* If we are past the end of the array, fill with zeros.  */
		if (wrapper_stream->current_position > array->len) {
			gint saved_length;

			saved_length = array->len;
			g_byte_array_set_size
				(array, wrapper_stream->current_position);
			memset (array->data + saved_length,
				0,
				(wrapper_stream->current_position
				 - saved_length));
		}

		buffer_next = buffer;
		left = n;
	}

	if (n > 0)
		g_byte_array_append (array, buffer_next, left);

	wrapper_stream->current_position += n;
	return n;
}

static void 
flush (CamelStream *stream)
{
	/* No op, as we don't do any buffering.  */
}

static gint 
available (CamelStream *stream)
{
	CamelSimpleDataWrapperStream *wrapper_stream;
	CamelSimpleDataWrapper *wrapper;
	GByteArray *array;
	gint available;

	wrapper_stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (stream);
	wrapper = wrapper_stream->wrapper;
	g_return_val_if_fail (wrapper != NULL, -1);
	array = wrapper->byte_array;

	available = array->len - wrapper_stream->current_position;
	return MAX (available, 0);
}

static gboolean
eos (CamelStream *stream)
{
	if (available (stream) > 0)
		return TRUE;
	else
		return FALSE;
}

static void 
close (CamelStream *stream)
{
	/* Nothing to do, we have no associated file descriptor.  */
}

static gint
seek (CamelSeekableStream *stream,
      gint offset,
      CamelStreamSeekPolicy policy)
{
	CamelSimpleDataWrapperStream *wrapper_stream;
	gint new_position;

	wrapper_stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (stream);

	switch (policy) {
	case CAMEL_STREAM_SET:
		new_position = offset;
		break;
	case CAMEL_STREAM_CUR:
		new_position = wrapper_stream->current_position + offset;
		break;
	case CAMEL_STREAM_END:
		new_position = wrapper_stream->wrapper->byte_array->len - offset;
		break;
	default:
		g_warning ("Unknown CamelStreamSeekPolicy %d.", policy);
		return -1;
	}

	if (new_position<0)
		new_position = 0;
	else if (new_position>=wrapper_stream->wrapper->byte_array->len)
		new_position = wrapper_stream->wrapper->byte_array->len-1;

	wrapper_stream->current_position = new_position;
	return new_position;
}


/* This handles destruction of the associated CamelDataWrapper.  */
/* Hm, this should never happen though, because we gtk_object_ref() the
   wrapper.  */
static void
wrapper_destroy_cb (GtkObject *object,
		    gpointer data)
{
	CamelSimpleDataWrapperStream *stream;

	g_warning ("CamelSimpleDataWrapperStream: associated CamelSimpleDataWrapper was destroyed.");
	stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (object);
	stream->wrapper = NULL;
}


/* GtkObject methods.  */

static void
destroy (GtkObject *object)
{
	CamelSimpleDataWrapperStream *stream;

	stream = CAMEL_SIMPLE_DATA_WRAPPER_STREAM (object);

	gtk_object_unref (GTK_OBJECT (stream->wrapper));

	if (GTK_OBJECT_CLASS (parent_class)->destroy != NULL)
		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}


static void
class_init (CamelSimpleDataWrapperStreamClass *klass)
{
	GtkObjectClass *object_class;
	CamelStreamClass *stream_class;
	CamelSeekableStreamClass *seek_class;

	object_class = (GtkObjectClass*) klass;
	stream_class = (CamelStreamClass *)klass;
	seek_class = (CamelSeekableStreamClass *)klass;

	stream_class->read = read;
	stream_class->write = write;
	stream_class->flush = flush;
	stream_class->available = available;
	stream_class->eos = eos;
	stream_class->close = close;

	seek_class->seek = seek;

	object_class->destroy = destroy;

	parent_class = gtk_type_class (camel_stream_get_type ());
}

static void
init (CamelSimpleDataWrapperStream *simple_data_wrapper_stream)
{
	simple_data_wrapper_stream->current_position = 0;
}


GtkType
camel_simple_data_wrapper_stream_get_type (void)
{
	static GtkType type = 0;

	if (type == 0) {
		static const GtkTypeInfo info = {
			"CamelSimpleDataWrapperStream",
			sizeof (CamelSimpleDataWrapperStream),
			sizeof (CamelSimpleDataWrapperStreamClass),
			(GtkClassInitFunc) class_init,
			(GtkObjectInitFunc) init,
			/* reserved_1 */ NULL,
			/* reserved_2 */ NULL,
			(GtkClassInitFunc) NULL,
		};

		type = gtk_type_unique (camel_stream_get_type (), &info);
	}

	return type;
}

void
camel_simple_data_wrapper_stream_construct (CamelSimpleDataWrapperStream *stream,
					    CamelSimpleDataWrapper *wrapper)
{
	g_return_if_fail (stream != NULL);
	g_return_if_fail (CAMEL_IS_SIMPLE_DATA_WRAPPER_STREAM (stream));
	g_return_if_fail (wrapper != NULL);
	g_return_if_fail (CAMEL_IS_SIMPLE_DATA_WRAPPER (wrapper));

	gtk_object_ref (GTK_OBJECT (wrapper));
	stream->wrapper = wrapper;
#if 0
	gtk_signal_connect (GTK_OBJECT (wrapper), "destroy",
			    wrapper_destroy_cb, stream);
#endif
}

CamelStream *
camel_simple_data_wrapper_stream_new (CamelSimpleDataWrapper *wrapper)
{
	CamelStream *stream;

	g_return_val_if_fail (wrapper != NULL, NULL);
	g_return_val_if_fail (CAMEL_IS_SIMPLE_DATA_WRAPPER (wrapper), NULL);

	stream = gtk_type_new (camel_simple_data_wrapper_stream_get_type ());

	camel_simple_data_wrapper_stream_construct
		(CAMEL_SIMPLE_DATA_WRAPPER_STREAM (stream), wrapper);

	return stream;
}