1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2009 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>
27 #include "gconverterinputstream.h"
28 #include "gpollableinputstream.h"
29 #include "gsimpleasyncresult.h"
30 #include "gcancellable.h"
31 #include "gioenumtypes.h"
37 * SECTION:gconverterinputstream
38 * @short_description: Converter Input Stream
40 * @see_also: #GInputStream, #GConverter
42 * Converter input stream implements #GInputStream and allows
43 * conversion of data of various types during reading.
45 * As of GLib 2.34, #GConverterInputStream implements
46 * #GPollableInputStream.
49 #define INITIAL_BUFFER_SIZE 4096
58 struct _GConverterInputStreamPrivate
{
59 gboolean at_input_end
;
62 GConverter
*converter
;
64 Buffer converted_buffer
;
72 static void g_converter_input_stream_set_property (GObject
*object
,
76 static void g_converter_input_stream_get_property (GObject
*object
,
80 static void g_converter_input_stream_finalize (GObject
*object
);
81 static gssize
g_converter_input_stream_read (GInputStream
*stream
,
84 GCancellable
*cancellable
,
87 static gboolean
g_converter_input_stream_can_poll (GPollableInputStream
*stream
);
88 static gboolean
g_converter_input_stream_is_readable (GPollableInputStream
*stream
);
89 static gssize
g_converter_input_stream_read_nonblocking (GPollableInputStream
*stream
,
94 static GSource
*g_converter_input_stream_create_source (GPollableInputStream
*stream
,
95 GCancellable
*cancellable
);
97 static void g_converter_input_stream_pollable_iface_init (GPollableInputStreamInterface
*iface
);
99 G_DEFINE_TYPE_WITH_CODE (GConverterInputStream
,
100 g_converter_input_stream
,
101 G_TYPE_FILTER_INPUT_STREAM
,
102 G_ADD_PRIVATE (GConverterInputStream
)
103 G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_INPUT_STREAM
,
104 g_converter_input_stream_pollable_iface_init
))
107 g_converter_input_stream_class_init (GConverterInputStreamClass
*klass
)
109 GObjectClass
*object_class
;
110 GInputStreamClass
*istream_class
;
112 object_class
= G_OBJECT_CLASS (klass
);
113 object_class
->get_property
= g_converter_input_stream_get_property
;
114 object_class
->set_property
= g_converter_input_stream_set_property
;
115 object_class
->finalize
= g_converter_input_stream_finalize
;
117 istream_class
= G_INPUT_STREAM_CLASS (klass
);
118 istream_class
->read_fn
= g_converter_input_stream_read
;
120 g_object_class_install_property (object_class
,
122 g_param_spec_object ("converter",
124 P_("The converter object"),
127 G_PARAM_CONSTRUCT_ONLY
|
128 G_PARAM_STATIC_STRINGS
));
133 g_converter_input_stream_pollable_iface_init (GPollableInputStreamInterface
*iface
)
135 iface
->can_poll
= g_converter_input_stream_can_poll
;
136 iface
->is_readable
= g_converter_input_stream_is_readable
;
137 iface
->read_nonblocking
= g_converter_input_stream_read_nonblocking
;
138 iface
->create_source
= g_converter_input_stream_create_source
;
142 g_converter_input_stream_finalize (GObject
*object
)
144 GConverterInputStreamPrivate
*priv
;
145 GConverterInputStream
*stream
;
147 stream
= G_CONVERTER_INPUT_STREAM (object
);
150 g_free (priv
->input_buffer
.data
);
151 g_free (priv
->converted_buffer
.data
);
153 g_object_unref (priv
->converter
);
155 G_OBJECT_CLASS (g_converter_input_stream_parent_class
)->finalize (object
);
159 g_converter_input_stream_set_property (GObject
*object
,
164 GConverterInputStream
*cstream
;
166 cstream
= G_CONVERTER_INPUT_STREAM (object
);
171 cstream
->priv
->converter
= g_value_dup_object (value
);
175 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
182 g_converter_input_stream_get_property (GObject
*object
,
187 GConverterInputStreamPrivate
*priv
;
188 GConverterInputStream
*cstream
;
190 cstream
= G_CONVERTER_INPUT_STREAM (object
);
191 priv
= cstream
->priv
;
196 g_value_set_object (value
, priv
->converter
);
200 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
206 g_converter_input_stream_init (GConverterInputStream
*stream
)
208 stream
->priv
= g_converter_input_stream_get_instance_private (stream
);
212 * g_converter_input_stream_new:
213 * @base_stream: a #GInputStream
214 * @converter: a #GConverter
216 * Creates a new converter input stream for the @base_stream.
218 * Returns: a new #GInputStream.
221 g_converter_input_stream_new (GInputStream
*base_stream
,
222 GConverter
*converter
)
224 GInputStream
*stream
;
226 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
228 stream
= g_object_new (G_TYPE_CONVERTER_INPUT_STREAM
,
229 "base-stream", base_stream
,
230 "converter", converter
,
237 buffer_data_size (Buffer
*buffer
)
239 return buffer
->end
- buffer
->start
;
243 buffer_tailspace (Buffer
*buffer
)
245 return buffer
->size
- buffer
->end
;
249 buffer_data (Buffer
*buffer
)
251 return buffer
->data
+ buffer
->start
;
255 buffer_consumed (Buffer
*buffer
,
258 buffer
->start
+= count
;
259 if (buffer
->start
== buffer
->end
)
260 buffer
->start
= buffer
->end
= 0;
264 buffer_read (Buffer
*buffer
,
268 memcpy (dest
, buffer
->data
+ buffer
->start
, count
);
269 buffer_consumed (buffer
, count
);
273 compact_buffer (Buffer
*buffer
)
277 in_buffer
= buffer_data_size (buffer
);
278 memmove (buffer
->data
,
279 buffer
->data
+ buffer
->start
,
281 buffer
->end
-= buffer
->start
;
286 grow_buffer (Buffer
*buffer
)
289 gsize size
, in_buffer
;
291 if (buffer
->size
== 0)
292 size
= INITIAL_BUFFER_SIZE
;
294 size
= buffer
->size
* 2;
296 data
= g_malloc (size
);
297 in_buffer
= buffer_data_size (buffer
);
300 buffer
->data
+ buffer
->start
,
302 g_free (buffer
->data
);
304 buffer
->end
-= buffer
->start
;
309 /* Ensures that the buffer can fit at_least_size bytes,
310 * *including* the current in-buffer data */
312 buffer_ensure_space (Buffer
*buffer
,
315 gsize in_buffer
, left_to_fill
;
317 in_buffer
= buffer_data_size (buffer
);
319 if (in_buffer
>= at_least_size
)
322 left_to_fill
= buffer_tailspace (buffer
);
324 if (in_buffer
+ left_to_fill
>= at_least_size
)
326 /* We fit in remaining space at end */
327 /* If the copy is small, compact now anyway so we can fill more */
329 compact_buffer (buffer
);
331 else if (buffer
->size
>= at_least_size
)
333 /* We fit, but only if we compact */
334 compact_buffer (buffer
);
338 /* Need to grow buffer */
339 while (buffer
->size
< at_least_size
)
340 grow_buffer (buffer
);
345 fill_input_buffer (GConverterInputStream
*stream
,
348 GCancellable
*cancellable
,
351 GConverterInputStreamPrivate
*priv
;
352 GInputStream
*base_stream
;
357 buffer_ensure_space (&priv
->input_buffer
, at_least_size
);
359 base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
360 nread
= g_pollable_stream_read (base_stream
,
361 priv
->input_buffer
.data
+ priv
->input_buffer
.end
,
362 buffer_tailspace (&priv
->input_buffer
),
369 priv
->input_buffer
.end
+= nread
;
370 priv
->need_input
= FALSE
;
378 read_internal (GInputStream
*stream
,
382 GCancellable
*cancellable
,
385 GConverterInputStream
*cstream
;
386 GConverterInputStreamPrivate
*priv
;
387 gsize available
, total_bytes_read
;
389 GConverterResult res
;
395 cstream
= G_CONVERTER_INPUT_STREAM (stream
);
396 priv
= cstream
->priv
;
398 available
= buffer_data_size (&priv
->converted_buffer
);
403 /* Converted data available, return that */
404 buffer_read (&priv
->converted_buffer
, buffer
, count
);
408 /* Full request not available, read all currently available and request
409 refill/conversion for more */
411 buffer_read (&priv
->converted_buffer
, buffer
, available
);
413 total_bytes_read
= available
;
414 buffer
= (char *) buffer
+ available
;
417 /* If there is no data to convert, and no pre-converted data,
418 do some i/o for more input */
419 if (buffer_data_size (&priv
->input_buffer
) == 0 &&
420 total_bytes_read
== 0 &&
423 nread
= fill_input_buffer (cstream
, count
, blocking
, cancellable
, error
);
427 priv
->at_input_end
= TRUE
;
430 /* First try to convert any available data (or state) directly to the user buffer: */
434 res
= g_converter_convert (priv
->converter
,
435 buffer_data (&priv
->input_buffer
),
436 buffer_data_size (&priv
->input_buffer
),
438 priv
->at_input_end
? G_CONVERTER_INPUT_AT_END
: 0,
442 if (res
!= G_CONVERTER_ERROR
)
444 total_bytes_read
+= bytes_written
;
445 buffer_consumed (&priv
->input_buffer
, bytes_read
);
446 if (res
== G_CONVERTER_FINISHED
)
447 priv
->finished
= TRUE
; /* We're done converting */
449 else if (total_bytes_read
== 0 &&
450 !g_error_matches (my_error
,
452 G_IO_ERROR_PARTIAL_INPUT
) &&
453 !g_error_matches (my_error
,
455 G_IO_ERROR_NO_SPACE
))
457 /* No previously read data and no "special" error, return error */
458 g_propagate_error (error
, my_error
);
462 g_error_free (my_error
);
465 /* We had some pre-converted data and/or we converted directly to the
467 if (total_bytes_read
> 0)
468 return total_bytes_read
;
470 /* If there is no more to convert, return EOF */
473 g_assert (buffer_data_size (&priv
->converted_buffer
) == 0);
477 /* There was "complexity" in the straight-to-buffer conversion,
478 * convert to our own buffer and write from that.
479 * At this point we didn't produce any data into @buffer.
482 /* Ensure we have *some* initial target space */
483 buffer_ensure_space (&priv
->converted_buffer
, count
);
487 g_assert (!priv
->finished
);
489 /* Try to convert to our buffer */
491 res
= g_converter_convert (priv
->converter
,
492 buffer_data (&priv
->input_buffer
),
493 buffer_data_size (&priv
->input_buffer
),
494 buffer_data (&priv
->converted_buffer
),
495 buffer_tailspace (&priv
->converted_buffer
),
496 priv
->at_input_end
? G_CONVERTER_INPUT_AT_END
: 0,
500 if (res
!= G_CONVERTER_ERROR
)
502 priv
->converted_buffer
.end
+= bytes_written
;
503 buffer_consumed (&priv
->input_buffer
, bytes_read
);
505 /* Maybe we consumed without producing any output */
506 if (buffer_data_size (&priv
->converted_buffer
) == 0 && res
!= G_CONVERTER_FINISHED
)
507 continue; /* Convert more */
509 if (res
== G_CONVERTER_FINISHED
)
510 priv
->finished
= TRUE
;
512 total_bytes_read
= MIN (count
, buffer_data_size (&priv
->converted_buffer
));
513 buffer_read (&priv
->converted_buffer
, buffer
, total_bytes_read
);
515 g_assert (priv
->finished
|| total_bytes_read
> 0);
517 return total_bytes_read
;
520 /* There was some kind of error filling our buffer */
522 if (g_error_matches (my_error
,
524 G_IO_ERROR_PARTIAL_INPUT
) &&
529 nread
= fill_input_buffer (cstream
,
530 buffer_data_size (&priv
->input_buffer
) + 4096,
536 /* Can't read any more data, return that error */
537 g_error_free (my_error
);
538 g_propagate_error (error
, my_error2
);
539 priv
->need_input
= TRUE
;
544 /* End of file, try INPUT_AT_END */
545 priv
->at_input_end
= TRUE
;
547 g_error_free (my_error
);
551 if (g_error_matches (my_error
,
553 G_IO_ERROR_NO_SPACE
))
555 /* Need more destination space, grow it
556 * Note: if we actually grow the buffer (as opposed to compacting it),
557 * this will double the size, not just add one byte. */
558 buffer_ensure_space (&priv
->converted_buffer
,
559 priv
->converted_buffer
.size
+ 1);
560 g_error_free (my_error
);
564 /* Any other random error, return it */
565 g_propagate_error (error
, my_error
);
569 g_assert_not_reached ();
573 g_converter_input_stream_read (GInputStream
*stream
,
576 GCancellable
*cancellable
,
579 return read_internal (stream
, buffer
, count
, TRUE
, cancellable
, error
);
583 g_converter_input_stream_can_poll (GPollableInputStream
*stream
)
585 GInputStream
*base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
587 return (G_IS_POLLABLE_INPUT_STREAM (base_stream
) &&
588 g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (base_stream
)));
592 g_converter_input_stream_is_readable (GPollableInputStream
*stream
)
594 GInputStream
*base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
595 GConverterInputStream
*cstream
= G_CONVERTER_INPUT_STREAM (stream
);
597 if (buffer_data_size (&cstream
->priv
->converted_buffer
))
599 else if (buffer_data_size (&cstream
->priv
->input_buffer
) &&
600 !cstream
->priv
->need_input
)
603 return g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (base_stream
));
607 g_converter_input_stream_read_nonblocking (GPollableInputStream
*stream
,
612 return read_internal (G_INPUT_STREAM (stream
), buffer
, count
,
617 g_converter_input_stream_create_source (GPollableInputStream
*stream
,
618 GCancellable
*cancellable
)
620 GInputStream
*base_stream
= G_FILTER_INPUT_STREAM (stream
)->base_stream
;
621 GSource
*base_source
, *pollable_source
;
623 if (g_pollable_input_stream_is_readable (stream
))
624 base_source
= g_timeout_source_new (0);
626 base_source
= g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (base_stream
), NULL
);
628 pollable_source
= g_pollable_source_new_full (stream
, base_source
,
630 g_source_unref (base_source
);
632 return pollable_source
;
637 * g_converter_input_stream_get_converter:
638 * @converter_stream: a #GConverterInputStream
640 * Gets the #GConverter that is used by @converter_stream.
642 * Returns: (transfer none): the converter of the converter input stream
647 g_converter_input_stream_get_converter (GConverterInputStream
*converter_stream
)
649 return converter_stream
->priv
->converter
;