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"
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.
61 #define DEFAULT_BUFFER_SIZE 4096
63 struct _GBufferedInputStreamPrivate
{
68 GAsyncReadyCallback outstanding_callback
;
76 static void g_buffered_input_stream_set_property (GObject
*object
,
81 static void g_buffered_input_stream_get_property (GObject
*object
,
85 static void g_buffered_input_stream_finalize (GObject
*object
);
88 static gssize
g_buffered_input_stream_skip (GInputStream
*stream
,
90 GCancellable
*cancellable
,
92 static void g_buffered_input_stream_skip_async (GInputStream
*stream
,
95 GCancellable
*cancellable
,
96 GAsyncReadyCallback callback
,
98 static gssize
g_buffered_input_stream_skip_finish (GInputStream
*stream
,
101 static gssize
g_buffered_input_stream_read (GInputStream
*stream
,
104 GCancellable
*cancellable
,
106 static void g_buffered_input_stream_read_async (GInputStream
*stream
,
110 GCancellable
*cancellable
,
111 GAsyncReadyCallback callback
,
113 static gssize
g_buffered_input_stream_read_finish (GInputStream
*stream
,
114 GAsyncResult
*result
,
116 static gssize
g_buffered_input_stream_real_fill (GBufferedInputStream
*stream
,
118 GCancellable
*cancellable
,
120 static void g_buffered_input_stream_real_fill_async (GBufferedInputStream
*stream
,
123 GCancellable
*cancellable
,
124 GAsyncReadyCallback callback
,
126 static gssize
g_buffered_input_stream_real_fill_finish (GBufferedInputStream
*stream
,
127 GAsyncResult
*result
,
130 static void compact_buffer (GBufferedInputStream
*stream
);
132 G_DEFINE_TYPE (GBufferedInputStream
,
133 g_buffered_input_stream
,
134 G_TYPE_FILTER_INPUT_STREAM
)
138 g_buffered_input_stream_class_init (GBufferedInputStreamClass
*klass
)
140 GObjectClass
*object_class
;
141 GInputStreamClass
*istream_class
;
142 GBufferedInputStreamClass
*bstream_class
;
144 g_type_class_add_private (klass
, sizeof (GBufferedInputStreamPrivate
));
146 object_class
= G_OBJECT_CLASS (klass
);
147 object_class
->get_property
= g_buffered_input_stream_get_property
;
148 object_class
->set_property
= g_buffered_input_stream_set_property
;
149 object_class
->finalize
= g_buffered_input_stream_finalize
;
151 istream_class
= G_INPUT_STREAM_CLASS (klass
);
152 istream_class
->skip
= g_buffered_input_stream_skip
;
153 istream_class
->skip_async
= g_buffered_input_stream_skip_async
;
154 istream_class
->skip_finish
= g_buffered_input_stream_skip_finish
;
155 istream_class
->read_fn
= g_buffered_input_stream_read
;
156 istream_class
->read_async
= g_buffered_input_stream_read_async
;
157 istream_class
->read_finish
= g_buffered_input_stream_read_finish
;
159 bstream_class
= G_BUFFERED_INPUT_STREAM_CLASS (klass
);
160 bstream_class
->fill
= g_buffered_input_stream_real_fill
;
161 bstream_class
->fill_async
= g_buffered_input_stream_real_fill_async
;
162 bstream_class
->fill_finish
= g_buffered_input_stream_real_fill_finish
;
164 g_object_class_install_property (object_class
,
166 g_param_spec_uint ("buffer-size",
168 P_("The size of the backend buffer"),
172 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT
|
173 G_PARAM_STATIC_NAME
|G_PARAM_STATIC_NICK
|G_PARAM_STATIC_BLURB
));
179 * g_buffered_input_stream_get_buffer_size:
180 * @stream: #GBufferedInputStream.
182 * Gets the size of the input buffer.
184 * Returns: the current buffer size.
187 g_buffered_input_stream_get_buffer_size (GBufferedInputStream
*stream
)
189 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), 0);
191 return stream
->priv
->len
;
195 * g_buffered_input_stream_set_buffer_size:
196 * @stream: #GBufferedInputStream.
199 * Sets the size of the internal buffer of @stream to @size, or to the
200 * size of the contents of the buffer. The buffer can never be resized
201 * smaller than its current contents.
204 g_buffered_input_stream_set_buffer_size (GBufferedInputStream
*stream
,
207 GBufferedInputStreamPrivate
*priv
;
211 g_return_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
));
215 if (priv
->len
== size
)
220 in_buffer
= priv
->end
- priv
->pos
;
222 /* Never resize smaller than current buffer contents */
223 size
= MAX (size
, in_buffer
);
225 buffer
= g_malloc (size
);
226 memcpy (buffer
, priv
->buffer
+ priv
->pos
, in_buffer
);
229 priv
->end
= in_buffer
;
230 g_free (priv
->buffer
);
231 priv
->buffer
= buffer
;
238 priv
->buffer
= g_malloc (size
);
241 g_object_notify (G_OBJECT (stream
), "buffer-size");
245 g_buffered_input_stream_set_property (GObject
*object
,
250 GBufferedInputStreamPrivate
*priv
;
251 GBufferedInputStream
*bstream
;
253 bstream
= G_BUFFERED_INPUT_STREAM (object
);
254 priv
= bstream
->priv
;
259 g_buffered_input_stream_set_buffer_size (bstream
, g_value_get_uint (value
));
263 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_init (GBufferedInputStream
*stream
)
310 stream
->priv
= G_TYPE_INSTANCE_GET_PRIVATE (stream
,
311 G_TYPE_BUFFERED_INPUT_STREAM
,
312 GBufferedInputStreamPrivate
);
317 * g_buffered_input_stream_new:
318 * @base_stream: a #GInputStream.
320 * Creates a new #GInputStream from the given @base_stream, with
321 * a buffer set to the default size (4 kilobytes).
323 * Returns: a #GInputStream for the given @base_stream.
326 g_buffered_input_stream_new (GInputStream
*base_stream
)
328 GInputStream
*stream
;
330 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
332 stream
= g_object_new (G_TYPE_BUFFERED_INPUT_STREAM
,
333 "base-stream", base_stream
,
340 * g_buffered_input_stream_new_sized:
341 * @base_stream: a #GInputStream.
344 * Creates a new #GBufferedInputStream from the given @base_stream,
345 * with a buffer set to @size.
347 * Returns: a #GInputStream.
350 g_buffered_input_stream_new_sized (GInputStream
*base_stream
,
353 GInputStream
*stream
;
355 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
357 stream
= g_object_new (G_TYPE_BUFFERED_INPUT_STREAM
,
358 "base-stream", base_stream
,
359 "buffer-size", (guint
)size
,
366 * g_buffered_input_stream_fill:
367 * @stream: #GBufferedInputStream.
368 * @count: the number of bytes that will be read from the stream.
369 * @cancellable: optional #GCancellable object, %NULL to ignore.
370 * @error: location to store the error occuring, or %NULL to ignore.
372 * Tries to read @count bytes from the stream into the buffer.
373 * Will block during this read.
375 * If @count is zero, returns zero and does nothing. A value of @count
376 * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
378 * On success, the number of bytes read into the buffer is returned.
379 * It is not an error if this is not the same as the requested size, as it
380 * can happen e.g. near the end of a file. Zero is returned on end of file
381 * (or if @count is zero), but never otherwise.
383 * If @cancellable is not %NULL, then the operation can be cancelled by
384 * triggering the cancellable object from another thread. If the operation
385 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
386 * operation was partially finished when the operation was cancelled the
387 * partial result will be returned, without an error.
389 * On error -1 is returned and @error is set accordingly.
391 * For the asynchronous, non-blocking, version of this function, see
392 * g_buffered_input_stream_fill_async().
394 * Returns: the number of bytes read into @stream's buffer, up to @count,
398 g_buffered_input_stream_fill (GBufferedInputStream
*stream
,
400 GCancellable
*cancellable
,
403 GBufferedInputStreamClass
*class;
404 GInputStream
*input_stream
;
407 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
409 input_stream
= G_INPUT_STREAM (stream
);
411 if (!g_input_stream_set_pending (input_stream
, error
))
415 g_cancellable_push_current (cancellable
);
417 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
418 res
= class->fill (stream
, count
, cancellable
, error
);
421 g_cancellable_pop_current (cancellable
);
423 g_input_stream_clear_pending (input_stream
);
429 async_fill_callback_wrapper (GObject
*source_object
,
433 GBufferedInputStream
*stream
= G_BUFFERED_INPUT_STREAM (source_object
);
435 g_input_stream_clear_pending (G_INPUT_STREAM (stream
));
436 (*stream
->priv
->outstanding_callback
) (source_object
, res
, user_data
);
437 g_object_unref (stream
);
441 * g_buffered_input_stream_fill_async:
442 * @stream: #GBufferedInputStream.
444 * @io_priority: the <link linkend="io-priority">I/O priority</link>
446 * @cancellable: optional #GCancellable object
447 * @callback: a #GAsyncReadyCallback.
448 * @user_data: a #gpointer.
450 * Reads data into @stream's buffer asynchronously, up to @count size.
451 * @io_priority can be used to prioritize reads. For the synchronous
452 * version of this function, see g_buffered_input_stream_fill().
455 g_buffered_input_stream_fill_async (GBufferedInputStream
*stream
,
458 GCancellable
*cancellable
,
459 GAsyncReadyCallback callback
,
462 GBufferedInputStreamClass
*class;
463 GSimpleAsyncResult
*simple
;
464 GError
*error
= NULL
;
466 g_return_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
));
470 simple
= g_simple_async_result_new (G_OBJECT (stream
),
473 g_buffered_input_stream_fill_async
);
474 g_simple_async_result_complete_in_idle (simple
);
475 g_object_unref (simple
);
479 if (((gssize
) count
) < 0)
481 g_simple_async_report_error_in_idle (G_OBJECT (stream
),
484 G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
485 _("Too large count value passed to %s"),
490 if (!g_input_stream_set_pending (G_INPUT_STREAM (stream
), &error
))
492 g_simple_async_report_gerror_in_idle (G_OBJECT (stream
),
496 g_error_free (error
);
500 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
502 stream
->priv
->outstanding_callback
= callback
;
503 g_object_ref (stream
);
504 class->fill_async (stream
, count
, io_priority
, cancellable
,
505 async_fill_callback_wrapper
, user_data
);
509 * g_buffered_input_stream_fill_finish:
510 * @stream: a #GBufferedInputStream.
511 * @result: a #GAsyncResult.
514 * Finishes an asynchronous read.
516 * Returns: a #gssize of the read stream, or %-1 on an error.
519 g_buffered_input_stream_fill_finish (GBufferedInputStream
*stream
,
520 GAsyncResult
*result
,
523 GSimpleAsyncResult
*simple
;
524 GBufferedInputStreamClass
*class;
526 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
527 g_return_val_if_fail (G_IS_ASYNC_RESULT (result
), -1);
529 if (G_IS_SIMPLE_ASYNC_RESULT (result
))
531 simple
= G_SIMPLE_ASYNC_RESULT (result
);
532 if (g_simple_async_result_propagate_error (simple
, error
))
535 /* Special case read of 0 bytes */
536 if (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_fill_async
)
540 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
541 return class->fill_finish (stream
, result
, error
);
545 * g_buffered_input_stream_get_available:
546 * @stream: #GBufferedInputStream.
548 * Gets the size of the available data within the stream.
550 * Returns: size of the available stream.
553 g_buffered_input_stream_get_available (GBufferedInputStream
*stream
)
555 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
557 return stream
->priv
->end
- stream
->priv
->pos
;
561 * g_buffered_input_stream_peek:
562 * @stream: a #GBufferedInputStream.
563 * @buffer: a pointer to an allocated chunk of memory.
567 * Peeks in the buffer, copying data of size @count into @buffer,
568 * offset @offset bytes.
570 * Returns: a #gsize of the number of bytes peeked, or %-1 on error.
573 g_buffered_input_stream_peek (GBufferedInputStream
*stream
,
581 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
582 g_return_val_if_fail (buffer
!= NULL
, -1);
584 available
= g_buffered_input_stream_get_available (stream
);
586 if (offset
> available
)
589 end
= MIN (offset
+ count
, available
);
590 count
= end
- offset
;
592 memcpy (buffer
, stream
->priv
->buffer
+ stream
->priv
->pos
+ offset
, count
);
597 * g_buffered_input_stream_peek_buffer:
598 * @stream: a #GBufferedInputStream.
599 * @count: a #gsize to get the number of bytes available in the buffer.
601 * Returns the buffer with the currently available bytes. The returned
602 * buffer must not be modified and will become invalid when reading from
603 * the stream or filling the buffer.
605 * Returns: read-only buffer
608 g_buffered_input_stream_peek_buffer (GBufferedInputStream
*stream
,
611 GBufferedInputStreamPrivate
*priv
;
613 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), NULL
);
618 *count
= priv
->end
- priv
->pos
;
620 return priv
->buffer
+ priv
->pos
;
624 compact_buffer (GBufferedInputStream
*stream
)
626 GBufferedInputStreamPrivate
*priv
;
631 current_size
= priv
->end
- priv
->pos
;
633 g_memmove (priv
->buffer
, priv
->buffer
+ priv
->pos
, current_size
);
636 priv
->end
= current_size
;
640 g_buffered_input_stream_real_fill (GBufferedInputStream
*stream
,
642 GCancellable
*cancellable
,
645 GBufferedInputStreamPrivate
*priv
;
646 GInputStream
*base_stream
;
655 in_buffer
= priv
->end
- priv
->pos
;
657 /* Never fill more than can fit in the buffer */
658 count
= MIN (count
, priv
->len
- in_buffer
);
660 /* If requested length does not fit at end, compact */
661 if (priv
->len
- priv
->end
< count
)
662 compact_buffer (stream
);
664 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
665 nread
= g_input_stream_read (base_stream
,
666 priv
->buffer
+ priv
->end
,
678 g_buffered_input_stream_skip (GInputStream
*stream
,
680 GCancellable
*cancellable
,
683 GBufferedInputStream
*bstream
;
684 GBufferedInputStreamPrivate
*priv
;
685 GBufferedInputStreamClass
*class;
686 GInputStream
*base_stream
;
687 gsize available
, bytes_skipped
;
690 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
691 priv
= bstream
->priv
;
693 available
= priv
->end
- priv
->pos
;
695 if (count
<= available
)
701 /* Full request not available, skip all currently available and
702 * request refill for more
707 bytes_skipped
= available
;
710 if (bytes_skipped
> 0)
711 error
= NULL
; /* Ignore further errors if we already read some data */
713 if (count
> priv
->len
)
715 /* Large request, shortcut buffer */
717 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
719 nread
= g_input_stream_skip (base_stream
,
724 if (nread
< 0 && bytes_skipped
== 0)
728 bytes_skipped
+= nread
;
730 return bytes_skipped
;
733 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
734 nread
= class->fill (bstream
, priv
->len
, cancellable
, error
);
738 if (bytes_skipped
== 0)
741 return bytes_skipped
;
744 available
= priv
->end
- priv
->pos
;
745 count
= MIN (count
, available
);
747 bytes_skipped
+= count
;
750 return bytes_skipped
;
754 g_buffered_input_stream_read (GInputStream
*stream
,
757 GCancellable
*cancellable
,
760 GBufferedInputStream
*bstream
;
761 GBufferedInputStreamPrivate
*priv
;
762 GBufferedInputStreamClass
*class;
763 GInputStream
*base_stream
;
764 gsize available
, bytes_read
;
767 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
768 priv
= bstream
->priv
;
770 available
= priv
->end
- priv
->pos
;
772 if (count
<= available
)
774 memcpy (buffer
, priv
->buffer
+ priv
->pos
, count
);
779 /* Full request not available, read all currently availbile and request refill for more */
781 memcpy (buffer
, priv
->buffer
+ priv
->pos
, available
);
784 bytes_read
= available
;
788 error
= NULL
; /* Ignore further errors if we already read some data */
790 if (count
> priv
->len
)
792 /* Large request, shortcut buffer */
794 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
796 nread
= g_input_stream_read (base_stream
,
797 (char *)buffer
+ bytes_read
,
802 if (nread
< 0 && bytes_read
== 0)
811 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
812 nread
= class->fill (bstream
, priv
->len
, cancellable
, error
);
821 available
= priv
->end
- priv
->pos
;
822 count
= MIN (count
, available
);
824 memcpy ((char *)buffer
+ bytes_read
, (char *)priv
->buffer
+ priv
->pos
, count
);
832 * g_buffered_input_stream_read_byte:
833 * @stream: #GBufferedInputStream.
834 * @cancellable: optional #GCancellable object, %NULL to ignore.
835 * @error: location to store the error occuring, or %NULL to ignore.
837 * Tries to read a single byte from the stream or the buffer. Will block
840 * On success, the byte read from the stream is returned. On end of stream
841 * -1 is returned but it's not an exceptional error and @error is not set.
843 * If @cancellable is not %NULL, then the operation can be cancelled by
844 * triggering the cancellable object from another thread. If the operation
845 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
846 * operation was partially finished when the operation was cancelled the
847 * partial result will be returned, without an error.
849 * On error -1 is returned and @error is set accordingly.
851 * Returns: the byte read from the @stream, or -1 on end of stream or error.
854 g_buffered_input_stream_read_byte (GBufferedInputStream
*stream
,
855 GCancellable
*cancellable
,
858 GBufferedInputStreamPrivate
*priv
;
859 GBufferedInputStreamClass
*class;
860 GInputStream
*input_stream
;
864 g_return_val_if_fail (G_IS_BUFFERED_INPUT_STREAM (stream
), -1);
867 input_stream
= G_INPUT_STREAM (stream
);
869 if (g_input_stream_is_closed (input_stream
))
871 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_CLOSED
,
872 _("Stream is already closed"));
876 if (!g_input_stream_set_pending (input_stream
, error
))
879 available
= priv
->end
- priv
->pos
;
883 g_input_stream_clear_pending (input_stream
);
884 return priv
->buffer
[priv
->pos
++];
887 /* Byte not available, request refill for more */
890 g_cancellable_push_current (cancellable
);
895 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
896 nread
= class->fill (stream
, priv
->len
, cancellable
, error
);
899 g_cancellable_pop_current (cancellable
);
901 g_input_stream_clear_pending (input_stream
);
904 return -1; /* error or end of stream */
906 return priv
->buffer
[priv
->pos
++];
909 /* ************************** */
910 /* Async stuff implementation */
911 /* ************************** */
914 fill_async_callback (GObject
*source_object
,
915 GAsyncResult
*result
,
920 GSimpleAsyncResult
*simple
;
925 res
= g_input_stream_read_finish (G_INPUT_STREAM (source_object
),
928 g_simple_async_result_set_op_res_gssize (simple
, res
);
931 g_simple_async_result_set_from_error (simple
, error
);
932 g_error_free (error
);
935 /* Complete immediately, not in idle, since we're already in a mainloop callout */
936 g_simple_async_result_complete (simple
);
937 g_object_unref (simple
);
941 g_buffered_input_stream_real_fill_async (GBufferedInputStream
*stream
,
944 GCancellable
*cancellable
,
945 GAsyncReadyCallback callback
,
948 GBufferedInputStreamPrivate
*priv
;
949 GInputStream
*base_stream
;
950 GSimpleAsyncResult
*simple
;
958 in_buffer
= priv
->end
- priv
->pos
;
960 /* Never fill more than can fit in the buffer */
961 count
= MIN (count
, priv
->len
- in_buffer
);
963 /* If requested length does not fit at end, compact */
964 if (priv
->len
- priv
->end
< count
)
965 compact_buffer (stream
);
967 simple
= g_simple_async_result_new (G_OBJECT (stream
),
969 g_buffered_input_stream_real_fill_async
);
971 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
972 g_input_stream_read_async (base_stream
,
973 priv
->buffer
+ priv
->end
,
982 g_buffered_input_stream_real_fill_finish (GBufferedInputStream
*stream
,
983 GAsyncResult
*result
,
986 GSimpleAsyncResult
*simple
;
989 simple
= G_SIMPLE_ASYNC_RESULT (result
);
990 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_real_fill_async
);
992 nread
= g_simple_async_result_get_op_res_gssize (simple
);
1003 free_read_async_data (gpointer _data
)
1005 ReadAsyncData
*data
= _data
;
1006 g_slice_free (ReadAsyncData
, data
);
1010 large_read_callback (GObject
*source_object
,
1011 GAsyncResult
*result
,
1014 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1015 ReadAsyncData
*data
;
1019 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1022 nread
= g_input_stream_read_finish (G_INPUT_STREAM (source_object
),
1025 /* Only report the error if we've not already read some data */
1026 if (nread
< 0 && data
->bytes_read
== 0)
1027 g_simple_async_result_set_from_error (simple
, error
);
1030 data
->bytes_read
+= nread
;
1033 g_error_free (error
);
1035 /* Complete immediately, not in idle, since we're already in a mainloop callout */
1036 g_simple_async_result_complete (simple
);
1037 g_object_unref (simple
);
1041 read_fill_buffer_callback (GObject
*source_object
,
1042 GAsyncResult
*result
,
1045 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1046 GBufferedInputStream
*bstream
;
1047 GBufferedInputStreamPrivate
*priv
;
1048 ReadAsyncData
*data
;
1053 bstream
= G_BUFFERED_INPUT_STREAM (source_object
);
1054 priv
= bstream
->priv
;
1056 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1059 nread
= g_buffered_input_stream_fill_finish (bstream
,
1062 if (nread
< 0 && data
->bytes_read
== 0)
1063 g_simple_async_result_set_from_error (simple
, error
);
1068 available
= priv
->end
- priv
->pos
;
1069 data
->count
= MIN (data
->count
, available
);
1071 memcpy ((char *)data
->buffer
+ data
->bytes_read
, (char *)priv
->buffer
+ priv
->pos
, data
->count
);
1072 data
->bytes_read
+= data
->count
;
1073 priv
->pos
+= data
->count
;
1077 g_error_free (error
);
1079 /* Complete immediately, not in idle, since we're already in a mainloop callout */
1080 g_simple_async_result_complete (simple
);
1081 g_object_unref (simple
);
1085 g_buffered_input_stream_read_async (GInputStream
*stream
,
1089 GCancellable
*cancellable
,
1090 GAsyncReadyCallback callback
,
1093 GBufferedInputStream
*bstream
;
1094 GBufferedInputStreamPrivate
*priv
;
1095 GBufferedInputStreamClass
*class;
1096 GInputStream
*base_stream
;
1098 GSimpleAsyncResult
*simple
;
1099 ReadAsyncData
*data
;
1101 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
1102 priv
= bstream
->priv
;
1104 data
= g_slice_new (ReadAsyncData
);
1105 data
->buffer
= buffer
;
1106 data
->bytes_read
= 0;
1107 simple
= g_simple_async_result_new (G_OBJECT (stream
),
1108 callback
, user_data
,
1109 g_buffered_input_stream_read_async
);
1110 g_simple_async_result_set_op_res_gpointer (simple
, data
, free_read_async_data
);
1112 available
= priv
->end
- priv
->pos
;
1114 if (count
<= available
)
1116 memcpy (buffer
, priv
->buffer
+ priv
->pos
, count
);
1118 data
->bytes_read
= count
;
1120 g_simple_async_result_complete_in_idle (simple
);
1121 g_object_unref (simple
);
1126 /* Full request not available, read all currently availbile and request refill for more */
1128 memcpy (buffer
, priv
->buffer
+ priv
->pos
, available
);
1134 data
->bytes_read
= available
;
1135 data
->count
= count
;
1137 if (count
> priv
->len
)
1139 /* Large request, shortcut buffer */
1141 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
1143 g_input_stream_read_async (base_stream
,
1144 (char *)buffer
+ data
->bytes_read
,
1146 io_priority
, cancellable
,
1147 large_read_callback
,
1152 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
1153 class->fill_async (bstream
, priv
->len
, io_priority
, cancellable
,
1154 read_fill_buffer_callback
, simple
);
1159 g_buffered_input_stream_read_finish (GInputStream
*stream
,
1160 GAsyncResult
*result
,
1163 GSimpleAsyncResult
*simple
;
1164 ReadAsyncData
*data
;
1166 simple
= G_SIMPLE_ASYNC_RESULT (result
);
1168 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_read_async
);
1170 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1172 return data
->bytes_read
;
1176 gssize bytes_skipped
;
1181 free_skip_async_data (gpointer _data
)
1183 SkipAsyncData
*data
= _data
;
1184 g_slice_free (SkipAsyncData
, data
);
1188 large_skip_callback (GObject
*source_object
,
1189 GAsyncResult
*result
,
1192 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1193 SkipAsyncData
*data
;
1197 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1200 nread
= g_input_stream_skip_finish (G_INPUT_STREAM (source_object
),
1203 /* Only report the error if we've not already read some data */
1204 if (nread
< 0 && data
->bytes_skipped
== 0)
1205 g_simple_async_result_set_from_error (simple
, error
);
1208 data
->bytes_skipped
+= nread
;
1211 g_error_free (error
);
1213 /* Complete immediately, not in idle, since we're already in a mainloop callout */
1214 g_simple_async_result_complete (simple
);
1215 g_object_unref (simple
);
1219 skip_fill_buffer_callback (GObject
*source_object
,
1220 GAsyncResult
*result
,
1223 GSimpleAsyncResult
*simple
= G_SIMPLE_ASYNC_RESULT (user_data
);
1224 GBufferedInputStream
*bstream
;
1225 GBufferedInputStreamPrivate
*priv
;
1226 SkipAsyncData
*data
;
1231 bstream
= G_BUFFERED_INPUT_STREAM (source_object
);
1232 priv
= bstream
->priv
;
1234 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1237 nread
= g_buffered_input_stream_fill_finish (bstream
,
1240 if (nread
< 0 && data
->bytes_skipped
== 0)
1241 g_simple_async_result_set_from_error (simple
, error
);
1246 available
= priv
->end
- priv
->pos
;
1247 data
->count
= MIN (data
->count
, available
);
1249 data
->bytes_skipped
+= data
->count
;
1250 priv
->pos
+= data
->count
;
1254 g_error_free (error
);
1256 /* Complete immediately, not in idle, since we're already in a mainloop callout */
1257 g_simple_async_result_complete (simple
);
1258 g_object_unref (simple
);
1262 g_buffered_input_stream_skip_async (GInputStream
*stream
,
1265 GCancellable
*cancellable
,
1266 GAsyncReadyCallback callback
,
1269 GBufferedInputStream
*bstream
;
1270 GBufferedInputStreamPrivate
*priv
;
1271 GBufferedInputStreamClass
*class;
1272 GInputStream
*base_stream
;
1274 GSimpleAsyncResult
*simple
;
1275 SkipAsyncData
*data
;
1277 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
1278 priv
= bstream
->priv
;
1280 data
= g_slice_new (SkipAsyncData
);
1281 data
->bytes_skipped
= 0;
1282 simple
= g_simple_async_result_new (G_OBJECT (stream
),
1283 callback
, user_data
,
1284 g_buffered_input_stream_skip_async
);
1285 g_simple_async_result_set_op_res_gpointer (simple
, data
, free_skip_async_data
);
1287 available
= priv
->end
- priv
->pos
;
1289 if (count
<= available
)
1292 data
->bytes_skipped
= count
;
1294 g_simple_async_result_complete_in_idle (simple
);
1295 g_object_unref (simple
);
1300 /* Full request not available, skip all currently availbile and request refill for more */
1307 data
->bytes_skipped
= available
;
1308 data
->count
= count
;
1310 if (count
> priv
->len
)
1312 /* Large request, shortcut buffer */
1314 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
1316 g_input_stream_skip_async (base_stream
,
1318 io_priority
, cancellable
,
1319 large_skip_callback
,
1324 class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream
);
1325 class->fill_async (bstream
, priv
->len
, io_priority
, cancellable
,
1326 skip_fill_buffer_callback
, simple
);
1331 g_buffered_input_stream_skip_finish (GInputStream
*stream
,
1332 GAsyncResult
*result
,
1335 GSimpleAsyncResult
*simple
;
1336 SkipAsyncData
*data
;
1338 simple
= G_SIMPLE_ASYNC_RESULT (result
);
1340 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) == g_buffered_input_stream_skip_async
);
1342 data
= g_simple_async_result_get_op_res_gpointer (simple
);
1344 return data
->bytes_skipped
;
1348 #define __G_BUFFERED_INPUT_STREAM_C__
1349 #include "gioaliasdef.c"