1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 * Copyright (C) 2007 Jürg Billeter
5 * Copyright © 2009 Codethink Limited
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
22 * Author: Alexander Larsson <alexl@redhat.com>
26 #include "gdatainputstream.h"
27 #include "gsimpleasyncresult.h"
28 #include "gcancellable.h"
29 #include "gioenumtypes.h"
36 * SECTION:gdatainputstream
37 * @short_description: Data Input Stream
39 * @see_also: #GInputStream
41 * Data input stream implements #GInputStream and includes functions for
42 * reading structured data directly from a binary input stream.
46 struct _GDataInputStreamPrivate {
47 GDataStreamByteOrder byte_order;
48 GDataStreamNewlineType newline_type;
57 static void g_data_input_stream_set_property (GObject *object,
61 static void g_data_input_stream_get_property (GObject *object,
66 G_DEFINE_TYPE (GDataInputStream,
68 G_TYPE_BUFFERED_INPUT_STREAM)
72 g_data_input_stream_class_init (GDataInputStreamClass *klass)
74 GObjectClass *object_class;
76 g_type_class_add_private (klass, sizeof (GDataInputStreamPrivate));
78 object_class = G_OBJECT_CLASS (klass);
79 object_class->get_property = g_data_input_stream_get_property;
80 object_class->set_property = g_data_input_stream_set_property;
83 * GDataStream:byte-order:
85 * The ::byte-order property determines the byte ordering that
86 * is used when reading multi-byte entities (such as integers)
89 g_object_class_install_property (object_class,
91 g_param_spec_enum ("byte-order",
94 G_TYPE_DATA_STREAM_BYTE_ORDER,
95 G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
96 G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_BLURB));
99 * GDataStream:newline-type:
101 * The :newline-type property determines what is considered
102 * as a line ending when reading complete lines from the stream.
104 g_object_class_install_property (object_class,
106 g_param_spec_enum ("newline-type",
108 P_("The accepted types of line ending"),
109 G_TYPE_DATA_STREAM_NEWLINE_TYPE,
110 G_DATA_STREAM_NEWLINE_TYPE_LF,
111 G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_BLURB));
115 g_data_input_stream_set_property (GObject *object,
120 GDataInputStreamPrivate *priv;
121 GDataInputStream *dstream;
123 dstream = G_DATA_INPUT_STREAM (object);
124 priv = dstream->priv;
128 case PROP_BYTE_ORDER:
129 g_data_input_stream_set_byte_order (dstream, g_value_get_enum (value));
132 case PROP_NEWLINE_TYPE:
133 g_data_input_stream_set_newline_type (dstream, g_value_get_enum (value));
137 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
144 g_data_input_stream_get_property (GObject *object,
149 GDataInputStreamPrivate *priv;
150 GDataInputStream *dstream;
152 dstream = G_DATA_INPUT_STREAM (object);
153 priv = dstream->priv;
157 case PROP_BYTE_ORDER:
158 g_value_set_enum (value, priv->byte_order);
161 case PROP_NEWLINE_TYPE:
162 g_value_set_enum (value, priv->newline_type);
166 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
172 g_data_input_stream_init (GDataInputStream *stream)
174 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
175 G_TYPE_DATA_INPUT_STREAM,
176 GDataInputStreamPrivate);
178 stream->priv->byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
179 stream->priv->newline_type = G_DATA_STREAM_NEWLINE_TYPE_LF;
183 * g_data_input_stream_new:
184 * @base_stream: a #GInputStream.
186 * Creates a new data input stream for the @base_stream.
188 * Returns: a new #GDataInputStream.
191 g_data_input_stream_new (GInputStream *base_stream)
193 GDataInputStream *stream;
195 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream), NULL);
197 stream = g_object_new (G_TYPE_DATA_INPUT_STREAM,
198 "base-stream", base_stream,
205 * g_data_input_stream_set_byte_order:
206 * @stream: a given #GDataInputStream.
207 * @order: a #GDataStreamByteOrder to set.
209 * This function sets the byte order for the given @stream. All subsequent
210 * reads from the @stream will be read in the given @order.
214 g_data_input_stream_set_byte_order (GDataInputStream *stream,
215 GDataStreamByteOrder order)
217 GDataInputStreamPrivate *priv;
219 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
223 if (priv->byte_order != order)
225 priv->byte_order = order;
227 g_object_notify (G_OBJECT (stream), "byte-order");
232 * g_data_input_stream_get_byte_order:
233 * @stream: a given #GDataInputStream.
235 * Gets the byte order for the data input stream.
237 * Returns: the @stream's current #GDataStreamByteOrder.
240 g_data_input_stream_get_byte_order (GDataInputStream *stream)
242 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
244 return stream->priv->byte_order;
248 * g_data_input_stream_set_newline_type:
249 * @stream: a #GDataInputStream.
250 * @type: the type of new line return as #GDataStreamNewlineType.
252 * Sets the newline type for the @stream.
254 * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
255 * chunk ends in "CR" we must read an additional byte to know if this is "CR" or
256 * "CR LF", and this might block if there is no more data availible.
260 g_data_input_stream_set_newline_type (GDataInputStream *stream,
261 GDataStreamNewlineType type)
263 GDataInputStreamPrivate *priv;
265 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
269 if (priv->newline_type != type)
271 priv->newline_type = type;
273 g_object_notify (G_OBJECT (stream), "newline-type");
278 * g_data_input_stream_get_newline_type:
279 * @stream: a given #GDataInputStream.
281 * Gets the current newline type for the @stream.
283 * Returns: #GDataStreamNewlineType for the given @stream.
285 GDataStreamNewlineType
286 g_data_input_stream_get_newline_type (GDataInputStream *stream)
288 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_NEWLINE_TYPE_ANY);
290 return stream->priv->newline_type;
294 read_data (GDataInputStream *stream,
297 GCancellable *cancellable,
303 while ((available = g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (stream))) < size)
305 res = g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (stream),
312 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
313 _("Unexpected early end-of-stream"));
318 /* This should always succeed, since it's in the buffer */
319 res = g_input_stream_read (G_INPUT_STREAM (stream),
322 g_warn_if_fail (res == size);
328 * g_data_input_stream_read_byte:
329 * @stream: a given #GDataInputStream.
330 * @cancellable: optional #GCancellable object, %NULL to ignore.
331 * @error: #GError for error reporting.
333 * Reads an unsigned 8-bit/1-byte value from @stream.
335 * Returns: an unsigned 8-bit/1-byte value read from the @stream or %0
336 * if an error occurred.
339 g_data_input_stream_read_byte (GDataInputStream *stream,
340 GCancellable *cancellable,
345 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), '\0');
347 if (read_data (stream, &c, 1, cancellable, error))
355 * g_data_input_stream_read_int16:
356 * @stream: a given #GDataInputStream.
357 * @cancellable: optional #GCancellable object, %NULL to ignore.
358 * @error: #GError for error reporting.
360 * Reads a 16-bit/2-byte value from @stream.
362 * In order to get the correct byte order for this read operation,
363 * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order().
365 * Returns: a signed 16-bit/2-byte value read from @stream or %0 if
369 g_data_input_stream_read_int16 (GDataInputStream *stream,
370 GCancellable *cancellable,
375 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
377 if (read_data (stream, &v, 2, cancellable, error))
379 switch (stream->priv->byte_order)
381 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
382 v = GINT16_FROM_BE (v);
384 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
385 v = GINT16_FROM_LE (v);
387 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
399 * g_data_input_stream_read_uint16:
400 * @stream: a given #GDataInputStream.
401 * @cancellable: optional #GCancellable object, %NULL to ignore.
402 * @error: #GError for error reporting.
404 * Reads an unsigned 16-bit/2-byte value from @stream.
406 * In order to get the correct byte order for this read operation,
407 * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order().
409 * Returns: an unsigned 16-bit/2-byte value read from the @stream or %0 if
413 g_data_input_stream_read_uint16 (GDataInputStream *stream,
414 GCancellable *cancellable,
419 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
421 if (read_data (stream, &v, 2, cancellable, error))
423 switch (stream->priv->byte_order)
425 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
426 v = GUINT16_FROM_BE (v);
428 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
429 v = GUINT16_FROM_LE (v);
431 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
443 * g_data_input_stream_read_int32:
444 * @stream: a given #GDataInputStream.
445 * @cancellable: optional #GCancellable object, %NULL to ignore.
446 * @error: #GError for error reporting.
448 * Reads a signed 32-bit/4-byte value from @stream.
450 * In order to get the correct byte order for this read operation,
451 * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order().
453 * If @cancellable is not %NULL, then the operation can be cancelled by
454 * triggering the cancellable object from another thread. If the operation
455 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
457 * Returns: a signed 32-bit/4-byte value read from the @stream or %0 if
461 g_data_input_stream_read_int32 (GDataInputStream *stream,
462 GCancellable *cancellable,
467 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
469 if (read_data (stream, &v, 4, cancellable, error))
471 switch (stream->priv->byte_order)
473 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
474 v = GINT32_FROM_BE (v);
476 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
477 v = GINT32_FROM_LE (v);
479 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
491 * g_data_input_stream_read_uint32:
492 * @stream: a given #GDataInputStream.
493 * @cancellable: optional #GCancellable object, %NULL to ignore.
494 * @error: #GError for error reporting.
496 * Reads an unsigned 32-bit/4-byte value from @stream.
498 * In order to get the correct byte order for this read operation,
499 * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order().
501 * If @cancellable is not %NULL, then the operation can be cancelled by
502 * triggering the cancellable object from another thread. If the operation
503 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
505 * Returns: an unsigned 32-bit/4-byte value read from the @stream or %0 if
509 g_data_input_stream_read_uint32 (GDataInputStream *stream,
510 GCancellable *cancellable,
515 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
517 if (read_data (stream, &v, 4, cancellable, error))
519 switch (stream->priv->byte_order)
521 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
522 v = GUINT32_FROM_BE (v);
524 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
525 v = GUINT32_FROM_LE (v);
527 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
539 * g_data_input_stream_read_int64:
540 * @stream: a given #GDataInputStream.
541 * @cancellable: optional #GCancellable object, %NULL to ignore.
542 * @error: #GError for error reporting.
544 * Reads a 64-bit/8-byte value from @stream.
546 * In order to get the correct byte order for this read operation,
547 * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order().
549 * If @cancellable is not %NULL, then the operation can be cancelled by
550 * triggering the cancellable object from another thread. If the operation
551 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
553 * Returns: a signed 64-bit/8-byte value read from @stream or %0 if
557 g_data_input_stream_read_int64 (GDataInputStream *stream,
558 GCancellable *cancellable,
563 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
565 if (read_data (stream, &v, 8, cancellable, error))
567 switch (stream->priv->byte_order)
569 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
570 v = GINT64_FROM_BE (v);
572 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
573 v = GINT64_FROM_LE (v);
575 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
587 * g_data_input_stream_read_uint64:
588 * @stream: a given #GDataInputStream.
589 * @cancellable: optional #GCancellable object, %NULL to ignore.
590 * @error: #GError for error reporting.
592 * Reads an unsigned 64-bit/8-byte value from @stream.
594 * In order to get the correct byte order for this read operation,
595 * see g_data_stream_get_byte_order().
597 * If @cancellable is not %NULL, then the operation can be cancelled by
598 * triggering the cancellable object from another thread. If the operation
599 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
601 * Returns: an unsigned 64-bit/8-byte read from @stream or %0 if
605 g_data_input_stream_read_uint64 (GDataInputStream *stream,
606 GCancellable *cancellable,
611 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
613 if (read_data (stream, &v, 8, cancellable, error))
615 switch (stream->priv->byte_order)
617 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
618 v = GUINT64_FROM_BE (v);
620 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
621 v = GUINT64_FROM_LE (v);
623 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
634 scan_for_newline (GDataInputStream *stream,
636 gboolean *last_saw_cr_out,
637 int *newline_len_out)
639 GBufferedInputStream *bstream;
640 GDataInputStreamPrivate *priv;
642 gsize start, end, peeked;
646 gsize available, checked;
647 gboolean last_saw_cr;
651 bstream = G_BUFFERED_INPUT_STREAM (stream);
653 checked = *checked_out;
654 last_saw_cr = *last_saw_cr_out;
659 buffer = (const char*)g_buffered_input_stream_peek_buffer (bstream, &available) + start;
661 peeked = end - start;
663 for (i = 0; checked < available && i < peeked; i++)
665 switch (priv->newline_type)
667 case G_DATA_STREAM_NEWLINE_TYPE_LF:
670 found_pos = start + i;
674 case G_DATA_STREAM_NEWLINE_TYPE_CR:
677 found_pos = start + i;
681 case G_DATA_STREAM_NEWLINE_TYPE_CR_LF:
682 if (last_saw_cr && buffer[i] == 10)
684 found_pos = start + i - 1;
689 case G_DATA_STREAM_NEWLINE_TYPE_ANY:
690 if (buffer[i] == 10) /* LF */
695 found_pos = start + i - 1;
701 found_pos = start + i;
705 else if (last_saw_cr)
707 /* Last was cr, this is not LF, end is CR */
708 found_pos = start + i - 1;
711 /* Don't check for CR here, instead look at last_saw_cr on next byte */
715 last_saw_cr = (buffer[i] == 13);
719 *newline_len_out = newline_len;
726 *checked_out = checked;
727 *last_saw_cr_out = last_saw_cr;
733 * g_data_input_stream_read_line:
734 * @stream: a given #GDataInputStream.
735 * @length: a #gsize to get the length of the data read in.
736 * @cancellable: optional #GCancellable object, %NULL to ignore.
737 * @error: #GError for error reporting.
739 * Reads a line from the data input stream.
741 * If @cancellable is not %NULL, then the operation can be cancelled by
742 * triggering the cancellable object from another thread. If the operation
743 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
745 * Returns: a string with the line that was read in (without the newlines).
746 * Set @length to a #gsize to get the length of the read line.
747 * On an error, it will return %NULL and @error will be set. If there's no
748 * content to read, it will still return %NULL, but @error won't be set.
751 g_data_input_stream_read_line (GDataInputStream *stream,
753 GCancellable *cancellable,
756 GBufferedInputStream *bstream;
758 gboolean last_saw_cr;
764 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL);
766 bstream = G_BUFFERED_INPUT_STREAM (stream);
772 while ((found_pos = scan_for_newline (stream, &checked, &last_saw_cr, &newline_len)) == -1)
774 if (g_buffered_input_stream_get_available (bstream) ==
775 g_buffered_input_stream_get_buffer_size (bstream))
776 g_buffered_input_stream_set_buffer_size (bstream,
777 2 * g_buffered_input_stream_get_buffer_size (bstream));
779 res = g_buffered_input_stream_fill (bstream, -1, cancellable, error);
785 if (g_buffered_input_stream_get_available (bstream) == 0)
800 line = g_malloc (found_pos + newline_len + 1);
802 res = g_input_stream_read (G_INPUT_STREAM (stream),
804 found_pos + newline_len,
807 *length = (gsize)found_pos;
808 g_warn_if_fail (res == found_pos + newline_len);
815 scan_for_chars (GDataInputStream *stream,
817 const char *stop_chars)
819 GBufferedInputStream *bstream;
820 GDataInputStreamPrivate *priv;
822 gsize start, end, peeked;
825 gsize available, checked;
826 const char *stop_char;
830 bstream = G_BUFFERED_INPUT_STREAM (stream);
832 checked = *checked_out;
836 buffer = (const char *)g_buffered_input_stream_peek_buffer (bstream, &available) + start;
838 peeked = end - start;
840 for (i = 0; checked < available && i < peeked; i++)
842 for (stop_char = stop_chars; *stop_char != '\0'; stop_char++)
844 if (buffer[i] == *stop_char)
851 *checked_out = checked;
856 * g_data_input_stream_read_until:
857 * @stream: a given #GDataInputStream.
858 * @stop_chars: characters to terminate the read.
859 * @length: a #gsize to get the length of the data read in.
860 * @cancellable: optional #GCancellable object, %NULL to ignore.
861 * @error: #GError for error reporting.
863 * Reads a string from the data input stream, up to the first
864 * occurrence of any of the stop characters.
866 * Returns: a string with the data that was read before encountering
867 * any of the stop characters. Set @length to a #gsize to get the length
868 * of the string. This function will return %NULL on an error.
871 g_data_input_stream_read_until (GDataInputStream *stream,
872 const gchar *stop_chars,
874 GCancellable *cancellable,
877 GBufferedInputStream *bstream;
884 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL);
886 bstream = G_BUFFERED_INPUT_STREAM (stream);
891 while ((found_pos = scan_for_chars (stream, &checked, stop_chars)) == -1)
893 if (g_buffered_input_stream_get_available (bstream) ==
894 g_buffered_input_stream_get_buffer_size (bstream))
895 g_buffered_input_stream_set_buffer_size (bstream,
896 2 * g_buffered_input_stream_get_buffer_size (bstream));
898 res = g_buffered_input_stream_fill (bstream, -1, cancellable, error);
904 if (g_buffered_input_stream_get_available (bstream) == 0)
919 data_until = g_malloc (found_pos + stop_char_len + 1);
921 res = g_input_stream_read (G_INPUT_STREAM (stream),
923 found_pos + stop_char_len,
926 *length = (gsize)found_pos;
927 g_warn_if_fail (res == found_pos + stop_char_len);
928 data_until[found_pos] = 0;
935 GDataInputStream *stream;
936 GSimpleAsyncResult *simple;
937 gboolean last_saw_cr;
940 GCancellable *cancellable;
945 } GDataInputStreamReadData;
948 g_data_input_stream_read_complete (GDataInputStreamReadData *data,
951 gboolean need_idle_dispatch)
953 if (read_length || skip_length)
957 data->length = read_length;
958 data->line = g_malloc (read_length + 1);
959 data->line[read_length] = '\0';
961 /* we already checked the buffer. this shouldn't fail. */
962 bytes = g_input_stream_read (G_INPUT_STREAM (data->stream),
963 data->line, read_length, NULL, NULL);
964 g_assert_cmpint (bytes, ==, read_length);
966 bytes = g_input_stream_skip (G_INPUT_STREAM (data->stream),
967 skip_length, NULL, NULL);
968 g_assert_cmpint (bytes, ==, skip_length);
971 if (need_idle_dispatch)
972 g_simple_async_result_complete_in_idle (data->simple);
974 g_simple_async_result_complete (data->simple);
976 g_object_unref (data->simple);
980 g_data_input_stream_read_line_ready (GObject *object,
981 GAsyncResult *result,
984 GDataInputStreamReadData *data = user_data;
989 /* this is a callback. finish the async call. */
991 GBufferedInputStream *buffer = G_BUFFERED_INPUT_STREAM (data->stream);
992 GError *error = NULL;
995 bytes = g_buffered_input_stream_fill_finish (buffer, result, &error);
1002 g_simple_async_result_set_from_error (data->simple, error);
1003 g_error_free (error);
1007 g_data_input_stream_read_complete (data, data->checked, 0, FALSE);
1011 /* only proceed if we got more bytes... */
1014 if (data->stop_chars)
1016 found_pos = scan_for_chars (data->stream,
1022 found_pos = scan_for_newline (data->stream, &data->checked,
1023 &data->last_saw_cr, &newline_len);
1025 if (found_pos == -1)
1026 /* didn't find a full line; need to buffer some more bytes */
1028 GBufferedInputStream *buffer = G_BUFFERED_INPUT_STREAM (data->stream);
1031 size = g_buffered_input_stream_get_buffer_size (buffer);
1033 if (g_buffered_input_stream_get_available (buffer) == size)
1034 /* need to grow the buffer */
1035 g_buffered_input_stream_set_buffer_size (buffer, size * 2);
1038 g_buffered_input_stream_fill_async (buffer, -1, data->io_priority,
1040 g_data_input_stream_read_line_ready,
1045 /* read the line and the EOL. no error is possible. */
1046 g_data_input_stream_read_complete (data, found_pos,
1047 newline_len, result == NULL);
1052 g_data_input_stream_read_data_free (gpointer user_data)
1054 GDataInputStreamReadData *data = user_data;
1056 /* we don't hold a ref to ->simple because it keeps a ref to us.
1057 * we are called because it is being finalized.
1060 g_free (data->stop_chars);
1061 if (data->cancellable)
1062 g_object_unref (data->cancellable);
1063 g_free (data->line);
1064 g_slice_free (GDataInputStreamReadData, data);
1068 g_data_input_stream_read_async (GDataInputStream *stream,
1069 const gchar *stop_chars,
1071 GCancellable *cancellable,
1072 GAsyncReadyCallback callback,
1074 gpointer source_tag)
1076 GDataInputStreamReadData *data;
1078 data = g_slice_new (GDataInputStreamReadData);
1079 data->stream = stream;
1081 g_object_ref (cancellable);
1082 data->cancellable = cancellable;
1083 data->stop_chars = g_strdup (stop_chars);
1084 data->io_priority = io_priority;
1085 data->last_saw_cr = FALSE;
1089 data->simple = g_simple_async_result_new (G_OBJECT (stream), callback,
1090 user_data, source_tag);
1091 g_simple_async_result_set_op_res_gpointer (data->simple, data,
1092 g_data_input_stream_read_data_free);
1093 g_data_input_stream_read_line_ready (NULL, NULL, data);
1097 g_data_input_stream_read_finish (GDataInputStream *stream,
1098 GAsyncResult *result,
1102 GDataInputStreamReadData *data;
1103 GSimpleAsyncResult *simple;
1106 simple = G_SIMPLE_ASYNC_RESULT (result);
1108 if (g_simple_async_result_propagate_error (simple, error))
1111 data = g_simple_async_result_get_op_res_gpointer (simple);
1117 *length = data->length;
1123 * g_data_input_stream_read_line_async:
1124 * @stream: a given #GDataInputStream.
1125 * @io_priority: the <link linkend="io-priority">I/O priority</link>
1127 * @cancellable: optional #GCancellable object, %NULL to ignore.
1128 * @callback: callback to call when the request is satisfied.
1129 * @user_data: the data to pass to callback function.
1131 * The asynchronous version of g_data_input_stream_read_line(). It is
1132 * an error to have two outstanding calls to this function.
1134 * When the operation is finished, @callback will be called. You
1135 * can then call g_data_input_stream_read_line_finish() to get
1136 * the result of the operation.
1141 g_data_input_stream_read_line_async (GDataInputStream *stream,
1143 GCancellable *cancellable,
1144 GAsyncReadyCallback callback,
1147 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
1148 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1150 g_data_input_stream_read_async (stream, NULL, io_priority,
1151 cancellable, callback, user_data,
1152 g_data_input_stream_read_line_async);
1156 * g_data_input_stream_read_until_async:
1157 * @stream: a given #GDataInputStream.
1158 * @stop_chars: characters to terminate the read.
1159 * @io_priority: the <link linkend="io-priority">I/O priority</link>
1161 * @cancellable: optional #GCancellable object, %NULL to ignore.
1162 * @callback: callback to call when the request is satisfied.
1163 * @user_data: the data to pass to callback function.
1165 * The asynchronous version of g_data_input_stream_read_until().
1166 * It is an error to have two outstanding calls to this function.
1168 * When the operation is finished, @callback will be called. You
1169 * can then call g_data_input_stream_read_until_finish() to get
1170 * the result of the operation.
1175 g_data_input_stream_read_until_async (GDataInputStream *stream,
1176 const gchar *stop_chars,
1178 GCancellable *cancellable,
1179 GAsyncReadyCallback callback,
1182 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
1183 g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1184 g_return_if_fail (stop_chars != NULL);
1186 g_data_input_stream_read_async (stream, stop_chars, io_priority,
1187 cancellable, callback, user_data,
1188 g_data_input_stream_read_until_async);
1192 * g_data_input_stream_read_line_finish:
1193 * @stream: a given #GDataInputStream.
1194 * @result: the #GAsyncResult that was provided to the callback.
1195 * @length: a #gsize to get the length of the data read in.
1196 * @error: #GError for error reporting.
1198 * Finish an asynchronous call started by
1199 * g_data_input_stream_read_line_async().
1201 * Returns: a string with the line that was read in (without the newlines).
1202 * Set @length to a #gsize to get the length of the read line.
1203 * On an error, it will return %NULL and @error will be set. If there's no
1204 * content to read, it will still return %NULL, but @error won't be set.
1209 g_data_input_stream_read_line_finish (GDataInputStream *stream,
1210 GAsyncResult *result,
1214 g_return_val_if_fail (
1215 g_simple_async_result_is_valid (result, G_OBJECT (stream),
1216 g_data_input_stream_read_line_async), NULL);
1218 return g_data_input_stream_read_finish (stream, result, length, error);
1222 * g_data_input_stream_read_until_finish:
1223 * @stream: a given #GDataInputStream.
1224 * @result: the #GAsyncResult that was provided to the callback.
1225 * @length: a #gsize to get the length of the data read in.
1226 * @error: #GError for error reporting.
1228 * Finish an asynchronous call started by
1229 * g_data_input_stream_read_until_async().
1233 * Returns: a string with the data that was read before encountering
1234 * any of the stop characters. Set @length to a #gsize to get the length
1235 * of the string. This function will return %NULL on an error.
1238 g_data_input_stream_read_until_finish (GDataInputStream *stream,
1239 GAsyncResult *result,
1243 g_return_val_if_fail (
1244 g_simple_async_result_is_valid (result, G_OBJECT (stream),
1245 g_data_input_stream_read_until_async), NULL);
1247 return g_data_input_stream_read_finish (stream, result, length, error);
1251 #define __G_DATA_INPUT_STREAM_C__
1252 #include "gioaliasdef.c"