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 <gfileinputstream.h>
27 #include <gseekable.h>
28 #include "gsimpleasyncresult.h"
34 * SECTION:gfileinputstream
35 * @short_description: file input streaming operations
36 * @see_also: #GInputStream, #GDataInputStream, #GSeekable
42 static void g_file_input_stream_seekable_iface_init (GSeekableIface *iface);
43 static goffset g_file_input_stream_seekable_tell (GSeekable *seekable);
44 static gboolean g_file_input_stream_seekable_can_seek (GSeekable *seekable);
45 static gboolean g_file_input_stream_seekable_seek (GSeekable *seekable,
48 GCancellable *cancellable,
50 static gboolean g_file_input_stream_seekable_can_truncate (GSeekable *seekable);
51 static gboolean g_file_input_stream_seekable_truncate (GSeekable *seekable,
53 GCancellable *cancellable,
55 static void g_file_input_stream_real_query_info_async (GFileInputStream *stream,
58 GCancellable *cancellable,
59 GAsyncReadyCallback callback,
61 static GFileInfo *g_file_input_stream_real_query_info_finish (GFileInputStream *stream,
66 G_DEFINE_TYPE_WITH_CODE (GFileInputStream, g_file_input_stream, G_TYPE_INPUT_STREAM,
67 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
68 g_file_input_stream_seekable_iface_init))
70 struct _GFileInputStreamPrivate {
71 GAsyncReadyCallback outstanding_callback;
75 g_file_input_stream_class_init (GFileInputStreamClass *klass)
77 g_type_class_add_private (klass, sizeof (GFileInputStreamPrivate));
79 klass->query_info_async = g_file_input_stream_real_query_info_async;
80 klass->query_info_finish = g_file_input_stream_real_query_info_finish;
84 g_file_input_stream_seekable_iface_init (GSeekableIface *iface)
86 iface->tell = g_file_input_stream_seekable_tell;
87 iface->can_seek = g_file_input_stream_seekable_can_seek;
88 iface->seek = g_file_input_stream_seekable_seek;
89 iface->can_truncate = g_file_input_stream_seekable_can_truncate;
90 iface->truncate = g_file_input_stream_seekable_truncate;
94 g_file_input_stream_init (GFileInputStream *stream)
96 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
97 G_TYPE_FILE_INPUT_STREAM,
98 GFileInputStreamPrivate);
102 * g_file_input_stream_query_info:
103 * @stream: a #GFileInputStream.
104 * @attributes: a file attribute query string.
105 * @cancellable: optional #GCancellable object, %NULL to ignore.
106 * @error: a #GError location to store the error occuring, or %NULL to
109 * Queries a file input stream the given @attributes.his function blocks
110 * while querying the stream. For the asynchronous (non-blocking) version
111 * of this function, see g_file_input_stream_query_info_async(). While the
112 * stream is blocked, the stream will set the pending flag internally, and
113 * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
115 * Returns: a #GFileInfo, or %NULL on error.
118 g_file_input_stream_query_info (GFileInputStream *stream,
120 GCancellable *cancellable,
123 GFileInputStreamClass *class;
124 GInputStream *input_stream;
127 g_return_val_if_fail (G_IS_FILE_INPUT_STREAM (stream), NULL);
129 input_stream = G_INPUT_STREAM (stream);
131 if (g_input_stream_is_closed (input_stream))
133 g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
134 _("Stream is already closed"));
138 if (g_input_stream_has_pending (input_stream))
140 g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
141 _("Stream has outstanding operation"));
147 g_input_stream_set_pending (input_stream, TRUE);
150 g_push_current_cancellable (cancellable);
152 class = G_FILE_INPUT_STREAM_GET_CLASS (stream);
153 if (class->query_info)
154 info = class->query_info (stream, attributes, cancellable, error);
156 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
157 _("Stream doesn't support query_info"));
160 g_pop_current_cancellable (cancellable);
162 g_input_stream_set_pending (input_stream, FALSE);
168 async_ready_callback_wrapper (GObject *source_object,
172 GFileInputStream *stream = G_FILE_INPUT_STREAM (source_object);
174 g_input_stream_set_pending (G_INPUT_STREAM (stream), FALSE);
175 if (stream->priv->outstanding_callback)
176 (*stream->priv->outstanding_callback) (source_object, res, user_data);
177 g_object_unref (stream);
181 * g_file_input_stream_query_info_async:
182 * @stream: a #GFileInputStream.
183 * @attributes: a file attribute query string.
184 * @io_priority: the i/o priority of the request.
185 * @cancellable: optional #GCancellable object, %NULL to ignore.
186 * @callback: callback to call when the request is satisfied
187 * @user_data: the data to pass to callback function
189 * Queries the stream information asynchronously. For the synchronous
190 * version of this function, see g_file_input_stream_query_info().
192 * If @cancellable is not %NULL, then the operation can be cancelled by
193 * triggering the cancellable object from another thread. If the operation
194 * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
198 g_file_input_stream_query_info_async (GFileInputStream *stream,
201 GCancellable *cancellable,
202 GAsyncReadyCallback callback,
205 GFileInputStreamClass *klass;
206 GInputStream *input_stream;
208 g_return_if_fail (G_IS_FILE_INPUT_STREAM (stream));
210 input_stream = G_INPUT_STREAM (stream);
212 if (g_input_stream_is_closed (input_stream))
214 g_simple_async_report_error_in_idle (G_OBJECT (stream),
217 G_IO_ERROR, G_IO_ERROR_CLOSED,
218 _("Stream is already closed"));
222 if (g_input_stream_has_pending (input_stream))
224 g_simple_async_report_error_in_idle (G_OBJECT (stream),
227 G_IO_ERROR, G_IO_ERROR_PENDING,
228 _("Stream has outstanding operation"));
232 klass = G_FILE_INPUT_STREAM_GET_CLASS (stream);
234 g_input_stream_set_pending (input_stream, TRUE);
235 stream->priv->outstanding_callback = callback;
236 g_object_ref (stream);
237 klass->query_info_async (stream, attributes, io_priority, cancellable,
238 async_ready_callback_wrapper, user_data);
242 * g_file_input_stream_query_info_finish:
243 * @stream: a #GFileInputStream.
244 * @result: a #GAsyncResult.
245 * @error: a #GError location to store the error occuring,
246 * or %NULL to ignore.
248 * Finishes an asynchronous info query operation.
250 * Returns: #GFileInfo.
253 g_file_input_stream_query_info_finish (GFileInputStream *stream,
254 GAsyncResult *result,
257 GSimpleAsyncResult *simple;
258 GFileInputStreamClass *class;
260 g_return_val_if_fail (G_IS_FILE_INPUT_STREAM (stream), NULL);
261 g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
263 if (G_IS_SIMPLE_ASYNC_RESULT (result))
265 simple = G_SIMPLE_ASYNC_RESULT (result);
266 if (g_simple_async_result_propagate_error (simple, error))
270 class = G_FILE_INPUT_STREAM_GET_CLASS (stream);
271 return class->query_info_finish (stream, result, error);
275 * g_file_input_stream_tell:
276 * @stream: a #GFileInputStream.
278 * Gets the current position in the stream.
280 * Returns: a #goffset with the position in the stream.
283 g_file_input_stream_tell (GFileInputStream *stream)
285 GFileInputStreamClass *class;
288 g_return_val_if_fail (G_IS_FILE_INPUT_STREAM (stream), 0);
290 class = G_FILE_INPUT_STREAM_GET_CLASS (stream);
294 offset = class->tell (stream);
300 g_file_input_stream_seekable_tell (GSeekable *seekable)
302 return g_file_input_stream_tell (G_FILE_INPUT_STREAM (seekable));
306 * g_file_input_stream_can_seek:
307 * @stream: a #GFileInputStream.
309 * Checks if a file input stream can be seeked.
311 * Returns: %TRUE if stream can be seeked. %FALSE otherwise.
314 g_file_input_stream_can_seek (GFileInputStream *stream)
316 GFileInputStreamClass *class;
319 g_return_val_if_fail (G_IS_FILE_INPUT_STREAM (stream), FALSE);
321 class = G_FILE_INPUT_STREAM_GET_CLASS (stream);
328 can_seek = class->can_seek (stream);
335 g_file_input_stream_seekable_can_seek (GSeekable *seekable)
337 return g_file_input_stream_can_seek (G_FILE_INPUT_STREAM (seekable));
341 * g_file_input_stream_seek:
342 * @stream: a #GFileInputStream.
343 * @offset: a #goffset to seek.
344 * @type: a #GSeekType.
345 * @cancellable: optional #GCancellable object, %NULL to ignore.
346 * @error: a #GError location to store the error occuring, or
349 * Seeks in the file input stream.
351 * If @cancellable is not %NULL, then the operation can be cancelled by
352 * triggering the cancellable object from another thread. If the operation
353 * was cancelled, the error %G_IO_ERROR_CANCELLED will be set.
355 * Returns: %TRUE if the stream was successfully seeked to the position.
359 g_file_input_stream_seek (GFileInputStream *stream,
362 GCancellable *cancellable,
365 GFileInputStreamClass *class;
366 GInputStream *input_stream;
369 g_return_val_if_fail (G_IS_FILE_INPUT_STREAM (stream), FALSE);
371 input_stream = G_INPUT_STREAM (stream);
372 class = G_FILE_INPUT_STREAM_GET_CLASS (stream);
374 if (g_input_stream_is_closed (input_stream))
376 g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
377 _("Stream is already closed"));
381 if (g_input_stream_has_pending (input_stream))
383 g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
384 _("Stream has outstanding operation"));
390 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
391 _("Seek not supported on stream"));
395 g_input_stream_set_pending (input_stream, TRUE);
398 g_push_current_cancellable (cancellable);
400 res = class->seek (stream, offset, type, cancellable, error);
403 g_pop_current_cancellable (cancellable);
405 g_input_stream_set_pending (input_stream, FALSE);
411 g_file_input_stream_seekable_seek (GSeekable *seekable,
414 GCancellable *cancellable,
417 return g_file_input_stream_seek (G_FILE_INPUT_STREAM (seekable),
418 offset, type, cancellable, error);
422 g_file_input_stream_seekable_can_truncate (GSeekable *seekable)
428 g_file_input_stream_seekable_truncate (GSeekable *seekable,
430 GCancellable *cancellable,
433 g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
434 _("Truncate not allowed on input stream"));
438 /********************************************
439 * Default implementation of async ops *
440 ********************************************/
445 } QueryInfoAsyncData;
448 query_info_data_free (QueryInfoAsyncData *data)
451 g_object_unref (data->info);
452 g_free (data->attributes);
457 query_info_async_thread (GSimpleAsyncResult *res,
459 GCancellable *cancellable)
461 GFileInputStreamClass *class;
462 GError *error = NULL;
463 QueryInfoAsyncData *data;
466 data = g_simple_async_result_get_op_res_gpointer (res);
470 class = G_FILE_INPUT_STREAM_GET_CLASS (object);
471 if (class->query_info)
472 info = class->query_info (G_FILE_INPUT_STREAM (object), data->attributes, cancellable, &error);
474 g_set_error (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
475 _("Stream doesn't support query_info"));
479 g_simple_async_result_set_from_error (res, error);
480 g_error_free (error);
487 g_file_input_stream_real_query_info_async (GFileInputStream *stream,
490 GCancellable *cancellable,
491 GAsyncReadyCallback callback,
494 GSimpleAsyncResult *res;
495 QueryInfoAsyncData *data;
497 data = g_new0 (QueryInfoAsyncData, 1);
498 data->attributes = g_strdup (attributes);
500 res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_file_input_stream_real_query_info_async);
501 g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)query_info_data_free);
503 g_simple_async_result_run_in_thread (res, query_info_async_thread, io_priority, cancellable);
504 g_object_unref (res);
508 g_file_input_stream_real_query_info_finish (GFileInputStream *stream,
512 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
513 QueryInfoAsyncData *data;
515 g_assert (g_simple_async_result_get_source_tag (simple) == g_file_input_stream_real_query_info_async);
517 data = g_simple_async_result_get_op_res_gpointer (simple);
519 return g_object_ref (data->info);
524 #define __G_FILE_INPUT_STREAM_C__
525 #include "gioaliasdef.c"