X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgoutputstream.c;h=111559968d96ae31d1c13a9c0b7dbb0ca7196c82;hb=4bc4590c7bb5d8e7c248347e4b702ab8b506d937;hp=b68593a4f6dbb54b9ad0c7b80eba924824998490;hpb=9c17697b56501d11b4c653432cc9e290347aa03e;p=platform%2Fupstream%2Fglib.git diff --git a/gio/goutputstream.c b/gio/goutputstream.c index b68593a..1115599 100644 --- a/gio/goutputstream.c +++ b/gio/goutputstream.c @@ -20,27 +20,37 @@ * Author: Alexander Larsson */ -#include +#include "config.h" #include "goutputstream.h" +#include "gcancellable.h" +#include "gasyncresult.h" #include "gsimpleasyncresult.h" +#include "ginputstream.h" +#include "gioerror.h" #include "glibintl.h" -#include "gioalias.h" /** * SECTION:goutputstream * @short_description: Base class for implementing streaming output * @include: gio/gio.h * + * GOutputStream has functions to write to a stream (g_output_stream_write()), + * to close a stream (g_output_stream_close()) and to flush pending writes + * (g_output_stream_flush()). * + * To copy the content of an input stream to an output stream without + * manually handling the reads and writes, use g_output_stream_splice(). + * + * All of these functions have async variants too. **/ -G_DEFINE_TYPE (GOutputStream, g_output_stream, G_TYPE_OBJECT); +G_DEFINE_ABSTRACT_TYPE (GOutputStream, g_output_stream, G_TYPE_OBJECT); struct _GOutputStreamPrivate { guint closed : 1; guint pending : 1; - guint cancelled : 1; + guint closing : 1; GAsyncReadyCallback outstanding_callback; }; @@ -89,10 +99,6 @@ static gboolean g_output_stream_real_close_finish (GOutputStream *s static void g_output_stream_finalize (GObject *object) { - GOutputStream *stream; - - stream = G_OUTPUT_STREAM (object); - G_OBJECT_CLASS (g_output_stream_parent_class)->finalize (object); } @@ -142,7 +148,7 @@ g_output_stream_init (GOutputStream *stream) /** * g_output_stream_write: * @stream: a #GOutputStream. - * @buffer: the buffer containing the data to write. + * @buffer: (array length=count) (element-type uint8): the buffer containing the data to write. * @count: the number of bytes to write * @cancellable: optional cancellable object * @error: location to store the error occuring, or %NULL to ignore @@ -220,7 +226,7 @@ g_output_stream_write (GOutputStream *stream, /** * g_output_stream_write_all: * @stream: a #GOutputStream. - * @buffer: the buffer containing the data to write. + * @buffer: (array length=count) (element-type uint8): the buffer containing the data to write. * @count: the number of bytes to write * @bytes_written: location to store the number of bytes that was * written to the stream @@ -334,13 +340,14 @@ g_output_stream_flush (GOutputStream *stream, * @stream: a #GOutputStream. * @source: a #GInputStream. * @flags: a set of #GOutputStreamSpliceFlags. - * @cancellable: optional #GCancellable object, %NULL to ignore. - * @error: a #GError location to store the error occuring, or %NULL to + * @cancellable: optional #GCancellable object, %NULL to ignore. + * @error: a #GError location to store the error occuring, or %NULL to * ignore. * * Splices an input stream into an output stream. * - * Returns: a #gssize containing the size of the data spliced. + * Returns: a #gssize containing the size of the data spliced, or + * -1 if an error occurred. **/ gssize g_output_stream_splice (GOutputStream *stream, @@ -350,7 +357,7 @@ g_output_stream_splice (GOutputStream *stream, GError **error) { GOutputStreamClass *class; - gboolean res; + gssize bytes_copied; g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), -1); g_return_val_if_fail (G_IS_INPUT_STREAM (source), -1); @@ -364,21 +371,20 @@ g_output_stream_splice (GOutputStream *stream, if (!g_output_stream_set_pending (stream, error)) return -1; - + class = G_OUTPUT_STREAM_GET_CLASS (stream); - res = TRUE; if (cancellable) g_cancellable_push_current (cancellable); - - res = class->splice (stream, source, flags, cancellable, error); - + + bytes_copied = class->splice (stream, source, flags, cancellable, error); + if (cancellable) g_cancellable_pop_current (cancellable); - + g_output_stream_clear_pending (stream); - return res; + return bytes_copied; } static gssize @@ -395,16 +401,16 @@ g_output_stream_real_splice (GOutputStream *stream, gboolean res; bytes_copied = 0; - if (class->write_fn == NULL) + if (class->write_fn == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Output stream doesn't implement write")); res = FALSE; goto notsupported; } - + res = TRUE; - do + do { n_read = g_input_stream_read (source, buffer, sizeof (buffer), cancellable, error); if (n_read == -1) @@ -412,7 +418,7 @@ g_output_stream_real_splice (GOutputStream *stream, res = FALSE; break; } - + if (n_read == 0) break; @@ -446,13 +452,14 @@ g_output_stream_real_splice (GOutputStream *stream, if (flags & G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET) { /* But write errors on close are bad! */ - if (!class->close_fn (stream, cancellable, error)) + if (class->close_fn && + !class->close_fn (stream, cancellable, error)) res = FALSE; } if (res) return bytes_copied; - + return -1; } @@ -513,6 +520,8 @@ g_output_stream_close (GOutputStream *stream, if (!g_output_stream_set_pending (stream, error)) return FALSE; + stream->priv->closing = TRUE; + if (cancellable) g_cancellable_push_current (cancellable); @@ -538,7 +547,8 @@ g_output_stream_close (GOutputStream *stream, if (cancellable) g_cancellable_pop_current (cancellable); - + + stream->priv->closing = FALSE; stream->priv->closed = TRUE; g_output_stream_clear_pending (stream); @@ -558,24 +568,89 @@ async_ready_callback_wrapper (GObject *source_object, g_object_unref (stream); } +typedef struct { + gint io_priority; + GCancellable *cancellable; + GError *flush_error; + gpointer user_data; +} CloseUserData; + static void async_ready_close_callback_wrapper (GObject *source_object, GAsyncResult *res, gpointer user_data) { GOutputStream *stream = G_OUTPUT_STREAM (source_object); + CloseUserData *data = user_data; + stream->priv->closing = FALSE; stream->priv->closed = TRUE; + g_output_stream_clear_pending (stream); + if (stream->priv->outstanding_callback) - (*stream->priv->outstanding_callback) (source_object, res, user_data); + { + if (data->flush_error != NULL) + { + GSimpleAsyncResult *err; + + err = g_simple_async_result_new_from_error (source_object, + stream->priv->outstanding_callback, + data->user_data, + data->flush_error); + + (*stream->priv->outstanding_callback) (source_object, + G_ASYNC_RESULT (err), + data->user_data); + g_object_unref (err); + } + else + { + (*stream->priv->outstanding_callback) (source_object, + res, + data->user_data); + } + } + g_object_unref (stream); + + if (data->cancellable) + g_object_unref (data->cancellable); + + if (data->flush_error) + g_error_free (data->flush_error); + + g_slice_free (CloseUserData, data); +} + +static void +async_ready_close_flushed_callback_wrapper (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GOutputStream *stream = G_OUTPUT_STREAM (source_object); + GOutputStreamClass *class; + CloseUserData *data = user_data; + GSimpleAsyncResult *simple; + + /* propagate the possible error */ + if (G_IS_SIMPLE_ASYNC_RESULT (res)) + { + simple = G_SIMPLE_ASYNC_RESULT (res); + g_simple_async_result_propagate_error (simple, &data->flush_error); + } + + class = G_OUTPUT_STREAM_GET_CLASS (stream); + + /* we still close, even if there was a flush error */ + class->close_async (stream, data->io_priority, data->cancellable, + async_ready_close_callback_wrapper, user_data); } /** * g_output_stream_write_async: * @stream: A #GOutputStream. - * @buffer: the buffer containing the data to write. + * @buffer: (array length=count) (element-type uint8): the buffer containing the data to write. * @count: the number of bytes to write * @io_priority: the io priority of the request. * @cancellable: optional #GCancellable object, %NULL to ignore. @@ -950,6 +1025,7 @@ g_output_stream_close_async (GOutputStream *stream, GOutputStreamClass *class; GSimpleAsyncResult *simple; GError *error = NULL; + CloseUserData *data; g_return_if_fail (G_IS_OUTPUT_STREAM (stream)); @@ -975,10 +1051,34 @@ g_output_stream_close_async (GOutputStream *stream, } class = G_OUTPUT_STREAM_GET_CLASS (stream); + stream->priv->closing = TRUE; stream->priv->outstanding_callback = callback; g_object_ref (stream); - class->close_async (stream, io_priority, cancellable, - async_ready_close_callback_wrapper, user_data); + + data = g_slice_new0 (CloseUserData); + + if (cancellable != NULL) + data->cancellable = g_object_ref (cancellable); + + data->io_priority = io_priority; + data->user_data = user_data; + + /* Call close_async directly if there is no need to flush, or if the flush + can be done sync (in the output stream async close thread) */ + if (class->flush_async == NULL || + (class->flush_async == g_output_stream_real_flush_async && + (class->flush == NULL || class->close_async == g_output_stream_real_close_async))) + { + class->close_async (stream, io_priority, cancellable, + async_ready_close_callback_wrapper, data); + } + else + { + /* First do an async flush, then do the async close in the callback + wrapper (see async_ready_close_flushed_callback_wrapper) */ + class->flush_async (stream, io_priority, cancellable, + async_ready_close_flushed_callback_wrapper, data); + } } /** @@ -1035,6 +1135,27 @@ g_output_stream_is_closed (GOutputStream *stream) } /** + * g_output_stream_is_closing: + * @stream: a #GOutputStream. + * + * Checks if an output stream is being closed. This can be + * used inside e.g. a flush implementation to see if the + * flush (or other i/o operation) is called from within + * the closing operation. + * + * Returns: %TRUE if @stream is being closed. %FALSE otherwise. + * + * Since: 2.24 + **/ +gboolean +g_output_stream_is_closing (GOutputStream *stream) +{ + g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), TRUE); + + return stream->priv->closing; +} + +/** * g_output_stream_has_pending: * @stream: a #GOutputStream. * @@ -1291,19 +1412,37 @@ close_async_thread (GSimpleAsyncResult *res, { GOutputStreamClass *class; GError *error = NULL; - gboolean result; + gboolean result = TRUE; + + class = G_OUTPUT_STREAM_GET_CLASS (object); + + /* Do a flush here if there is a flush function, and we did not have to do + an async flush before (see g_output_stream_close_async) */ + if (class->flush != NULL && + (class->flush_async == NULL || + class->flush_async == g_output_stream_real_flush_async)) + { + result = class->flush (G_OUTPUT_STREAM (object), cancellable, &error); + } /* Auto handling of cancelation disabled, and ignore cancellation, since we want to close things anyway, although possibly in a quick-n-dirty way. At least we never want to leak open handles */ - class = G_OUTPUT_STREAM_GET_CLASS (object); - result = class->close_fn (G_OUTPUT_STREAM (object), cancellable, &error); - if (!result) + if (class->close_fn) { - g_simple_async_result_set_from_error (res, error); - g_error_free (error); + /* Make sure to close, even if the flush failed (see sync close) */ + if (!result) + class->close_fn (G_OUTPUT_STREAM (object), cancellable, NULL); + else + result = class->close_fn (G_OUTPUT_STREAM (object), cancellable, &error); + + if (!result) + { + g_simple_async_result_set_from_error (res, error); + g_error_free (error); + } } } @@ -1333,6 +1472,3 @@ g_output_stream_real_close_finish (GOutputStream *stream, g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_output_stream_real_close_async); return TRUE; } - -#define __G_OUTPUT_STREAM_C__ -#include "gioaliasdef.c"