docs: Small improvements to glib-mkenums man page
[glib.git] / gio / gmemoryoutputstream.c
blobde8babfa5bc5b4830509bc16c97037f9612c9da1
1 /* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 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.1 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, see <http://www.gnu.org/licenses/>.
18 * Authors:
19 * Christian Kellner <gicmo@gnome.org>
20 * Krzysztof KosiƄski <tweenk.pl@gmail.com>
23 #include "config.h"
24 #include "gmemoryoutputstream.h"
25 #include "goutputstream.h"
26 #include "gpollableoutputstream.h"
27 #include "gseekable.h"
28 #include "gtask.h"
29 #include "gioerror.h"
30 #include "string.h"
31 #include "glibintl.h"
34 /**
35 * SECTION:gmemoryoutputstream
36 * @short_description: Streaming output operations on memory chunks
37 * @include: gio/gio.h
38 * @see_also: #GMemoryInputStream
40 * #GMemoryOutputStream is a class for using arbitrary
41 * memory chunks as output for GIO streaming output operations.
43 * As of GLib 2.34, #GMemoryOutputStream trivially implements
44 * #GPollableOutputStream: it always polls as ready.
47 #define MIN_ARRAY_SIZE 16
49 enum {
50 PROP_0,
51 PROP_DATA,
52 PROP_SIZE,
53 PROP_DATA_SIZE,
54 PROP_REALLOC_FUNCTION,
55 PROP_DESTROY_FUNCTION
58 struct _GMemoryOutputStreamPrivate
60 gpointer data; /* Write buffer */
61 gsize len; /* Current length of the data buffer. Can change with resizing. */
62 gsize valid_len; /* The part of data that has been written to */
63 gsize pos; /* Current position in the stream. Distinct from valid_len,
64 because the stream is seekable. */
66 GReallocFunc realloc_fn;
67 GDestroyNotify destroy;
70 static void g_memory_output_stream_set_property (GObject *object,
71 guint prop_id,
72 const GValue *value,
73 GParamSpec *pspec);
74 static void g_memory_output_stream_get_property (GObject *object,
75 guint prop_id,
76 GValue *value,
77 GParamSpec *pspec);
78 static void g_memory_output_stream_finalize (GObject *object);
80 static gssize g_memory_output_stream_write (GOutputStream *stream,
81 const void *buffer,
82 gsize count,
83 GCancellable *cancellable,
84 GError **error);
86 static gboolean g_memory_output_stream_close (GOutputStream *stream,
87 GCancellable *cancellable,
88 GError **error);
90 static void g_memory_output_stream_close_async (GOutputStream *stream,
91 int io_priority,
92 GCancellable *cancellable,
93 GAsyncReadyCallback callback,
94 gpointer data);
95 static gboolean g_memory_output_stream_close_finish (GOutputStream *stream,
96 GAsyncResult *result,
97 GError **error);
99 static void g_memory_output_stream_seekable_iface_init (GSeekableIface *iface);
100 static goffset g_memory_output_stream_tell (GSeekable *seekable);
101 static gboolean g_memory_output_stream_can_seek (GSeekable *seekable);
102 static gboolean g_memory_output_stream_seek (GSeekable *seekable,
103 goffset offset,
104 GSeekType type,
105 GCancellable *cancellable,
106 GError **error);
107 static gboolean g_memory_output_stream_can_truncate (GSeekable *seekable);
108 static gboolean g_memory_output_stream_truncate (GSeekable *seekable,
109 goffset offset,
110 GCancellable *cancellable,
111 GError **error);
113 static gboolean g_memory_output_stream_is_writable (GPollableOutputStream *stream);
114 static GSource *g_memory_output_stream_create_source (GPollableOutputStream *stream,
115 GCancellable *cancellable);
117 static void g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface);
119 G_DEFINE_TYPE_WITH_CODE (GMemoryOutputStream, g_memory_output_stream, G_TYPE_OUTPUT_STREAM,
120 G_ADD_PRIVATE (GMemoryOutputStream)
121 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
122 g_memory_output_stream_seekable_iface_init);
123 G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM,
124 g_memory_output_stream_pollable_iface_init))
127 static void
128 g_memory_output_stream_class_init (GMemoryOutputStreamClass *klass)
130 GOutputStreamClass *ostream_class;
131 GObjectClass *gobject_class;
133 gobject_class = G_OBJECT_CLASS (klass);
134 gobject_class->set_property = g_memory_output_stream_set_property;
135 gobject_class->get_property = g_memory_output_stream_get_property;
136 gobject_class->finalize = g_memory_output_stream_finalize;
138 ostream_class = G_OUTPUT_STREAM_CLASS (klass);
140 ostream_class->write_fn = g_memory_output_stream_write;
141 ostream_class->close_fn = g_memory_output_stream_close;
142 ostream_class->close_async = g_memory_output_stream_close_async;
143 ostream_class->close_finish = g_memory_output_stream_close_finish;
146 * GMemoryOutputStream:data:
148 * Pointer to buffer where data will be written.
150 * Since: 2.24
152 g_object_class_install_property (gobject_class,
153 PROP_DATA,
154 g_param_spec_pointer ("data",
155 P_("Data Buffer"),
156 P_("Pointer to buffer where data will be written."),
157 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
158 G_PARAM_STATIC_STRINGS));
161 * GMemoryOutputStream:size:
163 * Current size of the data buffer.
165 * Since: 2.24
167 g_object_class_install_property (gobject_class,
168 PROP_SIZE,
169 g_param_spec_ulong ("size",
170 P_("Data Buffer Size"),
171 P_("Current size of the data buffer."),
172 0, G_MAXULONG, 0,
173 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
174 G_PARAM_STATIC_STRINGS));
177 * GMemoryOutputStream:data-size:
179 * Size of data written to the buffer.
181 * Since: 2.24
183 g_object_class_install_property (gobject_class,
184 PROP_DATA_SIZE,
185 g_param_spec_ulong ("data-size",
186 P_("Data Size"),
187 P_("Size of data written to the buffer."),
188 0, G_MAXULONG, 0,
189 G_PARAM_READABLE |
190 G_PARAM_STATIC_STRINGS));
193 * GMemoryOutputStream:realloc-function: (skip)
195 * Function with realloc semantics called to enlarge the buffer.
197 * Since: 2.24
199 g_object_class_install_property (gobject_class,
200 PROP_REALLOC_FUNCTION,
201 g_param_spec_pointer ("realloc-function",
202 P_("Memory Reallocation Function"),
203 P_("Function with realloc semantics called to enlarge the buffer."),
204 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
205 G_PARAM_STATIC_STRINGS));
208 * GMemoryOutputStream:destroy-function: (skip)
210 * Function called with the buffer as argument when the stream is destroyed.
212 * Since: 2.24
214 g_object_class_install_property (gobject_class,
215 PROP_DESTROY_FUNCTION,
216 g_param_spec_pointer ("destroy-function",
217 P_("Destroy Notification Function"),
218 P_("Function called with the buffer as argument when the stream is destroyed."),
219 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
220 G_PARAM_STATIC_STRINGS));
223 static void
224 g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface)
226 iface->is_writable = g_memory_output_stream_is_writable;
227 iface->create_source = g_memory_output_stream_create_source;
230 static void
231 g_memory_output_stream_set_property (GObject *object,
232 guint prop_id,
233 const GValue *value,
234 GParamSpec *pspec)
236 GMemoryOutputStream *stream;
237 GMemoryOutputStreamPrivate *priv;
239 stream = G_MEMORY_OUTPUT_STREAM (object);
240 priv = stream->priv;
242 switch (prop_id)
244 case PROP_DATA:
245 priv->data = g_value_get_pointer (value);
246 break;
247 case PROP_SIZE:
248 priv->len = g_value_get_ulong (value);
249 break;
250 case PROP_REALLOC_FUNCTION:
251 priv->realloc_fn = g_value_get_pointer (value);
252 break;
253 case PROP_DESTROY_FUNCTION:
254 priv->destroy = g_value_get_pointer (value);
255 break;
256 default:
257 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
258 break;
262 static void
263 g_memory_output_stream_get_property (GObject *object,
264 guint prop_id,
265 GValue *value,
266 GParamSpec *pspec)
268 GMemoryOutputStream *stream;
269 GMemoryOutputStreamPrivate *priv;
271 stream = G_MEMORY_OUTPUT_STREAM (object);
272 priv = stream->priv;
274 switch (prop_id)
276 case PROP_DATA:
277 g_value_set_pointer (value, priv->data);
278 break;
279 case PROP_SIZE:
280 g_value_set_ulong (value, priv->len);
281 break;
282 case PROP_DATA_SIZE:
283 g_value_set_ulong (value, priv->valid_len);
284 break;
285 case PROP_REALLOC_FUNCTION:
286 g_value_set_pointer (value, priv->realloc_fn);
287 break;
288 case PROP_DESTROY_FUNCTION:
289 g_value_set_pointer (value, priv->destroy);
290 break;
291 default:
292 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
293 break;
297 static void
298 g_memory_output_stream_finalize (GObject *object)
300 GMemoryOutputStream *stream;
301 GMemoryOutputStreamPrivate *priv;
303 stream = G_MEMORY_OUTPUT_STREAM (object);
304 priv = stream->priv;
306 if (priv->destroy)
307 priv->destroy (priv->data);
309 G_OBJECT_CLASS (g_memory_output_stream_parent_class)->finalize (object);
312 static void
313 g_memory_output_stream_seekable_iface_init (GSeekableIface *iface)
315 iface->tell = g_memory_output_stream_tell;
316 iface->can_seek = g_memory_output_stream_can_seek;
317 iface->seek = g_memory_output_stream_seek;
318 iface->can_truncate = g_memory_output_stream_can_truncate;
319 iface->truncate_fn = g_memory_output_stream_truncate;
323 static void
324 g_memory_output_stream_init (GMemoryOutputStream *stream)
326 stream->priv = g_memory_output_stream_get_instance_private (stream);
327 stream->priv->pos = 0;
328 stream->priv->valid_len = 0;
332 * g_memory_output_stream_new: (skip)
333 * @data: (nullable): pointer to a chunk of memory to use, or %NULL
334 * @size: the size of @data
335 * @realloc_function: (nullable): a function with realloc() semantics (like g_realloc())
336 * to be called when @data needs to be grown, or %NULL
337 * @destroy_function: (nullable): a function to be called on @data when the stream is
338 * finalized, or %NULL
340 * Creates a new #GMemoryOutputStream.
342 * In most cases this is not the function you want. See
343 * g_memory_output_stream_new_resizable() instead.
345 * If @data is non-%NULL, the stream will use that for its internal storage.
347 * If @realloc_fn is non-%NULL, it will be used for resizing the internal
348 * storage when necessary and the stream will be considered resizable.
349 * In that case, the stream will start out being (conceptually) empty.
350 * @size is used only as a hint for how big @data is. Specifically,
351 * seeking to the end of a newly-created stream will seek to zero, not
352 * @size. Seeking past the end of the stream and then writing will
353 * introduce a zero-filled gap.
355 * If @realloc_fn is %NULL then the stream is fixed-sized. Seeking to
356 * the end will seek to @size exactly. Writing past the end will give
357 * an 'out of space' error. Attempting to seek past the end will fail.
358 * Unlike the resizable case, seeking to an offset within the stream and
359 * writing will preserve the bytes passed in as @data before that point
360 * and will return them as part of g_memory_output_stream_steal_data().
361 * If you intend to seek you should probably therefore ensure that @data
362 * is properly initialised.
364 * It is probably only meaningful to provide @data and @size in the case
365 * that you want a fixed-sized stream. Put another way: if @realloc_fn
366 * is non-%NULL then it makes most sense to give @data as %NULL and
367 * @size as 0 (allowing #GMemoryOutputStream to do the initial
368 * allocation for itself).
370 * |[<!-- language="C" -->
371 * // a stream that can grow
372 * stream = g_memory_output_stream_new (NULL, 0, realloc, free);
374 * // another stream that can grow
375 * stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
377 * // a fixed-size stream
378 * data = malloc (200);
379 * stream3 = g_memory_output_stream_new (data, 200, NULL, free);
380 * ]|
382 * Returns: A newly created #GMemoryOutputStream object.
384 GOutputStream *
385 g_memory_output_stream_new (gpointer data,
386 gsize size,
387 GReallocFunc realloc_function,
388 GDestroyNotify destroy_function)
390 GOutputStream *stream;
392 stream = g_object_new (G_TYPE_MEMORY_OUTPUT_STREAM,
393 "data", data,
394 "size", size,
395 "realloc-function", realloc_function,
396 "destroy-function", destroy_function,
397 NULL);
399 return stream;
403 * g_memory_output_stream_new_resizable:
405 * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
406 * for memory allocation.
408 * Since: 2.36
410 GOutputStream *
411 g_memory_output_stream_new_resizable (void)
413 return g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
417 * g_memory_output_stream_get_data:
418 * @ostream: a #GMemoryOutputStream
420 * Gets any loaded data from the @ostream.
422 * Note that the returned pointer may become invalid on the next
423 * write or truncate operation on the stream.
425 * Returns: (transfer none): pointer to the stream's data, or %NULL if the data
426 * has been stolen
428 gpointer
429 g_memory_output_stream_get_data (GMemoryOutputStream *ostream)
431 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
433 return ostream->priv->data;
437 * g_memory_output_stream_get_size:
438 * @ostream: a #GMemoryOutputStream
440 * Gets the size of the currently allocated data area (available from
441 * g_memory_output_stream_get_data()).
443 * You probably don't want to use this function on resizable streams.
444 * See g_memory_output_stream_get_data_size() instead. For resizable
445 * streams the size returned by this function is an implementation
446 * detail and may be change at any time in response to operations on the
447 * stream.
449 * If the stream is fixed-sized (ie: no realloc was passed to
450 * g_memory_output_stream_new()) then this is the maximum size of the
451 * stream and further writes will return %G_IO_ERROR_NO_SPACE.
453 * In any case, if you want the number of bytes currently written to the
454 * stream, use g_memory_output_stream_get_data_size().
456 * Returns: the number of bytes allocated for the data buffer
458 gsize
459 g_memory_output_stream_get_size (GMemoryOutputStream *ostream)
461 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
463 return ostream->priv->len;
467 * g_memory_output_stream_get_data_size:
468 * @ostream: a #GMemoryOutputStream
470 * Returns the number of bytes from the start up to including the last
471 * byte written in the stream that has not been truncated away.
473 * Returns: the number of bytes written to the stream
475 * Since: 2.18
477 gsize
478 g_memory_output_stream_get_data_size (GMemoryOutputStream *ostream)
480 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
482 return ostream->priv->valid_len;
486 * g_memory_output_stream_steal_data:
487 * @ostream: a #GMemoryOutputStream
489 * Gets any loaded data from the @ostream. Ownership of the data
490 * is transferred to the caller; when no longer needed it must be
491 * freed using the free function set in @ostream's
492 * #GMemoryOutputStream:destroy-function property.
494 * @ostream must be closed before calling this function.
496 * Returns: (transfer full): the stream's data, or %NULL if it has previously
497 * been stolen
499 * Since: 2.26
501 gpointer
502 g_memory_output_stream_steal_data (GMemoryOutputStream *ostream)
504 gpointer data;
506 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
507 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream)), NULL);
509 data = ostream->priv->data;
510 ostream->priv->data = NULL;
512 return data;
516 * g_memory_output_stream_steal_as_bytes:
517 * @ostream: a #GMemoryOutputStream
519 * Returns data from the @ostream as a #GBytes. @ostream must be
520 * closed before calling this function.
522 * Returns: (transfer full): the stream's data
524 * Since: 2.34
526 GBytes *
527 g_memory_output_stream_steal_as_bytes (GMemoryOutputStream *ostream)
529 GBytes *result;
531 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
532 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream)), NULL);
534 result = g_bytes_new_with_free_func (ostream->priv->data,
535 ostream->priv->valid_len,
536 ostream->priv->destroy,
537 ostream->priv->data);
538 ostream->priv->data = NULL;
540 return result;
543 static gboolean
544 array_resize (GMemoryOutputStream *ostream,
545 gsize size,
546 gboolean allow_partial,
547 GError **error)
549 GMemoryOutputStreamPrivate *priv;
550 gpointer data;
551 gsize len;
553 priv = ostream->priv;
555 if (priv->len == size)
556 return TRUE;
558 if (!priv->realloc_fn)
560 if (allow_partial &&
561 priv->pos < priv->len)
562 return TRUE; /* Short write */
564 g_set_error_literal (error,
565 G_IO_ERROR,
566 G_IO_ERROR_NO_SPACE,
567 _("Memory output stream not resizable"));
568 return FALSE;
571 len = priv->len;
572 data = priv->realloc_fn (priv->data, size);
574 if (size > 0 && !data)
576 if (allow_partial &&
577 priv->pos < priv->len)
578 return TRUE; /* Short write */
580 g_set_error_literal (error,
581 G_IO_ERROR,
582 G_IO_ERROR_NO_SPACE,
583 _("Failed to resize memory output stream"));
584 return FALSE;
587 if (size > len)
588 memset ((guint8 *)data + len, 0, size - len);
590 priv->data = data;
591 priv->len = size;
593 if (priv->len < priv->valid_len)
594 priv->valid_len = priv->len;
596 return TRUE;
599 static gsize
600 g_nearest_pow (gsize num)
602 gsize n = 1;
604 while (n < num && n > 0)
605 n <<= 1;
607 return n;
610 static gssize
611 g_memory_output_stream_write (GOutputStream *stream,
612 const void *buffer,
613 gsize count,
614 GCancellable *cancellable,
615 GError **error)
617 GMemoryOutputStream *ostream;
618 GMemoryOutputStreamPrivate *priv;
619 guint8 *dest;
620 gsize new_size;
622 ostream = G_MEMORY_OUTPUT_STREAM (stream);
623 priv = ostream->priv;
625 if (count == 0)
626 return 0;
628 /* Check for address space overflow, but only if the buffer is resizable.
629 Otherwise we just do a short write and don't worry. */
630 if (priv->realloc_fn && priv->pos + count < priv->pos)
631 goto overflow;
633 if (priv->pos + count > priv->len)
635 /* At least enough to fit the write, rounded up for greater than
636 * linear growth.
638 * Assuming that we're using something like realloc(), the kernel
639 * will overcommit memory to us, so doubling the size each time
640 * will keep the number of realloc calls low without wasting too
641 * much memory.
643 new_size = g_nearest_pow (priv->pos + count);
644 /* Check for overflow again. We have checked if
645 pos + count > G_MAXSIZE, but now check if g_nearest_pow () has
646 overflowed */
647 if (new_size == 0)
648 goto overflow;
650 new_size = MAX (new_size, MIN_ARRAY_SIZE);
651 if (!array_resize (ostream, new_size, TRUE, error))
652 return -1;
655 /* Make sure we handle short writes if the array_resize
656 only added part of the required memory */
657 count = MIN (count, priv->len - priv->pos);
659 dest = (guint8 *)priv->data + priv->pos;
660 memcpy (dest, buffer, count);
661 priv->pos += count;
663 if (priv->pos > priv->valid_len)
664 priv->valid_len = priv->pos;
666 return count;
668 overflow:
669 /* Overflow: buffer size would need to be bigger than G_MAXSIZE. */
670 g_set_error_literal (error,
671 G_IO_ERROR,
672 G_IO_ERROR_NO_SPACE,
673 _("Amount of memory required to process the write is "
674 "larger than available address space"));
675 return -1;
678 static gboolean
679 g_memory_output_stream_close (GOutputStream *stream,
680 GCancellable *cancellable,
681 GError **error)
683 return TRUE;
686 static void
687 g_memory_output_stream_close_async (GOutputStream *stream,
688 int io_priority,
689 GCancellable *cancellable,
690 GAsyncReadyCallback callback,
691 gpointer data)
693 GTask *task;
695 task = g_task_new (stream, cancellable, callback, data);
696 g_task_set_source_tag (task, g_memory_output_stream_close_async);
698 /* will always return TRUE */
699 g_memory_output_stream_close (stream, cancellable, NULL);
701 g_task_return_boolean (task, TRUE);
702 g_object_unref (task);
705 static gboolean
706 g_memory_output_stream_close_finish (GOutputStream *stream,
707 GAsyncResult *result,
708 GError **error)
710 g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
712 return g_task_propagate_boolean (G_TASK (result), error);
715 static goffset
716 g_memory_output_stream_tell (GSeekable *seekable)
718 GMemoryOutputStream *stream;
719 GMemoryOutputStreamPrivate *priv;
721 stream = G_MEMORY_OUTPUT_STREAM (seekable);
722 priv = stream->priv;
724 return priv->pos;
727 static gboolean
728 g_memory_output_stream_can_seek (GSeekable *seekable)
730 return TRUE;
733 static gboolean
734 g_memory_output_stream_seek (GSeekable *seekable,
735 goffset offset,
736 GSeekType type,
737 GCancellable *cancellable,
738 GError **error)
740 GMemoryOutputStream *stream;
741 GMemoryOutputStreamPrivate *priv;
742 goffset absolute;
744 stream = G_MEMORY_OUTPUT_STREAM (seekable);
745 priv = stream->priv;
747 switch (type)
749 case G_SEEK_CUR:
750 absolute = priv->pos + offset;
751 break;
753 case G_SEEK_SET:
754 absolute = offset;
755 break;
757 case G_SEEK_END:
758 /* For resizable streams, we consider the end to be the data
759 * length. For fixed-sized streams, we consider the end to be the
760 * size of the buffer.
762 if (priv->realloc_fn)
763 absolute = priv->valid_len + offset;
764 else
765 absolute = priv->len + offset;
766 break;
768 default:
769 g_set_error_literal (error,
770 G_IO_ERROR,
771 G_IO_ERROR_INVALID_ARGUMENT,
772 _("Invalid GSeekType supplied"));
774 return FALSE;
777 if (absolute < 0)
779 g_set_error_literal (error,
780 G_IO_ERROR,
781 G_IO_ERROR_INVALID_ARGUMENT,
782 _("Requested seek before the beginning of the stream"));
783 return FALSE;
786 /* Can't seek past the end of a fixed-size stream.
788 * Note: seeking to the non-existent byte at the end of a fixed-sized
789 * stream is valid (eg: a 1-byte fixed sized stream can have position
790 * 0 or 1). Therefore '>' is what we want.
791 * */
792 if (priv->realloc_fn == NULL && absolute > priv->len)
794 g_set_error_literal (error,
795 G_IO_ERROR,
796 G_IO_ERROR_INVALID_ARGUMENT,
797 _("Requested seek beyond the end of the stream"));
798 return FALSE;
801 priv->pos = absolute;
803 return TRUE;
806 static gboolean
807 g_memory_output_stream_can_truncate (GSeekable *seekable)
809 GMemoryOutputStream *ostream;
810 GMemoryOutputStreamPrivate *priv;
812 ostream = G_MEMORY_OUTPUT_STREAM (seekable);
813 priv = ostream->priv;
815 /* We do not allow truncation of fixed-sized streams */
816 return priv->realloc_fn != NULL;
819 static gboolean
820 g_memory_output_stream_truncate (GSeekable *seekable,
821 goffset offset,
822 GCancellable *cancellable,
823 GError **error)
825 GMemoryOutputStream *ostream = G_MEMORY_OUTPUT_STREAM (seekable);
827 if (!array_resize (ostream, offset, FALSE, error))
828 return FALSE;
830 ostream->priv->valid_len = offset;
832 return TRUE;
835 static gboolean
836 g_memory_output_stream_is_writable (GPollableOutputStream *stream)
838 return TRUE;
841 static GSource *
842 g_memory_output_stream_create_source (GPollableOutputStream *stream,
843 GCancellable *cancellable)
845 GSource *base_source, *pollable_source;
847 base_source = g_timeout_source_new (0);
848 pollable_source = g_pollable_source_new_full (stream, base_source, cancellable);
849 g_source_unref (base_source);
851 return pollable_source;