1 /* GIO - GLib Input, Output and Streaming Library
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 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.
21 * Christian Kellner <gicmo@gnome.org>
22 * Krzysztof KosiĆski <tweenk.pl@gmail.com>
26 #include "gmemoryoutputstream.h"
27 #include "goutputstream.h"
28 #include "gpollableoutputstream.h"
29 #include "gseekable.h"
30 #include "gsimpleasyncresult.h"
37 * SECTION:gmemoryoutputstream
38 * @short_description: Streaming output operations on memory chunks
40 * @see_also: #GMemoryInputStream
42 * #GMemoryOutputStream is a class for using arbitrary
43 * memory chunks as output for GIO streaming output operations.
45 * As of GLib 2.34, #GMemoryOutputStream implements
46 * #GPollableOutputStream.
49 #define MIN_ARRAY_SIZE 16
56 PROP_REALLOC_FUNCTION
,
60 struct _GMemoryOutputStreamPrivate
{
62 gpointer data
; /* Write buffer */
63 gsize len
; /* Current length of the data buffer. Can change with resizing. */
64 gsize valid_len
; /* The part of data that has been written to */
65 gsize pos
; /* Current position in the stream. Distinct from valid_len,
66 because the stream is seekable. */
68 GReallocFunc realloc_fn
;
69 GDestroyNotify destroy
;
72 static void g_memory_output_stream_set_property (GObject
*object
,
76 static void g_memory_output_stream_get_property (GObject
*object
,
80 static void g_memory_output_stream_finalize (GObject
*object
);
82 static gssize
g_memory_output_stream_write (GOutputStream
*stream
,
85 GCancellable
*cancellable
,
88 static gboolean
g_memory_output_stream_close (GOutputStream
*stream
,
89 GCancellable
*cancellable
,
92 static void g_memory_output_stream_close_async (GOutputStream
*stream
,
94 GCancellable
*cancellable
,
95 GAsyncReadyCallback callback
,
97 static gboolean
g_memory_output_stream_close_finish (GOutputStream
*stream
,
101 static void g_memory_output_stream_seekable_iface_init (GSeekableIface
*iface
);
102 static goffset
g_memory_output_stream_tell (GSeekable
*seekable
);
103 static gboolean
g_memory_output_stream_can_seek (GSeekable
*seekable
);
104 static gboolean
g_memory_output_stream_seek (GSeekable
*seekable
,
107 GCancellable
*cancellable
,
109 static gboolean
g_memory_output_stream_can_truncate (GSeekable
*seekable
);
110 static gboolean
g_memory_output_stream_truncate (GSeekable
*seekable
,
112 GCancellable
*cancellable
,
115 static gboolean
g_memory_output_stream_is_writable (GPollableOutputStream
*stream
);
116 static GSource
*g_memory_output_stream_create_source (GPollableOutputStream
*stream
,
117 GCancellable
*cancellable
);
119 static void g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface
*iface
);
121 G_DEFINE_TYPE_WITH_CODE (GMemoryOutputStream
, g_memory_output_stream
, G_TYPE_OUTPUT_STREAM
,
122 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE
,
123 g_memory_output_stream_seekable_iface_init
);
124 G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM
,
125 g_memory_output_stream_pollable_iface_init
))
129 g_memory_output_stream_class_init (GMemoryOutputStreamClass
*klass
)
131 GOutputStreamClass
*ostream_class
;
132 GObjectClass
*gobject_class
;
134 g_type_class_add_private (klass
, sizeof (GMemoryOutputStreamPrivate
));
136 gobject_class
= G_OBJECT_CLASS (klass
);
137 gobject_class
->set_property
= g_memory_output_stream_set_property
;
138 gobject_class
->get_property
= g_memory_output_stream_get_property
;
139 gobject_class
->finalize
= g_memory_output_stream_finalize
;
141 ostream_class
= G_OUTPUT_STREAM_CLASS (klass
);
143 ostream_class
->write_fn
= g_memory_output_stream_write
;
144 ostream_class
->close_fn
= g_memory_output_stream_close
;
145 ostream_class
->close_async
= g_memory_output_stream_close_async
;
146 ostream_class
->close_finish
= g_memory_output_stream_close_finish
;
149 * GMemoryOutputStream:data:
151 * Pointer to buffer where data will be written.
155 g_object_class_install_property (gobject_class
,
157 g_param_spec_pointer ("data",
159 P_("Pointer to buffer where data will be written."),
160 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT_ONLY
|
161 G_PARAM_STATIC_STRINGS
));
164 * GMemoryOutputStream:size:
166 * Current size of the data buffer.
170 g_object_class_install_property (gobject_class
,
172 g_param_spec_ulong ("size",
173 P_("Data Buffer Size"),
174 P_("Current size of the data buffer."),
176 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT_ONLY
|
177 G_PARAM_STATIC_STRINGS
));
180 * GMemoryOutputStream:data-size:
182 * Size of data written to the buffer.
186 g_object_class_install_property (gobject_class
,
188 g_param_spec_ulong ("data-size",
190 P_("Size of data written to the buffer."),
193 G_PARAM_STATIC_STRINGS
));
196 * GMemoryOutputStream:realloc-function: (skip)
198 * Function with realloc semantics called to enlarge the buffer.
202 g_object_class_install_property (gobject_class
,
203 PROP_REALLOC_FUNCTION
,
204 g_param_spec_pointer ("realloc-function",
205 P_("Memory Reallocation Function"),
206 P_("Function with realloc semantics called to enlarge the buffer."),
207 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT_ONLY
|
208 G_PARAM_STATIC_STRINGS
));
211 * GMemoryOutputStream:destroy-function: (skip)
213 * Function called with the buffer as argument when the stream is destroyed.
217 g_object_class_install_property (gobject_class
,
218 PROP_DESTROY_FUNCTION
,
219 g_param_spec_pointer ("destroy-function",
220 P_("Destroy Notification Function"),
221 P_("Function called with the buffer as argument when the stream is destroyed."),
222 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT_ONLY
|
223 G_PARAM_STATIC_STRINGS
));
227 g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface
*iface
)
229 iface
->is_writable
= g_memory_output_stream_is_writable
;
230 iface
->create_source
= g_memory_output_stream_create_source
;
234 g_memory_output_stream_set_property (GObject
*object
,
239 GMemoryOutputStream
*stream
;
240 GMemoryOutputStreamPrivate
*priv
;
242 stream
= G_MEMORY_OUTPUT_STREAM (object
);
248 priv
->data
= g_value_get_pointer (value
);
251 priv
->len
= g_value_get_ulong (value
);
253 case PROP_REALLOC_FUNCTION
:
254 priv
->realloc_fn
= g_value_get_pointer (value
);
256 case PROP_DESTROY_FUNCTION
:
257 priv
->destroy
= g_value_get_pointer (value
);
260 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
266 g_memory_output_stream_get_property (GObject
*object
,
271 GMemoryOutputStream
*stream
;
272 GMemoryOutputStreamPrivate
*priv
;
274 stream
= G_MEMORY_OUTPUT_STREAM (object
);
280 g_value_set_pointer (value
, priv
->data
);
283 g_value_set_ulong (value
, priv
->len
);
286 g_value_set_ulong (value
, priv
->valid_len
);
288 case PROP_REALLOC_FUNCTION
:
289 g_value_set_pointer (value
, priv
->realloc_fn
);
291 case PROP_DESTROY_FUNCTION
:
292 g_value_set_pointer (value
, priv
->destroy
);
295 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
301 g_memory_output_stream_finalize (GObject
*object
)
303 GMemoryOutputStream
*stream
;
304 GMemoryOutputStreamPrivate
*priv
;
306 stream
= G_MEMORY_OUTPUT_STREAM (object
);
310 priv
->destroy (priv
->data
);
312 G_OBJECT_CLASS (g_memory_output_stream_parent_class
)->finalize (object
);
316 g_memory_output_stream_seekable_iface_init (GSeekableIface
*iface
)
318 iface
->tell
= g_memory_output_stream_tell
;
319 iface
->can_seek
= g_memory_output_stream_can_seek
;
320 iface
->seek
= g_memory_output_stream_seek
;
321 iface
->can_truncate
= g_memory_output_stream_can_truncate
;
322 iface
->truncate_fn
= g_memory_output_stream_truncate
;
327 g_memory_output_stream_init (GMemoryOutputStream
*stream
)
329 stream
->priv
= G_TYPE_INSTANCE_GET_PRIVATE (stream
,
330 G_TYPE_MEMORY_OUTPUT_STREAM
,
331 GMemoryOutputStreamPrivate
);
332 stream
->priv
->pos
= 0;
333 stream
->priv
->valid_len
= 0;
337 * g_memory_output_stream_new: (skip)
338 * @data: (allow-none): pointer to a chunk of memory to use, or %NULL
339 * @size: the size of @data
340 * @realloc_function: (allow-none): a function with realloc() semantics (like g_realloc())
341 * to be called when @data needs to be grown, or %NULL
342 * @destroy_function: (allow-none): a function to be called on @data when the stream is
343 * finalized, or %NULL
345 * Creates a new #GMemoryOutputStream.
347 * If @data is non-%NULL, the stream will use that for its internal storage.
348 * If @realloc_fn is non-%NULL, it will be used for resizing the internal
349 * storage when necessary. To construct a fixed-size output stream,
350 * pass %NULL as @realloc_fn.
353 * /* a stream that can grow */
354 * stream = g_memory_output_stream_new (NULL, 0, realloc, free);
356 * /* another stream that can grow */
357 * stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
359 * /* a fixed-size stream */
360 * data = malloc (200);
361 * stream3 = g_memory_output_stream_new (data, 200, NULL, free);
364 * Return value: A newly created #GMemoryOutputStream object.
367 g_memory_output_stream_new (gpointer data
,
369 GReallocFunc realloc_function
,
370 GDestroyNotify destroy_function
)
372 GOutputStream
*stream
;
374 stream
= g_object_new (G_TYPE_MEMORY_OUTPUT_STREAM
,
377 "realloc-function", realloc_function
,
378 "destroy-function", destroy_function
,
385 * g_memory_output_stream_get_data:
386 * @ostream: a #GMemoryOutputStream
388 * Gets any loaded data from the @ostream.
390 * Note that the returned pointer may become invalid on the next
391 * write or truncate operation on the stream.
393 * Returns: (transfer none): pointer to the stream's data
396 g_memory_output_stream_get_data (GMemoryOutputStream
*ostream
)
398 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream
), NULL
);
400 return ostream
->priv
->data
;
404 * g_memory_output_stream_get_size:
405 * @ostream: a #GMemoryOutputStream
407 * Gets the size of the currently allocated data area (available from
408 * g_memory_output_stream_get_data()). If the stream isn't
409 * growable (no realloc was passed to g_memory_output_stream_new()) then
410 * this is the maximum size of the stream and further writes
411 * will return %G_IO_ERROR_NO_SPACE.
413 * Note that for growable streams the returned size may become invalid on
414 * the next write or truncate operation on the stream.
416 * If you want the number of bytes currently written to the stream, use
417 * g_memory_output_stream_get_data_size().
419 * Returns: the number of bytes allocated for the data buffer
422 g_memory_output_stream_get_size (GMemoryOutputStream
*ostream
)
424 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream
), 0);
426 return ostream
->priv
->len
;
430 * g_memory_output_stream_get_data_size:
431 * @ostream: a #GMemoryOutputStream
433 * Returns the number of bytes from the start up
434 * to including the last byte written in the stream
435 * that has not been truncated away.
437 * Returns: the number of bytes written to the stream
442 g_memory_output_stream_get_data_size (GMemoryOutputStream
*ostream
)
444 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream
), 0);
446 return ostream
->priv
->valid_len
;
450 * g_memory_output_stream_steal_data:
451 * @ostream: a #GMemoryOutputStream
453 * Gets any loaded data from the @ostream. Ownership of the data
454 * is transferred to the caller; when no longer needed it must be
455 * freed using the free function set in @ostream's
456 * #GMemoryOutputStream:destroy-function property.
458 * @ostream must be closed before calling this function.
460 * Returns: (transfer full): the stream's data
465 g_memory_output_stream_steal_data (GMemoryOutputStream
*ostream
)
469 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream
), NULL
);
470 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream
)), NULL
);
472 data
= ostream
->priv
->data
;
473 ostream
->priv
->data
= NULL
;
479 * g_memory_output_stream_steal_as_bytes:
480 * @ostream: a #GMemoryOutputStream
482 * Returns data from the @ostream as a #GBytes. @ostream must be
483 * closed before calling this function.
485 * Returns: (transfer full): the stream's data
490 g_memory_output_stream_steal_as_bytes (GMemoryOutputStream
*ostream
)
494 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream
), NULL
);
495 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream
)), NULL
);
497 result
= g_bytes_new_with_free_func (ostream
->priv
->data
,
498 ostream
->priv
->valid_len
,
499 ostream
->priv
->destroy
,
500 ostream
->priv
->data
);
501 ostream
->priv
->data
= NULL
;
507 array_resize (GMemoryOutputStream
*ostream
,
509 gboolean allow_partial
,
512 GMemoryOutputStreamPrivate
*priv
;
516 priv
= ostream
->priv
;
518 if (priv
->len
== size
)
521 if (!priv
->realloc_fn
)
524 priv
->pos
< priv
->len
)
525 return TRUE
; /* Short write */
527 g_set_error_literal (error
,
530 _("Memory output stream not resizable"));
535 data
= priv
->realloc_fn (priv
->data
, size
);
537 if (size
> 0 && !data
)
540 priv
->pos
< priv
->len
)
541 return TRUE
; /* Short write */
543 g_set_error_literal (error
,
546 _("Failed to resize memory output stream"));
551 memset ((guint8
*)data
+ len
, 0, size
- len
);
556 if (priv
->len
< priv
->valid_len
)
557 priv
->valid_len
= priv
->len
;
563 g_nearest_pow (gint num
)
574 g_memory_output_stream_write (GOutputStream
*stream
,
577 GCancellable
*cancellable
,
580 GMemoryOutputStream
*ostream
;
581 GMemoryOutputStreamPrivate
*priv
;
585 ostream
= G_MEMORY_OUTPUT_STREAM (stream
);
586 priv
= ostream
->priv
;
591 /* Check for address space overflow, but only if the buffer is resizable.
592 Otherwise we just do a short write and don't worry. */
593 if (priv
->realloc_fn
&& priv
->pos
+ count
< priv
->pos
)
596 if (priv
->pos
+ count
> priv
->len
)
598 /* At least enought to fit the write, rounded up
599 for greater than linear growth.
600 TODO: This wastes a lot of memory at large stream sizes.
601 Figure out a more rational allocation strategy. */
602 new_size
= g_nearest_pow (priv
->pos
+ count
);
603 /* Check for overflow again. We have only checked if
604 pos + count > G_MAXSIZE, but it only catches the case of writing
605 more than 4GiB total on a 32-bit system. There's still the problem
606 of g_nearest_pow overflowing above 0x7fffffff, so we're
607 effectively limited to 2GiB. */
608 if (new_size
< priv
->len
)
611 new_size
= MAX (new_size
, MIN_ARRAY_SIZE
);
612 if (!array_resize (ostream
, new_size
, TRUE
, error
))
616 /* Make sure we handle short writes if the array_resize
617 only added part of the required memory */
618 count
= MIN (count
, priv
->len
- priv
->pos
);
620 dest
= (guint8
*)priv
->data
+ priv
->pos
;
621 memcpy (dest
, buffer
, count
);
624 if (priv
->pos
> priv
->valid_len
)
625 priv
->valid_len
= priv
->pos
;
630 /* Overflow: buffer size would need to be bigger than G_MAXSIZE. */
631 g_set_error_literal (error
,
634 _("Amount of memory required to process the write is "
635 "larger than available address space"));
640 g_memory_output_stream_close (GOutputStream
*stream
,
641 GCancellable
*cancellable
,
648 g_memory_output_stream_close_async (GOutputStream
*stream
,
650 GCancellable
*cancellable
,
651 GAsyncReadyCallback callback
,
654 GSimpleAsyncResult
*simple
;
656 simple
= g_simple_async_result_new (G_OBJECT (stream
),
659 g_memory_output_stream_close_async
);
662 /* will always return TRUE */
663 g_memory_output_stream_close (stream
, cancellable
, NULL
);
665 g_simple_async_result_complete_in_idle (simple
);
666 g_object_unref (simple
);
670 g_memory_output_stream_close_finish (GOutputStream
*stream
,
671 GAsyncResult
*result
,
674 GSimpleAsyncResult
*simple
;
676 simple
= G_SIMPLE_ASYNC_RESULT (result
);
678 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) ==
679 g_memory_output_stream_close_async
);
685 g_memory_output_stream_tell (GSeekable
*seekable
)
687 GMemoryOutputStream
*stream
;
688 GMemoryOutputStreamPrivate
*priv
;
690 stream
= G_MEMORY_OUTPUT_STREAM (seekable
);
697 g_memory_output_stream_can_seek (GSeekable
*seekable
)
703 g_memory_output_stream_seek (GSeekable
*seekable
,
706 GCancellable
*cancellable
,
709 GMemoryOutputStream
*stream
;
710 GMemoryOutputStreamPrivate
*priv
;
713 stream
= G_MEMORY_OUTPUT_STREAM (seekable
);
719 absolute
= priv
->pos
+ offset
;
727 absolute
= priv
->len
+ offset
;
731 g_set_error_literal (error
,
733 G_IO_ERROR_INVALID_ARGUMENT
,
734 _("Invalid GSeekType supplied"));
741 g_set_error_literal (error
,
743 G_IO_ERROR_INVALID_ARGUMENT
,
744 _("Requested seek before the beginning of the stream"));
748 if (absolute
> priv
->len
)
750 g_set_error_literal (error
,
752 G_IO_ERROR_INVALID_ARGUMENT
,
753 _("Requested seek beyond the end of the stream"));
757 priv
->pos
= absolute
;
763 g_memory_output_stream_can_truncate (GSeekable
*seekable
)
765 GMemoryOutputStream
*ostream
;
766 GMemoryOutputStreamPrivate
*priv
;
768 ostream
= G_MEMORY_OUTPUT_STREAM (seekable
);
769 priv
= ostream
->priv
;
771 return priv
->realloc_fn
!= NULL
;
775 g_memory_output_stream_truncate (GSeekable
*seekable
,
777 GCancellable
*cancellable
,
780 GMemoryOutputStream
*ostream
= G_MEMORY_OUTPUT_STREAM (seekable
);
782 if (!array_resize (ostream
, offset
, FALSE
, error
))
789 g_memory_output_stream_is_writable (GPollableOutputStream
*stream
)
795 g_memory_output_stream_create_source (GPollableOutputStream
*stream
,
796 GCancellable
*cancellable
)
798 GSource
*base_source
, *pollable_source
;
800 base_source
= g_timeout_source_new (0);
801 pollable_source
= g_pollable_source_new_full (stream
, base_source
,
803 g_source_unref (base_source
);
805 return pollable_source
;