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 "gsimpleasyncresult.h"
29 #include "gcancellable.h"
30 #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.
47 #define INITIAL_BUFFER_SIZE 4096
56 struct _GConverterInputStreamPrivate {
57 gboolean at_input_end;
59 GConverter *converter;
61 Buffer converted_buffer;
69 static void g_converter_input_stream_set_property (GObject *object,
73 static void g_converter_input_stream_get_property (GObject *object,
77 static void g_converter_input_stream_finalize (GObject *object);
78 static gssize g_converter_input_stream_read (GInputStream *stream,
81 GCancellable *cancellable,
84 G_DEFINE_TYPE (GConverterInputStream,
85 g_converter_input_stream,
86 G_TYPE_FILTER_INPUT_STREAM)
89 g_converter_input_stream_class_init (GConverterInputStreamClass *klass)
91 GObjectClass *object_class;
92 GInputStreamClass *istream_class;
94 g_type_class_add_private (klass, sizeof (GConverterInputStreamPrivate));
96 object_class = G_OBJECT_CLASS (klass);
97 object_class->get_property = g_converter_input_stream_get_property;
98 object_class->set_property = g_converter_input_stream_set_property;
99 object_class->finalize = g_converter_input_stream_finalize;
101 istream_class = G_INPUT_STREAM_CLASS (klass);
102 istream_class->read_fn = g_converter_input_stream_read;
104 g_object_class_install_property (object_class,
106 g_param_spec_object ("converter",
108 P_("The converter object"),
111 G_PARAM_CONSTRUCT_ONLY|
112 G_PARAM_STATIC_STRINGS));
117 g_converter_input_stream_finalize (GObject *object)
119 GConverterInputStreamPrivate *priv;
120 GConverterInputStream *stream;
122 stream = G_CONVERTER_INPUT_STREAM (object);
125 g_free (priv->input_buffer.data);
126 g_free (priv->converted_buffer.data);
128 g_object_unref (priv->converter);
130 G_OBJECT_CLASS (g_converter_input_stream_parent_class)->finalize (object);
134 g_converter_input_stream_set_property (GObject *object,
139 GConverterInputStream *cstream;
141 cstream = G_CONVERTER_INPUT_STREAM (object);
146 cstream->priv->converter = g_value_dup_object (value);
150 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
157 g_converter_input_stream_get_property (GObject *object,
162 GConverterInputStreamPrivate *priv;
163 GConverterInputStream *cstream;
165 cstream = G_CONVERTER_INPUT_STREAM (object);
166 priv = cstream->priv;
171 g_value_set_object (value, priv->converter);
175 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
181 g_converter_input_stream_init (GConverterInputStream *stream)
183 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
184 G_TYPE_CONVERTER_INPUT_STREAM,
185 GConverterInputStreamPrivate);
189 * g_converter_input_stream_new:
190 * @base_stream: a #GInputStream.
192 * Creates a new converter input stream for the @base_stream.
194 * Returns: a new #GInputStream.
197 g_converter_input_stream_new (GInputStream *base_stream,
198 GConverter *converter)
200 GInputStream *stream;
202 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream), NULL);
204 stream = g_object_new (G_TYPE_CONVERTER_INPUT_STREAM,
205 "base-stream", base_stream,
206 "converter", converter,
213 buffer_available (Buffer *buffer)
215 return buffer->end - buffer->start;
219 buffer_tailspace (Buffer *buffer)
221 return buffer->size - buffer->end;
225 buffer_data (Buffer *buffer)
227 return buffer->data + buffer->start;
231 buffer_consumed (Buffer *buffer,
234 buffer->start += count;
235 if (buffer->start == buffer->end)
236 buffer->start = buffer->end = 0;
240 buffer_read (Buffer *buffer,
244 memcpy (dest, buffer->data + buffer->start, count);
245 buffer_consumed (buffer, count);
249 compact_buffer (Buffer *buffer)
253 in_buffer = buffer_available (buffer);
254 memmove (buffer->data,
255 buffer->data + buffer->start,
257 buffer->end -= buffer->start;
262 grow_buffer (Buffer *buffer)
265 gsize size, in_buffer;
267 if (buffer->size == 0)
268 size = INITIAL_BUFFER_SIZE;
270 size = buffer->size * 2;
272 data = g_malloc (size);
273 in_buffer = buffer_available (buffer);
276 buffer->data + buffer->start,
278 g_free (buffer->data);
280 buffer->end -= buffer->start;
286 buffer_ensure_space (Buffer *buffer,
289 gsize in_buffer, left_to_fill;
291 in_buffer = buffer_available (buffer);
293 if (in_buffer >= at_least_size)
296 left_to_fill = buffer_tailspace (buffer);
298 if (in_buffer + left_to_fill >= at_least_size)
300 /* We fit in remaining space at end */
301 /* If the copy is small, compact now anyway so we can fill more */
303 compact_buffer (buffer);
305 else if (buffer->size >= at_least_size)
307 /* We fit, but only if we compact */
308 compact_buffer (buffer);
312 /* Need to grow buffer */
313 while (buffer->size < at_least_size)
314 grow_buffer (buffer);
319 fill_input_buffer (GConverterInputStream *stream,
321 GCancellable *cancellable,
324 GConverterInputStreamPrivate *priv;
325 GInputStream *base_stream;
330 buffer_ensure_space (&priv->input_buffer, at_least_size);
332 base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
333 nread = g_input_stream_read (base_stream,
334 priv->input_buffer.data + priv->input_buffer.end,
335 buffer_tailspace (&priv->input_buffer),
340 priv->input_buffer.end += nread;
347 g_converter_input_stream_read (GInputStream *stream,
350 GCancellable *cancellable,
353 GConverterInputStream *cstream;
354 GConverterInputStreamPrivate *priv;
355 gsize available, total_bytes_read;
357 GConverterResult res;
363 cstream = G_CONVERTER_INPUT_STREAM (stream);
364 priv = cstream->priv;
366 available = buffer_available (&priv->converted_buffer);
371 /* Converted data available, return that */
372 buffer_read (&priv->converted_buffer, buffer, count);
376 /* Full request not available, read all currently available and request
377 refill/conversion for more */
379 buffer_read (&priv->converted_buffer, buffer, available);
381 total_bytes_read = available;
384 /* If there is no data to convert, and no pre-converted data,
385 do some i/o for more input */
386 if (buffer_available (&priv->input_buffer) == 0 &&
387 total_bytes_read == 0 &&
390 nread = fill_input_buffer (cstream, count, cancellable, error);
394 priv->at_input_end = TRUE;
397 /* First try to convert any available data (or state) directly to the user buffer: */
401 res = g_converter_convert (priv->converter,
402 buffer_data (&priv->input_buffer),
403 buffer_available (&priv->input_buffer),
405 priv->at_input_end ? G_CONVERTER_INPUT_AT_END : 0,
409 if (res != G_CONVERTER_ERROR)
411 total_bytes_read += bytes_written;
412 buffer_consumed (&priv->input_buffer, bytes_read);
413 if (res == G_CONVERTER_FINISHED)
414 priv->finished = TRUE; /* We're done converting */
416 else if (total_bytes_read == 0 &&
417 !g_error_matches (my_error,
419 G_IO_ERROR_PARTIAL_INPUT) &&
420 !g_error_matches (my_error,
422 G_IO_ERROR_NO_SPACE))
424 /* No previously read data and no "special" error, return error */
425 g_propagate_error (error, my_error);
429 g_error_free (my_error);
432 /* We had some pre-converted data and/or we converted directly to the
434 if (total_bytes_read > 0)
435 return total_bytes_read;
437 /* If there is no more to convert, return EOF */
440 g_assert (buffer_available (&priv->converted_buffer) == 0);
444 /* There was "complexity" in the straight-to-buffer conversion,
445 * convert to our own buffer and write from that.
446 * At this point we didn't produce any data into @buffer.
449 /* Ensure we have *some* initial target space */
450 buffer_ensure_space (&priv->converted_buffer, count);
454 g_assert (!priv->finished);
456 /* Try to convert to our buffer */
458 res = g_converter_convert (priv->converter,
459 buffer_data (&priv->input_buffer),
460 buffer_available (&priv->input_buffer),
461 buffer_data (&priv->converted_buffer),
462 buffer_tailspace (&priv->converted_buffer),
463 priv->at_input_end ? G_CONVERTER_INPUT_AT_END : 0,
467 if (res != G_CONVERTER_ERROR)
469 priv->converted_buffer.end += bytes_written;
470 buffer_consumed (&priv->input_buffer, bytes_read);
472 /* Maybe we consumed without producing any output */
473 if (buffer_available (&priv->converted_buffer) == 0 && res != G_CONVERTER_FINISHED)
474 continue; /* Convert more */
476 if (res == G_CONVERTER_FINISHED)
477 priv->finished = TRUE;
479 total_bytes_read = MIN (count, buffer_available (&priv->converted_buffer));
480 buffer_read (&priv->converted_buffer, buffer, total_bytes_read);
482 g_assert (priv->finished || total_bytes_read > 0);
484 return total_bytes_read;
487 /* There was some kind of error filling our buffer */
489 if (g_error_matches (my_error,
491 G_IO_ERROR_PARTIAL_INPUT) &&
496 res = fill_input_buffer (cstream,
497 buffer_available (&priv->input_buffer) + 4096,
502 /* Can't read any more data, return that error */
503 g_error_free (my_error);
504 g_propagate_error (error, my_error2);
509 /* End of file, try INPUT_AT_END */
510 priv->at_input_end = TRUE;
512 g_error_free (my_error);
516 if (g_error_matches (my_error,
518 G_IO_ERROR_NO_SPACE))
520 /* Need more destination space, grow it
521 * Note: if we actually grow the buffer (as opposed to compacting it),
522 * this will double the size, not just add one byte. */
523 buffer_ensure_space (&priv->converted_buffer,
524 priv->converted_buffer.size + 1);
525 g_error_free (my_error);
529 /* Any other random error, return it */
530 g_propagate_error (error, my_error);
534 g_assert_not_reached ();
538 g_converter_input_stream_get_converter (GConverterInputStream *converter_stream)
540 return converter_stream->priv->converter;
543 #define __G_CONVERTER_INPUT_STREAM_C__
544 #include "gioaliasdef.c"