#include "ginputstream.h"
#include "gioerror.h"
#include "glibintl.h"
-
+#include "gpollableoutputstream.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()),
+ * #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()).
*
* is written or an error occurs; 0 is never returned (unless
* @count is 0).
*
- * If @cancellable is not NULL, then the operation can be cancelled by
+ * If @cancellable is not %NULL, then the operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
* was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
* operation was partially finished when the operation was cancelled the
*
* On error -1 is returned and @error is set accordingly.
*
+ * Virtual: write_fn
+ *
* Return value: Number of bytes written, or -1 on error
**/
gssize
* On a successful write of @count bytes, %TRUE is returned, and @bytes_written
* is set to @count.
*
- * If there is an error during the operation FALSE is returned and @error
+ * If there is an error during the operation %FALSE is returned and @error
* is set to indicate the error status, @bytes_written is updated to contain
* the number of bytes written into the stream before the error occurred.
*
}
/**
+ * g_output_stream_write_bytes:
+ * @stream: a #GOutputStream.
+ * @bytes: the #GBytes to write
+ * @cancellable: (allow-none): optional cancellable object
+ * @error: location to store the error occurring, or %NULL to ignore
+ *
+ * Tries to write the data from @bytes into the stream. Will block
+ * during the operation.
+ *
+ * If @bytes is 0-length, returns 0 and does nothing. A #GBytes larger
+ * than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+ *
+ * On success, the number of bytes written to the stream is returned.
+ * It is not an error if this is not the same as the requested size, as it
+ * can happen e.g. on a partial I/O error, or if there is not enough
+ * storage in the stream. All writes block until at least one byte
+ * is written or an error occurs; 0 is never returned (unless
+ * the size of @bytes is 0).
+ *
+ * If @cancellable is not %NULL, then the operation can be cancelled by
+ * triggering the cancellable object from another thread. If the operation
+ * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+ * operation was partially finished when the operation was cancelled the
+ * partial result will be returned, without an error.
+ *
+ * On error -1 is returned and @error is set accordingly.
+ *
+ * Return value: Number of bytes written, or -1 on error
+ **/
+gssize
+g_output_stream_write_bytes (GOutputStream *stream,
+ GBytes *bytes,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gsize size;
+ gconstpointer data;
+
+ data = g_bytes_get_data (bytes, &size);
+
+ return g_output_stream_write (stream,
+ data, size,
+ cancellable,
+ error);
+}
+
+/**
* g_output_stream_flush:
* @stream: a #GOutputStream.
* @cancellable: (allow-none): optional cancellable object
* @error: location to store the error occurring, or %NULL to ignore
*
- * Flushed any outstanding buffers in the stream. Will block during
- * the operation. Closing the stream will implicitly cause a flush.
+ * Forces a write of all user-space buffered data for the given
+ * @stream. Will block during the operation. Closing the stream will
+ * implicitly cause a flush.
*
* This function is optional for inherited classes.
*
* is important to check and report the error to the user, otherwise
* there might be a loss of data as all data might not be written.
*
- * If @cancellable is not NULL, then the operation can be cancelled by
+ * If @cancellable is not %NULL, then the operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
* was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
* Cancelling a close will still leave the stream closed, but there some streams
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), -1);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
+ if (g_async_result_legacy_propagate_error (result, error))
+ return -1;
+
if (G_IS_SIMPLE_ASYNC_RESULT (result))
{
simple = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (simple, error))
- return -1;
/* Special case writes of 0 bytes */
if (g_simple_async_result_get_source_tag (simple) == g_output_stream_write_async)
return class->write_finish (stream, result, error);
}
+static void
+write_bytes_callback (GObject *stream,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *simple = user_data;
+ GError *error = NULL;
+ gssize nwrote;
+
+ nwrote = g_output_stream_write_finish (G_OUTPUT_STREAM (stream),
+ result, &error);
+ if (nwrote == -1)
+ g_simple_async_result_take_error (simple, error);
+ else
+ g_simple_async_result_set_op_res_gssize (simple, nwrote);
+ g_simple_async_result_complete (simple);
+ g_object_unref (simple);
+}
+
+/**
+ * g_output_stream_write_bytes_async:
+ * @stream: A #GOutputStream.
+ * @bytes: The bytes to write
+ * @io_priority: the io priority of the request.
+ * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
+ * @callback: (scope async): callback to call when the request is satisfied
+ * @user_data: (closure): the data to pass to callback function
+ *
+ * Request an asynchronous write of the data in @bytes to the stream.
+ * When the operation is finished @callback will be called. You can
+ * then call g_output_stream_write_bytes_finish() to get the result of
+ * the operation.
+ *
+ * During an async request no other sync and async calls are allowed,
+ * and will result in %G_IO_ERROR_PENDING errors.
+ *
+ * A #GBytes larger than %G_MAXSSIZE will cause a
+ * %G_IO_ERROR_INVALID_ARGUMENT error.
+ *
+ * On success, the number of bytes written will be passed to the
+ * @callback. It is not an error if this is not the same as the
+ * requested size, as it can happen e.g. on a partial I/O error,
+ * but generally we try to write as many bytes as requested.
+ *
+ * You are guaranteed that this method will never fail with
+ * %G_IO_ERROR_WOULD_BLOCK - if @stream can't accept more data, the
+ * method will just wait until this changes.
+ *
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
+ * priority. Default priority is %G_PRIORITY_DEFAULT.
+ *
+ * For the synchronous, blocking version of this function, see
+ * g_output_stream_write_bytes().
+ **/
+void
+g_output_stream_write_bytes_async (GOutputStream *stream,
+ GBytes *bytes,
+ int io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *simple;
+ gsize size;
+ gconstpointer data;
+
+ data = g_bytes_get_data (bytes, &size);
+
+ simple = g_simple_async_result_new (G_OBJECT (stream),
+ callback, user_data,
+ g_output_stream_write_bytes_async);
+ g_simple_async_result_set_op_res_gpointer (simple, g_bytes_ref (bytes),
+ (GDestroyNotify) g_bytes_unref);
+
+ g_output_stream_write_async (stream,
+ data, size,
+ io_priority,
+ cancellable,
+ write_bytes_callback,
+ simple);
+}
+
+/**
+ * g_output_stream_write_bytes_finish:
+ * @stream: a #GOutputStream.
+ * @result: a #GAsyncResult.
+ * @error: a #GError location to store the error occurring, or %NULL to
+ * ignore.
+ *
+ * Finishes a stream write-from-#GBytes operation.
+ *
+ * Returns: a #gssize containing the number of bytes written to the stream.
+ **/
+gssize
+g_output_stream_write_bytes_finish (GOutputStream *stream,
+ GAsyncResult *result,
+ GError **error)
+{
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), -1);
+ g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (stream), g_output_stream_write_bytes_async), -1);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ if (g_simple_async_result_propagate_error (simple, error))
+ return -1;
+ return g_simple_async_result_get_op_res_gssize (simple);
+}
+
typedef struct {
GInputStream *source;
gpointer user_data;
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple;
GOutputStreamClass *class;
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), -1);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
- if (G_IS_SIMPLE_ASYNC_RESULT (result))
- {
- simple = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (simple, error))
- return -1;
- }
+ if (g_async_result_legacy_propagate_error (result, error))
+ return -1;
class = G_OUTPUT_STREAM_GET_CLASS (stream);
return class->splice_finish (stream, result, error);
* @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: (closure): the data to pass to callback function
*
- * Flushes a stream asynchronously.
+ * Forces an asynchronous write of all user-space buffered data for
+ * the given @stream.
* For behaviour details see g_output_stream_flush().
*
* When the operation is finished @callback will be
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
+ if (g_async_result_legacy_propagate_error (result, error))
+ return FALSE;
+
if (G_IS_SIMPLE_ASYNC_RESULT (result))
{
simple = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (simple, error))
- return FALSE;
/* Special case default implementation */
if (g_simple_async_result_get_source_tag (simple) == g_output_stream_flush_async)
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
+ if (g_async_result_legacy_propagate_error (result, error))
+ return FALSE;
+
if (G_IS_SIMPLE_ASYNC_RESULT (result))
{
simple = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (simple, error))
- return FALSE;
/* Special case already closed */
if (g_simple_async_result_get_source_tag (simple) == g_output_stream_close_async)
const void *buffer;
gsize count_requested;
gssize count_written;
+
+ GCancellable *cancellable;
+ gint io_priority;
+ gboolean need_idle;
} WriteData;
static void
+free_write_data (WriteData *op)
+{
+ if (op->cancellable)
+ g_object_unref (op->cancellable);
+ g_slice_free (WriteData, op);
+}
+
+static void
write_async_thread (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
g_simple_async_result_take_error (res, error);
}
+static void write_async_pollable (GPollableOutputStream *stream,
+ GSimpleAsyncResult *result);
+
+static gboolean
+write_async_pollable_ready (GPollableOutputStream *stream,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *result = user_data;
+
+ write_async_pollable (stream, result);
+ return FALSE;
+}
+
+static void
+write_async_pollable (GPollableOutputStream *stream,
+ GSimpleAsyncResult *result)
+{
+ GError *error = NULL;
+ WriteData *op = g_simple_async_result_get_op_res_gpointer (result);
+
+ if (g_cancellable_set_error_if_cancelled (op->cancellable, &error))
+ op->count_written = -1;
+ else
+ {
+ op->count_written = G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream)->
+ write_nonblocking (stream, op->buffer, op->count_requested, &error);
+ }
+
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
+ {
+ GSource *source;
+
+ g_error_free (error);
+ op->need_idle = FALSE;
+
+ source = g_pollable_output_stream_create_source (stream, op->cancellable);
+ g_source_set_callback (source,
+ (GSourceFunc) write_async_pollable_ready,
+ g_object_ref (result), g_object_unref);
+ g_source_set_priority (source, op->io_priority);
+ g_source_attach (source, g_main_context_get_thread_default ());
+ g_source_unref (source);
+ return;
+ }
+
+ if (op->count_written == -1)
+ g_simple_async_result_take_error (result, error);
+
+ if (op->need_idle)
+ g_simple_async_result_complete_in_idle (result);
+ else
+ g_simple_async_result_complete (result);
+}
+
static void
g_output_stream_real_write_async (GOutputStream *stream,
const void *buffer,
GSimpleAsyncResult *res;
WriteData *op;
- op = g_new0 (WriteData, 1);
+ op = g_slice_new0 (WriteData);
res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_output_stream_real_write_async);
- g_simple_async_result_set_op_res_gpointer (res, op, g_free);
+ g_simple_async_result_set_op_res_gpointer (res, op, (GDestroyNotify) free_write_data);
op->buffer = buffer;
op->count_requested = count;
+ op->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
+ op->io_priority = io_priority;
+ op->need_idle = TRUE;
- g_simple_async_result_run_in_thread (res, write_async_thread, io_priority, cancellable);
+ if (G_IS_POLLABLE_OUTPUT_STREAM (stream) &&
+ g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (stream)))
+ write_async_pollable (G_POLLABLE_OUTPUT_STREAM (stream), res);
+ else
+ g_simple_async_result_run_in_thread (res, write_async_thread, io_priority, cancellable);
g_object_unref (res);
}
WriteData *op;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_output_stream_real_write_async);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return -1;
+
op = g_simple_async_result_get_op_res_gpointer (simple);
return op->count_written;
}
SpliceData *op;
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_output_stream_real_splice_async);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return -1;
+
op = g_simple_async_result_get_op_res_gpointer (simple);
return op->bytes_copied;
}
GAsyncResult *result,
GError **error)
{
+ GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
return TRUE;
}
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
+
g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_output_stream_real_close_async);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
return TRUE;
}