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 array_resize (GMemoryOutputStream
*ostream
,
481 gboolean allow_partial
,
484 GMemoryOutputStreamPrivate
*priv
;
488 priv
= ostream
->priv
;
490 if (priv
->len
== size
)
493 if (!priv
->realloc_fn
)
496 priv
->pos
< priv
->len
)
497 return TRUE
; /* Short write */
499 g_set_error_literal (error
,
502 _("Memory output stream not resizable"));
507 data
= priv
->realloc_fn (priv
->data
, size
);
509 if (size
> 0 && !data
)
512 priv
->pos
< priv
->len
)
513 return TRUE
; /* Short write */
515 g_set_error_literal (error
,
518 _("Failed to resize memory output stream"));
523 memset ((guint8
*)data
+ len
, 0, size
- len
);
528 if (priv
->len
< priv
->valid_len
)
529 priv
->valid_len
= priv
->len
;
535 g_nearest_pow (gint num
)
546 g_memory_output_stream_write (GOutputStream
*stream
,
549 GCancellable
*cancellable
,
552 GMemoryOutputStream
*ostream
;
553 GMemoryOutputStreamPrivate
*priv
;
557 ostream
= G_MEMORY_OUTPUT_STREAM (stream
);
558 priv
= ostream
->priv
;
563 /* Check for address space overflow, but only if the buffer is resizable.
564 Otherwise we just do a short write and don't worry. */
565 if (priv
->realloc_fn
&& priv
->pos
+ count
< priv
->pos
)
568 if (priv
->pos
+ count
> priv
->len
)
570 /* At least enought to fit the write, rounded up
571 for greater than linear growth.
572 TODO: This wastes a lot of memory at large stream sizes.
573 Figure out a more rational allocation strategy. */
574 new_size
= g_nearest_pow (priv
->pos
+ count
);
575 /* Check for overflow again. We have only checked if
576 pos + count > G_MAXSIZE, but it only catches the case of writing
577 more than 4GiB total on a 32-bit system. There's still the problem
578 of g_nearest_pow overflowing above 0x7fffffff, so we're
579 effectively limited to 2GiB. */
580 if (new_size
< priv
->len
)
583 new_size
= MAX (new_size
, MIN_ARRAY_SIZE
);
584 if (!array_resize (ostream
, new_size
, TRUE
, error
))
588 /* Make sure we handle short writes if the array_resize
589 only added part of the required memory */
590 count
= MIN (count
, priv
->len
- priv
->pos
);
592 dest
= (guint8
*)priv
->data
+ priv
->pos
;
593 memcpy (dest
, buffer
, count
);
596 if (priv
->pos
> priv
->valid_len
)
597 priv
->valid_len
= priv
->pos
;
602 /* Overflow: buffer size would need to be bigger than G_MAXSIZE. */
603 g_set_error_literal (error
,
606 _("Amount of memory required to process the write is "
607 "larger than available address space"));
612 g_memory_output_stream_close (GOutputStream
*stream
,
613 GCancellable
*cancellable
,
620 g_memory_output_stream_close_async (GOutputStream
*stream
,
622 GCancellable
*cancellable
,
623 GAsyncReadyCallback callback
,
626 GSimpleAsyncResult
*simple
;
628 simple
= g_simple_async_result_new (G_OBJECT (stream
),
631 g_memory_output_stream_close_async
);
634 /* will always return TRUE */
635 g_memory_output_stream_close (stream
, cancellable
, NULL
);
637 g_simple_async_result_complete_in_idle (simple
);
638 g_object_unref (simple
);
642 g_memory_output_stream_close_finish (GOutputStream
*stream
,
643 GAsyncResult
*result
,
646 GSimpleAsyncResult
*simple
;
648 simple
= G_SIMPLE_ASYNC_RESULT (result
);
650 g_warn_if_fail (g_simple_async_result_get_source_tag (simple
) ==
651 g_memory_output_stream_close_async
);
657 g_memory_output_stream_tell (GSeekable
*seekable
)
659 GMemoryOutputStream
*stream
;
660 GMemoryOutputStreamPrivate
*priv
;
662 stream
= G_MEMORY_OUTPUT_STREAM (seekable
);
669 g_memory_output_stream_can_seek (GSeekable
*seekable
)
675 g_memory_output_stream_seek (GSeekable
*seekable
,
678 GCancellable
*cancellable
,
681 GMemoryOutputStream
*stream
;
682 GMemoryOutputStreamPrivate
*priv
;
685 stream
= G_MEMORY_OUTPUT_STREAM (seekable
);
691 absolute
= priv
->pos
+ offset
;
699 absolute
= priv
->len
+ offset
;
703 g_set_error_literal (error
,
705 G_IO_ERROR_INVALID_ARGUMENT
,
706 _("Invalid GSeekType supplied"));
713 g_set_error_literal (error
,
715 G_IO_ERROR_INVALID_ARGUMENT
,
716 _("Requested seek before the beginning of the stream"));
720 if (absolute
> priv
->len
)
722 g_set_error_literal (error
,
724 G_IO_ERROR_INVALID_ARGUMENT
,
725 _("Requested seek beyond the end of the stream"));
729 priv
->pos
= absolute
;
735 g_memory_output_stream_can_truncate (GSeekable
*seekable
)
737 GMemoryOutputStream
*ostream
;
738 GMemoryOutputStreamPrivate
*priv
;
740 ostream
= G_MEMORY_OUTPUT_STREAM (seekable
);
741 priv
= ostream
->priv
;
743 return priv
->realloc_fn
!= NULL
;
747 g_memory_output_stream_truncate (GSeekable
*seekable
,
749 GCancellable
*cancellable
,
752 GMemoryOutputStream
*ostream
= G_MEMORY_OUTPUT_STREAM (seekable
);
754 if (!array_resize (ostream
, offset
, FALSE
, error
))
761 g_memory_output_stream_is_writable (GPollableOutputStream
*stream
)
767 g_memory_output_stream_create_source (GPollableOutputStream
*stream
,
768 GCancellable
*cancellable
)
770 GSource
*base_source
, *pollable_source
;
772 base_source
= g_timeout_source_new (0);
773 pollable_source
= g_pollable_source_new_full (stream
, base_source
,
775 g_source_unref (base_source
);
777 return pollable_source
;