1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: Alexander Larsson <alexl@redhat.com>
26 #include <gfileoutputstream.h>
27 #include <gseekable.h>
28 #include "gsimpleasyncresult.h"
34 * SECTION:gfileoutputstream
35 * @short_description: File output streaming operations
36 * @see_also: #GOutputStream, #GDataOutputStream, #GSeekable
42 static void g_file_output_stream_seekable_iface_init (GSeekableIface *iface);
43 static goffset g_file_output_stream_seekable_tell (GSeekable *seekable);
44 static gboolean g_file_output_stream_seekable_can_seek (GSeekable *seekable);
45 static gboolean g_file_output_stream_seekable_seek (GSeekable *seekable,
48 GCancellable *cancellable,
50 static gboolean g_file_output_stream_seekable_can_truncate (GSeekable *seekable);
51 static gboolean g_file_output_stream_seekable_truncate (GSeekable *seekable,
53 GCancellable *cancellable,
55 static void g_file_output_stream_real_query_info_async (GFileOutputStream *stream,
58 GCancellable *cancellable,
59 GAsyncReadyCallback callback,
61 static GFileInfo *g_file_output_stream_real_query_info_finish (GFileOutputStream *stream,
65 G_DEFINE_TYPE_WITH_CODE (GFileOutputStream, g_file_output_stream, G_TYPE_OUTPUT_STREAM,
66 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
67 g_file_output_stream_seekable_iface_init));
69 struct _GFileOutputStreamPrivate {
70 GAsyncReadyCallback outstanding_callback;
74 g_file_output_stream_class_init (GFileOutputStreamClass *klass)
76 g_type_class_add_private (klass, sizeof (GFileOutputStreamPrivate));
78 klass->query_info_async = g_file_output_stream_real_query_info_async;
79 klass->query_info_finish = g_file_output_stream_real_query_info_finish;
83 g_file_output_stream_seekable_iface_init (GSeekableIface *iface)
85 iface->tell = g_file_output_stream_seekable_tell;
86 iface->can_seek = g_file_output_stream_seekable_can_seek;
87 iface->seek = g_file_output_stream_seekable_seek;
88 iface->can_truncate = g_file_output_stream_seekable_can_truncate;
89 iface->truncate = g_file_output_stream_seekable_truncate;
93 g_file_output_stream_init (GFileOutputStream *stream)
95 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
96 G_TYPE_FILE_OUTPUT_STREAM,
97 GFileOutputStreamPrivate);
101 * g_file_output_stream_query_info:
102 * @stream: a #GFileOutputStream.
103 * @attributes: a file attribute query string.
104 * @cancellable: optional #GCancellable object, %NULL to ignore.
105 * @error: a #GError, %NULL to ignore.
107 * Queries a file output stream for the given @attributes.
108 * This function blocks while querying the stream. For the asynchronous
109 * version of this function, see g_file_output_stream_query_info_async().
110 * While the stream is blocked, the stream will set the pending flag
111 * internally, and any other operations on the stream will fail with
112 * %G_IO_ERROR_PENDING.
114 * Can fail if the stream was already closed (with @error being set to
115 * %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
116 * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
117 * the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In
118 * all cases of failure, %NULL will be returned.
120 * If @cancellable is not %NULL, then the operation can be cancelled by
121 * triggering the cancellable object from another thread. If the operation
122 * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
125 * Returns: a #GFileInfo for the @stream, or %NULL on error.
128 g_file_output_stream_query_info (GFileOutputStream *stream,
130 GCancellable *cancellable,
133 GFileOutputStreamClass *class;
134 GOutputStream *output_stream;
137 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
139 output_stream = G_OUTPUT_STREAM (stream);
141 if (g_output_stream_is_closed (output_stream))
143 g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
144 _("Stream is already closed"));
148 if (g_output_stream_has_pending (output_stream))
150 g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
151 _("Stream has outstanding operation"));
157 g_output_stream_set_pending (output_stream, TRUE);
160 g_push_current_cancellable (cancellable);
162 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
163 if (class->query_info)
164 info = class->query_info (stream, attributes, cancellable, error);
166 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
167 _("Stream doesn't support query_info"));
170 g_pop_current_cancellable (cancellable);
172 g_output_stream_set_pending (output_stream, FALSE);
178 async_ready_callback_wrapper (GObject *source_object,
182 GFileOutputStream *stream = G_FILE_OUTPUT_STREAM (source_object);
184 g_output_stream_set_pending (G_OUTPUT_STREAM (stream), FALSE);
185 if (stream->priv->outstanding_callback)
186 (*stream->priv->outstanding_callback) (source_object, res, user_data);
187 g_object_unref (stream);
191 * g_file_output_stream_query_info_async:
192 * @stream: a #GFileOutputStream.
193 * @attributes: a file attribute query string.
194 * @io_priority: the <link linkend="gio-GIOScheduler">I/O priority</link>
196 * @cancellable: optional #GCancellable object, %NULL to ignore.
197 * @callback: callback to call when the request is satisfied
198 * @user_data: the data to pass to callback function
200 * Asynchronously queries the @stream for a #GFileInfo. When completed,
201 * @callback will be called with a #GAsyncResult which can be used to
202 * finish the operation with g_file_output_stream_query_info_finish().
204 * For the synchronous version of this function, see
205 * g_file_output_stream_query_info().
209 g_file_output_stream_query_info_async (GFileOutputStream *stream,
212 GCancellable *cancellable,
213 GAsyncReadyCallback callback,
216 GFileOutputStreamClass *klass;
217 GOutputStream *output_stream;
219 g_return_if_fail (G_IS_FILE_OUTPUT_STREAM (stream));
221 output_stream = G_OUTPUT_STREAM (stream);
223 if (g_output_stream_is_closed (output_stream))
225 g_simple_async_report_error_in_idle (G_OBJECT (stream),
228 G_IO_ERROR, G_IO_ERROR_CLOSED,
229 _("Stream is already closed"));
233 if (g_output_stream_has_pending (output_stream))
235 g_simple_async_report_error_in_idle (G_OBJECT (stream),
238 G_IO_ERROR, G_IO_ERROR_PENDING,
239 _("Stream has outstanding operation"));
243 klass = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
245 g_output_stream_set_pending (output_stream, TRUE);
246 stream->priv->outstanding_callback = callback;
247 g_object_ref (stream);
248 klass->query_info_async (stream, attributes, io_priority, cancellable,
249 async_ready_callback_wrapper, user_data);
253 * g_file_output_stream_query_info_finish:
254 * @stream: a #GFileOutputStream.
255 * @result: a #GAsyncResult.
256 * @error: a #GError, %NULL to ignore.
258 * Finalizes the asynchronous query started
259 * by g_file_output_stream_query_info_async().
261 * Returns: A #GFileInfo for the finished query.
264 g_file_output_stream_query_info_finish (GFileOutputStream *stream,
265 GAsyncResult *result,
268 GSimpleAsyncResult *simple;
269 GFileOutputStreamClass *class;
271 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
272 g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
274 if (G_IS_SIMPLE_ASYNC_RESULT (result))
276 simple = G_SIMPLE_ASYNC_RESULT (result);
277 if (g_simple_async_result_propagate_error (simple, error))
281 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
282 return class->query_info_finish (stream, result, error);
286 * g_file_output_stream_get_etag:
287 * @stream: a #GFileOutputStream.
289 * Gets the entity tag for the file output stream.
291 * Returns: the entity tag for the stream.
294 g_file_output_stream_get_etag (GFileOutputStream *stream)
296 GFileOutputStreamClass *class;
297 GOutputStream *output_stream;
300 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
302 output_stream = G_OUTPUT_STREAM (stream);
304 if (!g_output_stream_is_closed (output_stream))
306 g_warning ("stream is not closed yet, can't get etag");
312 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
314 etag = class->get_etag (stream);
320 * g_file_output_stream_tell:
321 * @stream: a #GFileOutputStream.
323 * Gets the current location within the stream.
325 * Returns: a #goffset of the location within the stream.
328 g_file_output_stream_tell (GFileOutputStream *stream)
330 GFileOutputStreamClass *class;
333 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), 0);
335 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
339 offset = class->tell (stream);
345 g_file_output_stream_seekable_tell (GSeekable *seekable)
347 return g_file_output_stream_tell (G_FILE_OUTPUT_STREAM (seekable));
351 * g_file_output_stream_can_seek:
352 * @stream: a #GFileOutputStream.
354 * Checks if the stream can be seeked.
356 * Returns: %TRUE if seeking is supported by the stream.
359 g_file_output_stream_can_seek (GFileOutputStream *stream)
361 GFileOutputStreamClass *class;
364 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);
366 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
373 can_seek = class->can_seek (stream);
380 g_file_output_stream_seekable_can_seek (GSeekable *seekable)
382 return g_file_output_stream_can_seek (G_FILE_OUTPUT_STREAM (seekable));
386 * g_file_output_stream_seek:
387 * @stream: a #GFileOutputStream.
388 * @offset: a #goffset to seek.
389 * @type: a #GSeekType.
390 * @cancellable: optional #GCancellable object, %NULL to ignore.
391 * @error: a #GError, %NULL to ignore.
393 * Seeks to a location in a file output stream.
395 * Returns: %TRUE if the seek was successful. %FALSE otherwise.
398 g_file_output_stream_seek (GFileOutputStream *stream,
401 GCancellable *cancellable,
404 GFileOutputStreamClass *class;
405 GOutputStream *output_stream;
408 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);
410 output_stream = G_OUTPUT_STREAM (stream);
411 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
413 if (g_output_stream_is_closed (output_stream))
415 g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
416 _("Stream is already closed"));
420 if (g_output_stream_has_pending (output_stream))
422 g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
423 _("Stream has outstanding operation"));
429 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
430 _("Seek not supported on stream"));
434 g_output_stream_set_pending (output_stream, TRUE);
437 g_push_current_cancellable (cancellable);
439 res = class->seek (stream, offset, type, cancellable, error);
442 g_pop_current_cancellable (cancellable);
444 g_output_stream_set_pending (output_stream, FALSE);
450 g_file_output_stream_seekable_seek (GSeekable *seekable,
453 GCancellable *cancellable,
456 return g_file_output_stream_seek (G_FILE_OUTPUT_STREAM (seekable),
457 offset, type, cancellable, error);
461 * g_file_output_stream_can_truncate:
462 * @stream: a #GFileOutputStream.
464 * Checks if the stream can be truncated.
466 * Returns: %TRUE if stream can be truncated.
469 g_file_output_stream_can_truncate (GFileOutputStream *stream)
471 GFileOutputStreamClass *class;
472 gboolean can_truncate;
474 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);
476 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
478 can_truncate = FALSE;
482 if (class->can_truncate)
483 can_truncate = class->can_truncate (stream);
490 g_file_output_stream_seekable_can_truncate (GSeekable *seekable)
492 return g_file_output_stream_can_truncate (G_FILE_OUTPUT_STREAM (seekable));
496 * g_file_output_stream_truncate:
497 * @stream: a #GFileOutputStream.
498 * @size: a #goffset to truncate the stream at.
499 * @cancellable: optional #GCancellable object, %NULL to ignore.
500 * @error: a #GError, %NULL to ignore.
502 * Truncates a file output stream.
504 * Returns: %TRUE if @stream is truncated successfully.
507 g_file_output_stream_truncate (GFileOutputStream *stream,
509 GCancellable *cancellable,
512 GFileOutputStreamClass *class;
513 GOutputStream *output_stream;
516 g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);
518 output_stream = G_OUTPUT_STREAM (stream);
519 class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
521 if (g_output_stream_is_closed (output_stream))
523 g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
524 _("Stream is already closed"));
528 if (g_output_stream_has_pending (output_stream))
530 g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
531 _("Stream has outstanding operation"));
535 if (!class->truncate)
537 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
538 _("Truncate not supported on stream"));
542 g_output_stream_set_pending (output_stream, TRUE);
545 g_push_current_cancellable (cancellable);
547 res = class->truncate (stream, size, cancellable, error);
550 g_pop_current_cancellable (cancellable);
552 g_output_stream_set_pending (output_stream, FALSE);
558 g_file_output_stream_seekable_truncate (GSeekable *seekable,
560 GCancellable *cancellable,
563 return g_file_output_stream_truncate (G_FILE_OUTPUT_STREAM (seekable),
564 size, cancellable, error);
566 /********************************************
567 * Default implementation of async ops *
568 ********************************************/
573 } QueryInfoAsyncData;
576 query_info_data_free (QueryInfoAsyncData *data)
579 g_object_unref (data->info);
580 g_free (data->attributes);
585 query_info_async_thread (GSimpleAsyncResult *res,
587 GCancellable *cancellable)
589 GFileOutputStreamClass *class;
590 GError *error = NULL;
591 QueryInfoAsyncData *data;
594 data = g_simple_async_result_get_op_res_gpointer (res);
598 class = G_FILE_OUTPUT_STREAM_GET_CLASS (object);
599 if (class->query_info)
600 info = class->query_info (G_FILE_OUTPUT_STREAM (object), data->attributes, cancellable, &error);
602 g_set_error (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
603 _("Stream doesn't support query_info"));
607 g_simple_async_result_set_from_error (res, error);
608 g_error_free (error);
615 g_file_output_stream_real_query_info_async (GFileOutputStream *stream,
618 GCancellable *cancellable,
619 GAsyncReadyCallback callback,
622 GSimpleAsyncResult *res;
623 QueryInfoAsyncData *data;
625 data = g_new0 (QueryInfoAsyncData, 1);
626 data->attributes = g_strdup (attributes);
628 res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_file_output_stream_real_query_info_async);
629 g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_info_data_free);
631 g_simple_async_result_run_in_thread (res, query_info_async_thread, io_priority, cancellable);
632 g_object_unref (res);
636 g_file_output_stream_real_query_info_finish (GFileOutputStream *stream,
640 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
641 QueryInfoAsyncData *data;
643 g_assert (g_simple_async_result_get_source_tag (simple) == g_file_output_stream_real_query_info_async);
645 data = g_simple_async_result_get_op_res_gpointer (simple);
647 return g_object_ref (data->info);
652 #define __G_FILE_OUTPUT_STREAM_C__
653 #include "gioaliasdef.c"