1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 * Copyright (C) 2007 Jürg Billeter
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19 * Boston, MA 02111-1307, USA.
21 * Author: Christian Kellner <gicmo@gnome.org>
25 #include "gbufferedinputstream.h"
26 #include "ginputstream.h"
27 #include "gcancellable.h"
28 #include "gasyncresult.h"
29 #include "gsimpleasyncresult.h"
30 #include "gseekable.h"
37 * SECTION:gbufferedinputstream
38 * @short_description: Buffered Input Stream
40 * @see_also: #GFilterInputStream, #GInputStream
42 * Buffered input stream implements #GFilterInputStream and provides
45 * By default, #GBufferedInputStream's buffer size is set at 4 kilobytes.
47 * To create a buffered input stream, use g_buffered_input_stream_new(),
48 * or g_buffered_input_stream_new_sized() to specify the buffer's size at
51 * To get the size of a buffer within a buffered input stream, use
52 * g_buffered_input_stream_get_buffer_size(). To change the size of a
53 * buffered input stream's buffer, use
54 * g_buffered_input_stream_set_buffer_size(). Note that the buffer's size
55 * cannot be reduced below the size of the data within the buffer.
59 #define DEFAULT_BUFFER_SIZE 4096
61 struct _GBufferedInputStreamPrivate
{
66 GAsyncReadyCallback outstanding_callback
;
74 static void g_buffered_input_stream_set_property (GObject
*object
,
79 static void g_buffered_input_stream_get_property (GObject
*object
,
83 static void g_buffered_input_stream_finalize (GObject
*object
);
86 static gssize
g_buffered_input_stream_skip (GInputStream
*stream
,
88 GCancellable
*cancellable
,
90 static void g_buffered_input_stream_skip_async (GInputStream
*stream
,
93 GCancellable
*cancellable
,
94 GAsyncReadyCallback callback
,
96 static gssize
g_buffered_input_stream_skip_finish (GInputStream
*stream
,
99 static gssize
g_buffered_input_stream_read (GInputStream
*stream
,
102 GCancellable
*cancellable
,
104 static gssize
g_buffered_input_stream_real_fill (GBufferedInputStream
*stream
,
106 GCancellable
*cancellable
,
108 static void g_buffered_input_stream_real_fill_async (GBufferedInputStream
*stream
,
111 GCancellable
*cancellable
,
112 GAsyncReadyCallback callback
,
114 static gssize
g_buffered_input_stream_real_fill_finish (GBufferedInputStream
*stream
,
115 GAsyncResult
*result
,
118 static void g_buffered_input_stream_seekable_iface_init (GSeekableIface
*iface
);
119 static goffset
g_buffered_input_stream_tell (GSeekable
*seekable
);
120 static gboolean
g_buffered_input_stream_can_seek (GSeekable
*seekable
);
121 static gboolean
g_buffered_input_stream_seek (GSeekable
*seekable
,
124 GCancellable
*cancellable
,
126 static gboolean
g_buffered_input_stream_can_truncate (GSeekable
*seekable
);
127 static gboolean
g_buffered_input_stream_truncate (GSeekable
*seekable
,
129 GCancellable
*cancellable
,
132 static void g_buffered_input_stream_finalize (GObject
*object
);
134 static void compact_buffer (GBufferedInputStream
*stream
);
136 G_DEFINE_TYPE_WITH_CODE (GBufferedInputStream
,
137 g_buffered_input_stream
,
138 G_TYPE_FILTER_INPUT_STREAM
,
139 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE
,
140 g_buffered_input_stream_seekable_iface_init
))
143 g_buffered_input_stream_class_init (GBufferedInputStreamClass
*klass
)
145 GObjectClass
*object_class
;
146 GInputStreamClass
*istream_class
;
147 GBufferedInputStreamClass
*bstream_class
;
149 g_type_class_add_private (klass
, sizeof (GBufferedInputStreamPrivate
));
151 object_class
= G_OBJECT_CLASS (klass
);
152 object_class
->get_property
= g_buffered_input_stream_get_property
;
153 object_class
->set_property
= g_buffered_input_stream_set_property
;
154 object_class
->finalize
= g_buffered_input_stream_finalize
;
156 istream_class
= G_INPUT_STREAM_CLASS (klass
);
157 istream_class
->skip
= g_buffered_input_stream_skip
;
158 istream_class
->skip_async
= g_buffered_input_stream_skip_async
;
159 istream_class
->skip_finish
= g_buffered_input_stream_skip_finish
;
160 istream_class
->read_fn
= g_buffered_input_stream_read
;
162 bstream_class
= G_BUFFERED_INPUT_STREAM_CLASS (klass
);
163 bstream_class
->fill
= g_buffered_input_stream_real_fill
;
164 bstream_class
->fill_async
= g_buffered_input_stream_real_fill_async
;
165 bstream_class
->fill_finish
= g_buffered_input_stream_real_fill_finish
;
167 g_object_class_install_property (object_class
,
169 g_param_spec_uint ("buffer-size",
171 P_("The size of the backend buffer"),
175 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT
|
176 G_PARAM_STATIC_NAME
|G_PARAM_STATIC_NICK
|G_PARAM_STATIC_BLURB
));
182 * g_buffered_input_stream_get_buffer_size:
183 * @stream: a #GBufferedInputStream
185 * Gets the size of the input buffer.
187 * Returns: the current buffer size.
190 g_buffered_input_stream_get_buffer_size (GBufferedInputStream
*stream
)
192 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), 0);
194 return stream
->priv
->len
;
198 * g_buffered_input_stream_set_buffer_size:
199 * @stream: a #GBufferedInputStream
202 * Sets the size of the internal buffer of @stream to @size, or to the
203 * size of the contents of the buffer. The buffer can never be resized
204 * smaller than its current contents.
207 g_buffered_input_stream_set_buffer_size (GBufferedInputStream
*stream
,
210 GBufferedInputStreamPrivate
*priv
;
214 g_return_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
));
218 if (priv
->len
== size
)
223 in_buffer
= priv
->end
- priv
->pos
;
225 /* Never resize smaller than current buffer contents */
226 size
= MAX (size
, in_buffer
);
228 buffer
= g_malloc (size
);
229 memcpy (buffer
, priv
->buffer
+ priv
->pos
, in_buffer
);
232 priv
->end
= in_buffer
;
233 g_free (priv
->buffer
);
234 priv
->buffer
= buffer
;
241 priv
->buffer
= g_malloc (size
);
244 g_object_notify (G_OBJECT (stream
), "buffer-size");
248 g_buffered_input_stream_set_property (GObject
*object
,
253 GBufferedInputStream
*bstream
;
255 bstream
= G_BUFFERED_INPUT_STREAM (object
);
260 g_buffered_input_stream_set_buffer_size (bstream
, g_value_get_uint (value
));
264 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
270 g_buffered_input_stream_get_property (GObject
*object
,
275 GBufferedInputStreamPrivate
*priv
;
276 GBufferedInputStream
*bstream
;
278 bstream
= G_BUFFERED_INPUT_STREAM (object
);
279 priv
= bstream
->priv
;
284 g_value_set_uint (value
, priv
->len
);
288 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
294 g_buffered_input_stream_finalize (GObject
*object
)
296 GBufferedInputStreamPrivate
*priv
;
297 GBufferedInputStream
*stream
;
299 stream
= G_BUFFERED_INPUT_STREAM (object
);
302 g_free (priv
->buffer
);
304 G_OBJECT_CLASS (g_buffered_input_stream_parent_class
)->finalize (object
);
308 g_buffered_input_stream_seekable_iface_init (GSeekableIface
*iface
)
310 iface
->tell
= g_buffered_input_stream_tell
;
311 iface
->can_seek
= g_buffered_input_stream_can_seek
;
312 iface
->seek
= g_buffered_input_stream_seek
;
313 iface
->can_truncate
= g_buffered_input_stream_can_truncate
;
314 iface
->truncate_fn
= g_buffered_input_stream_truncate
;
318 g_buffered_input_stream_init (GBufferedInputStream
*stream
)
320 stream
->priv
= G_TYPE_INSTANCE_GET_PRIVATE (stream
,
321 G_TYPE_BUFFERED_INPUT_STREAM
,
322 GBufferedInputStreamPrivate
);
327 * g_buffered_input_stream_new:
328 * @base_stream: a #GInputStream
330 * Creates a new #GInputStream from the given @base_stream, with
331 * a buffer set to the default size (4 kilobytes).
333 * Returns: a #GInputStream for the given @base_stream.
336 g_buffered_input_stream_new (GInputStream
*base_stream
)
338 GInputStream
*stream
;
340 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
342 stream
= g_object_new (G_TYPE_BUFFERED_INPUT_STREAM
,
343 "base-stream", base_stream
,
350 * g_buffered_input_stream_new_sized:
351 * @base_stream: a #GInputStream
354 * Creates a new #GBufferedInputStream from the given @base_stream,
355 * with a buffer set to @size.
357 * Returns: a #GInputStream.
360 g_buffered_input_stream_new_sized (GInputStream
*base_stream
,
363 GInputStream
*stream
;
365 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
367 stream
= g_object_new (G_TYPE_BUFFERED_INPUT_STREAM
,
368 "base-stream", base_stream
,
369 "buffer-size", (guint
)size
,
376 * g_buffered_input_stream_fill:
377 * @stream: a #GBufferedInputStream
378 * @count: the number of bytes that will be read from the stream
379 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
380 * @error: location to store the error occurring, or %NULL to ignore
382 * Tries to read @count bytes from the stream into the buffer.
383 * Will block during this read.
385 * If @count is zero, returns zero and does nothing. A value of @count
386 * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
388 * On success, the number of bytes read into the buffer is returned.
389 * It is not an error if this is not the same as the requested size, as it
390 * can happen e.g. near the end of a file. Zero is returned on end of file
391 * (or if @count is zero), but never otherwise.
393 * If @count is -1 then the attempted read size is equal to the number of
394 * bytes that are required to fill the buffer.
396 * If @cancellable is not %NULL, then the operation can be cancelled by
397 * triggering the cancellable object from another thread. If the operation
398 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
399 * operation was partially finished when the operation was cancelled the
400 * partial result will be returned, without an error.
402 * On error -1 is returned and @error is set accordingly.
404 * For the asynchronous, non-blocking, version of this function, see
405 * g_buffered_input_stream_fill_async().
407 * Returns: the number of bytes read into @stream's buffer, up to @count,
411 g_buffered_input_stream_fill (GBufferedInputStream
*stream
,
413 GCancellable
*cancellable
,
416 GBufferedInputStreamClass
*class;
417 GInputStream
*input_stream
;
420 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
422 input_stream
= G_INPUT_STREAM (stream
);
426 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
427 _("Too large count value passed to %s"), G_STRFUNC
);
431 if (!g_input_stream_set_pending (input_stream
, error
))
435 g_cancellable_push_current (cancellable
);
437 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
438 res
= class->fill (stream
, count
, cancellable
, error
);
441 g_cancellable_pop_current (cancellable
);
443 g_input_stream_clear_pending (input_stream
);
449 async_fill_callback_wrapper (GObject
*source_object
,
453 GBufferedInputStream
*stream
= G_BUFFERED_INPUT_STREAM (source_object
);
455 g_input_stream_clear_pending (G_INPUT_STREAM (stream
));
456 (*stream
->priv
->outstanding_callback
) (source_object
, res
, user_data
);
457 g_object_unref (stream
);
461 * g_buffered_input_stream_fill_async:
462 * @stream: a #GBufferedInputStream
463 * @count: the number of bytes that will be read from the stream
464 * @io_priority: the <link linkend="io-priority">I/O priority</link>
466 * @cancellable: (allow-none): optional #GCancellable object
467 * @callback: (scope async): a #GAsyncReadyCallback
468 * @user_data: (closure): a #gpointer
470 * Reads data into @stream's buffer asynchronously, up to @count size.
471 * @io_priority can be used to prioritize reads. For the synchronous
472 * version of this function, see g_buffered_input_stream_fill().
474 * If @count is -1 then the attempted read size is equal to the number
475 * of bytes that are required to fill the buffer.
478 g_buffered_input_stream_fill_async (GBufferedInputStream
*stream
,
481 GCancellable
*cancellable
,
482 GAsyncReadyCallback callback
,
485 GBufferedInputStreamClass
*class;
486 GSimpleAsyncResult
*simple
;
487 GError
*error
= NULL
;
489 g_return_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
));
493 simple
= g_simple_async_result_new (G_OBJECT (stream
),
496 g_buffered_input_stream_fill_async
);
497 g_simple_async_result_complete_in_idle (simple
);
498 g_object_unref (simple
);
504 g_simple_async_report_error_in_idle (G_OBJECT (stream
),
507 G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
508 _("Too large count value passed to %s"),
513 if (!g_input_stream_set_pending (G_INPUT_STREAM (stream
), &error
))
515 g_simple_async_report_take_gerror_in_idle (G_OBJECT (stream
),
522 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
524 stream
->priv
->outstanding_callback
= callback
;
525 g_object_ref (stream
);
526 class->fill_async (stream
, count
, io_priority
, cancellable
,
527 async_fill_callback_wrapper
, user_data
);
531 * g_buffered_input_stream_fill_finish:
532 * @stream: a #GBufferedInputStream
533 * @result: a #GAsyncResult
536 * Finishes an asynchronous read.
538 * Returns: a #gssize of the read stream, or %-1 on an error.
541 g_buffered_input_stream_fill_finish (GBufferedInputStream
*stream
,
542 GAsyncResult
*result
,
545 GSimpleAsyncResult
*simple
;
546 GBufferedInputStreamClass
*class;
548 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
549 g_return_val_if_fail (G_IS_ASYNC_RESULT (result
), -1);
551 if (G_IS_SIMPLE_ASYNC_RESULT (result
))
553 simple
= G_SIMPLE_ASYNC_RESULT (result
);
554 if (g_simple_async_result_propagate_error (simple
, error
))
557 /* Special case read of 0 bytes */
558 if (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_fill_async
)
562 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
563 return class->fill_finish (stream
, result
, error
);
567 * g_buffered_input_stream_get_available:
568 * @stream: #GBufferedInputStream
570 * Gets the size of the available data within the stream.
572 * Returns: size of the available stream.
575 g_buffered_input_stream_get_available (GBufferedInputStream
*stream
)
577 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
579 return stream
->priv
->end
- stream
->priv
->pos
;
583 * g_buffered_input_stream_peek:
584 * @stream: a #GBufferedInputStream
585 * @buffer: (array length=count) (element-type guint8): a pointer to
586 * an allocated chunk of memory
590 * Peeks in the buffer, copying data of size @count into @buffer,
591 * offset @offset bytes.
593 * Returns: a #gsize of the number of bytes peeked, or -1 on error.
596 g_buffered_input_stream_peek (GBufferedInputStream
*stream
,
604 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
605 g_return_val_if_fail (buffer
!= NULL
, -1);
607 available
= g_buffered_input_stream_get_available (stream
);
609 if (offset
> available
)
612 end
= MIN (offset
+ count
, available
);
613 count
= end
- offset
;
615 memcpy (buffer
, stream
->priv
->buffer
+ stream
->priv
->pos
+ offset
, count
);
620 * g_buffered_input_stream_peek_buffer:
621 * @stream: a #GBufferedInputStream
622 * @count: (out): a #gsize to get the number of bytes available in the buffer
624 * Returns the buffer with the currently available bytes. The returned
625 * buffer must not be modified and will become invalid when reading from
626 * the stream or filling the buffer.
628 * Returns: (array length=count) (element-type guint8) (transfer none):
632 g_buffered_input_stream_peek_buffer (GBufferedInputStream
*stream
,
635 GBufferedInputStreamPrivate
*priv
;
637 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), NULL
);
642 *count
= priv
->end
- priv
->pos
;
644 return priv
->buffer
+ priv
->pos
;
648 compact_buffer (GBufferedInputStream
*stream
)
650 GBufferedInputStreamPrivate
*priv
;
655 current_size
= priv
->end
- priv
->pos
;
657 g_memmove (priv
->buffer
, priv
->buffer
+ priv
->pos
, current_size
);
660 priv
->end
= current_size
;
664 g_buffered_input_stream_real_fill (GBufferedInputStream
*stream
,
666 GCancellable
*cancellable
,
669 GBufferedInputStreamPrivate
*priv
;
670 GInputStream
*base_stream
;
679 in_buffer
= priv
->end
- priv
->pos
;
681 /* Never fill more than can fit in the buffer */
682 count
= MIN (count
, priv
->len
- in_buffer
);
684 /* If requested length does not fit at end, compact */
685 if (priv
->len
- priv
->end
< count
)
686 compact_buffer (stream
);
688 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
689 nread
= g_input_stream_read (base_stream
,
690 priv
->buffer
+ priv
->end
,
702 g_buffered_input_stream_skip (GInputStream
*stream
,
704 GCancellable
*cancellable
,
707 GBufferedInputStream
*bstream
;
708 GBufferedInputStreamPrivate
*priv
;
709 GBufferedInputStreamClass
*class;
710 GInputStream
*base_stream
;
711 gsize available
, bytes_skipped
;
714 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
715 priv
= bstream
->priv
;
717 available
= priv
->end
- priv
->pos
;
719 if (count
<= available
)
725 /* Full request not available, skip all currently available and
726 * request refill for more
731 bytes_skipped
= available
;
734 if (bytes_skipped
> 0)
735 error
= NULL
; /* Ignore further errors if we already read some data */
737 if (count
> priv
->len
)
739 /* Large request, shortcut buffer */
741 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
743 nread
= g_input_stream_skip (base_stream
,
748 if (nread
< 0 && bytes_skipped
== 0)
752 bytes_skipped
+= nread
;
754 return bytes_skipped
;
757 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
758 nread
= class->fill (bstream
, priv
->len
, cancellable
, error
);
762 if (bytes_skipped
== 0)
765 return bytes_skipped
;
768 available
= priv
->end
- priv
->pos
;
769 count
= MIN (count
, available
);
771 bytes_skipped
+= count
;
774 return bytes_skipped
;
778 g_buffered_input_stream_read (GInputStream
*stream
,
781 GCancellable
*cancellable
,
784 GBufferedInputStream
*bstream
;
785 GBufferedInputStreamPrivate
*priv
;
786 GBufferedInputStreamClass
*class;
787 GInputStream
*base_stream
;
788 gsize available
, bytes_read
;
791 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
792 priv
= bstream
->priv
;
794 available
= priv
->end
- priv
->pos
;
796 if (count
<= available
)
798 memcpy (buffer
, priv
->buffer
+ priv
->pos
, count
);
803 /* Full request not available, read all currently available and
804 * request refill for more
807 memcpy (buffer
, priv
->buffer
+ priv
->pos
, available
);
810 bytes_read
= available
;
814 error
= NULL
; /* Ignore further errors if we already read some data */
816 if (count
> priv
->len
)
818 /* Large request, shortcut buffer */
820 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
822 nread
= g_input_stream_read (base_stream
,
823 (char *)buffer
+ bytes_read
,
828 if (nread
< 0 && bytes_read
== 0)
837 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
838 nread
= class->fill (bstream
, priv
->len
, cancellable
, error
);
847 available
= priv
->end
- priv
->pos
;
848 count
= MIN (count
, available
);
850 memcpy ((char *)buffer
+ bytes_read
, (char *)priv
->buffer
+ priv
->pos
, count
);
858 g_buffered_input_stream_tell (GSeekable
*seekable
)
860 GBufferedInputStream
*bstream
;
861 GBufferedInputStreamPrivate
*priv
;
862 GInputStream
*base_stream
;
863 GSeekable
*base_stream_seekable
;
867 bstream
= G_BUFFERED_INPUT_STREAM (seekable
);
868 priv
= bstream
->priv
;
870 base_stream
= G_FILTER_INPUT_STREAM (seekable
)->base_stream
;
871 if (!G_IS_SEEKABLE (base_stream
))
873 base_stream_seekable
= G_SEEKABLE (base_stream
);
875 available
= priv
->end
- priv
->pos
;
876 base_offset
= g_seekable_tell (base_stream_seekable
);
878 return base_offset
- available
;
882 g_buffered_input_stream_can_seek (GSeekable
*seekable
)
884 GInputStream
*base_stream
;
886 base_stream
= G_FILTER_INPUT_STREAM (seekable
)->base_stream
;
887 return G_IS_SEEKABLE (base_stream
) && g_seekable_can_seek (G_SEEKABLE (base_stream
));
891 g_buffered_input_stream_seek (GSeekable
*seekable
,
894 GCancellable
*cancellable
,
897 GBufferedInputStream
*bstream
;
898 GBufferedInputStreamPrivate
*priv
;
899 GInputStream
*base_stream
;
900 GSeekable
*base_stream_seekable
;
902 bstream
= G_BUFFERED_INPUT_STREAM (seekable
);
903 priv
= bstream
->priv
;
905 base_stream
= G_FILTER_INPUT_STREAM (seekable
)->base_stream
;
906 if (!G_IS_SEEKABLE (base_stream
))
908 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
909 _("Seek not supported on base stream"));
913 base_stream_seekable
= G_SEEKABLE (base_stream
);
915 if (type
== G_SEEK_CUR
)
917 if (offset
<= priv
->end
- priv
->pos
&& offset
>= -priv
->pos
)
924 offset
-= priv
->end
- priv
->pos
;
928 if (g_seekable_seek (base_stream_seekable
, offset
, type
, cancellable
, error
))
941 g_buffered_input_stream_can_truncate (GSeekable
*seekable
)
947 g_buffered_input_stream_truncate (GSeekable
*seekable
,
949 GCancellable
*cancellable
,
952 g_set_error_literal (error
,
954 G_IO_ERROR_NOT_SUPPORTED
,
955 _("Cannot truncate GBufferedInputStream"));
960 * g_buffered_input_stream_read_byte:
961 * @stream: a #GBufferedInputStream
962 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
963 * @error: location to store the error occurring, or %NULL to ignore
965 * Tries to read a single byte from the stream or the buffer. Will block
968 * On success, the byte read from the stream is returned. On end of stream
969 * -1 is returned but it's not an exceptional error and @error is not set.
971 * If @cancellable is not %NULL, then the operation can be cancelled by
972 * triggering the cancellable object from another thread. If the operation
973 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
974 * operation was partially finished when the operation was cancelled the
975 * partial result will be returned, without an error.
977 * On error -1 is returned and @error is set accordingly.
979 * Returns: the byte read from the @stream, or -1 on end of stream or error.
982 g_buffered_input_stream_read_byte (GBufferedInputStream
*stream
,
983 GCancellable
*cancellable
,
986 GBufferedInputStreamPrivate
*priv
;
987 GBufferedInputStreamClass
*class;
988 GInputStream
*input_stream
;
992 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
995 input_stream
= G_INPUT_STREAM (stream
);
997 if (g_input_stream_is_closed (input_stream
))
999 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_CLOSED
,
1000 _("Stream is already closed"));
1004 if (!g_input_stream_set_pending (input_stream
, error
))
1007 available
= priv
->end
- priv
->pos
;
1011 g_input_stream_clear_pending (input_stream
);
1012 return priv
->buffer
[priv
->pos
++];
1015 /* Byte not available, request refill for more */
1018 g_cancellable_push_current (cancellable
);
1023 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
1024 nread
= class->fill (stream
, priv
->len
, cancellable
, error
);
1027 g_cancellable_pop_current (cancellable
);
1029 g_input_stream_clear_pending (input_stream
);
1032 return -1; /* error or end of stream */
1034 return priv
->buffer
[priv
->pos
++];
1037 /* ************************** */
1038 /* Async stuff implementation */
1039 /* ************************** */
1042 fill_async_callback (GObject
*source_object
,
1043 GAsyncResult
*result
,
1048 GSimpleAsyncResult
*simple
;
1053 res
= g_input_stream_read_finish (G_INPUT_STREAM (source_object
),
1056 g_simple_async_result_set_op_res_gssize (simple
, res
);
1059 g_simple_async_result_take_error (simple
, error
);
1063 GBufferedInputStreamPrivate
*priv
;
1066 object
= g_async_result_get_source_object (G_ASYNC_RESULT (simple
));
1067 priv
= G_BUFFERED_INPUT_STREAM (object
)->priv
;
1069 g_assert_cmpint (priv
->end
+ res
, <=, priv
->len
);
1072 g_object_unref (object
);
1075 /* Complete immediately, not in idle, since we're already
1076 * in a mainloop callout
1078 g_simple_async_result_complete (simple
);
1079 g_object_unref (simple
);
1083 g_buffered_input_stream_real_fill_async (GBufferedInputStream
*stream
,
1086 GCancellable
*cancellable
,
1087 GAsyncReadyCallback callback
,
1090 GBufferedInputStreamPrivate
*priv
;
1091 GInputStream
*base_stream
;
1092 GSimpleAsyncResult
*simple
;
1095 priv
= stream
->priv
;
1100 in_buffer
= priv
->end
- priv
->pos
;
1102 /* Never fill more than can fit in the buffer */
1103 count
= MIN (count
, priv
->len
- in_buffer
);
1105 /* If requested length does not fit at end, compact */
1106 if (priv
->len
- priv
->end
< count
)
1107 compact_buffer (stream
);
1109 simple
= g_simple_async_result_new (G_OBJECT (stream
),
1110 callback
, user_data
,
1111 g_buffered_input_stream_real_fill_async
);
1113 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
1114 g_input_stream_read_async (base_stream
,
1115 priv
->buffer
+ priv
->end
,
1119 fill_async_callback
,
1124 g_buffered_input_stream_real_fill_finish (GBufferedInputStream
*stream
,
1125 GAsyncResult
*result
,
1128 GSimpleAsyncResult
*simple
;
1131 simple
= G_SIMPLE_ASYNC_RESULT (result
);
1132 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_real_fill_async
);
1134 nread
= g_simple_async_result_get_op_res_gssize (simple
);
1140 gssize bytes_skipped
;
1145 free_skip_async_data (gpointer _data
)
1147 SkipAsyncData
*data
= _data
;
1148 g_slice_free (SkipAsyncData
, data
);
1152 large_skip_callback (GObject
*source_object
,
1153 GAsyncResult
*result
,
1156 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1157 SkipAsyncData
*data
;
1161 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1164 nread
= g_input_stream_skip_finish (G_INPUT_STREAM (source_object
),
1167 /* Only report the error if we've not already read some data */
1168 if (nread
< 0 && data
->bytes_skipped
== 0)
1169 g_simple_async_result_take_error (simple
, error
);
1171 g_error_free (error
);
1174 data
->bytes_skipped
+= nread
;
1176 /* Complete immediately, not in idle, since we're already
1177 * in a mainloop callout
1179 g_simple_async_result_complete (simple
);
1180 g_object_unref (simple
);
1184 skip_fill_buffer_callback (GObject
*source_object
,
1185 GAsyncResult
*result
,
1188 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1189 GBufferedInputStream
*bstream
;
1190 GBufferedInputStreamPrivate
*priv
;
1191 SkipAsyncData
*data
;
1196 bstream
= G_BUFFERED_INPUT_STREAM (source_object
);
1197 priv
= bstream
->priv
;
1199 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1202 nread
= g_buffered_input_stream_fill_finish (bstream
,
1205 if (nread
< 0 && data
->bytes_skipped
== 0)
1206 g_simple_async_result_take_error (simple
, error
);
1208 g_error_free (error
);
1212 available
= priv
->end
- priv
->pos
;
1213 data
->count
= MIN (data
->count
, available
);
1215 data
->bytes_skipped
+= data
->count
;
1216 priv
->pos
+= data
->count
;
1219 /* Complete immediately, not in idle, since we're already
1220 * in a mainloop callout
1222 g_simple_async_result_complete (simple
);
1223 g_object_unref (simple
);
1227 g_buffered_input_stream_skip_async (GInputStream
*stream
,
1230 GCancellable
*cancellable
,
1231 GAsyncReadyCallback callback
,
1234 GBufferedInputStream
*bstream
;
1235 GBufferedInputStreamPrivate
*priv
;
1236 GBufferedInputStreamClass
*class;
1237 GInputStream
*base_stream
;
1239 GSimpleAsyncResult
*simple
;
1240 SkipAsyncData
*data
;
1242 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
1243 priv
= bstream
->priv
;
1245 data
= g_slice_new (SkipAsyncData
);
1246 data
->bytes_skipped
= 0;
1247 simple
= g_simple_async_result_new (G_OBJECT (stream
),
1248 callback
, user_data
,
1249 g_buffered_input_stream_skip_async
);
1250 g_simple_async_result_set_op_res_gpointer (simple
, data
, free_skip_async_data
);
1252 available
= priv
->end
- priv
->pos
;
1254 if (count
<= available
)
1257 data
->bytes_skipped
= count
;
1259 g_simple_async_result_complete_in_idle (simple
);
1260 g_object_unref (simple
);
1264 /* Full request not available, skip all currently available
1265 * and request refill for more
1273 data
->bytes_skipped
= available
;
1274 data
->count
= count
;
1276 if (count
> priv
->len
)
1278 /* Large request, shortcut buffer */
1280 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
1282 g_input_stream_skip_async (base_stream
,
1284 io_priority
, cancellable
,
1285 large_skip_callback
,
1290 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
1291 class->fill_async (bstream
, priv
->len
, io_priority
, cancellable
,
1292 skip_fill_buffer_callback
, simple
);
1297 g_buffered_input_stream_skip_finish (GInputStream
*stream
,
1298 GAsyncResult
*result
,
1301 GSimpleAsyncResult
*simple
;
1302 SkipAsyncData
*data
;
1304 simple
= G_SIMPLE_ASYNC_RESULT (result
);
1306 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_skip_async
);
1308 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1310 return data
->bytes_skipped
;