nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 *
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.
9 *
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.
14 *
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/>.
17 *
18 * Authors:
19 * Christian Kellner <gicmo@gnome.org>
20 * Krzysztof Kosiński <tweenk.pl@gmail.com>
21 */
22  
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"
32  
33  
34 /**
35 * SECTION:gmemoryoutputstream
36 * @short_description: Streaming output operations on memory chunks
37 * @include: gio/gio.h
38 * @see_also: #GMemoryInputStream
39 *
40 * #GMemoryOutputStream is a class for using arbitrary
41 * memory chunks as output for GIO streaming output operations.
42 *
43 * As of GLib 2.34, #GMemoryOutputStream trivially implements
44 * #GPollableOutputStream: it always polls as ready.
45 */
46  
47 #define MIN_ARRAY_SIZE 16
48  
49 enum {
50 PROP_0,
51 PROP_DATA,
52 PROP_SIZE,
53 PROP_DATA_SIZE,
54 PROP_REALLOC_FUNCTION,
55 PROP_DESTROY_FUNCTION
56 };
57  
58 struct _GMemoryOutputStreamPrivate
59 {
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. */
65  
66 GReallocFunc realloc_fn;
67 GDestroyNotify destroy;
68 };
69  
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);
79  
80 static gssize g_memory_output_stream_write (GOutputStream *stream,
81 const void *buffer,
82 gsize count,
83 GCancellable *cancellable,
84 GError **error);
85  
86 static gboolean g_memory_output_stream_close (GOutputStream *stream,
87 GCancellable *cancellable,
88 GError **error);
89  
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);
98  
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);
112  
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);
116  
117 static void g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface);
118  
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))
125  
126  
127 static void
128 g_memory_output_stream_class_init (GMemoryOutputStreamClass *klass)
129 {
130 GOutputStreamClass *ostream_class;
131 GObjectClass *gobject_class;
132  
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;
137  
138 ostream_class = G_OUTPUT_STREAM_CLASS (klass);
139  
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;
144  
145 /**
146 * GMemoryOutputStream:data:
147 *
148 * Pointer to buffer where data will be written.
149 *
150 * Since: 2.24
151 **/
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));
159  
160 /**
161 * GMemoryOutputStream:size:
162 *
163 * Current size of the data buffer.
164 *
165 * Since: 2.24
166 **/
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));
175  
176 /**
177 * GMemoryOutputStream:data-size:
178 *
179 * Size of data written to the buffer.
180 *
181 * Since: 2.24
182 **/
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));
191  
192 /**
193 * GMemoryOutputStream:realloc-function: (skip)
194 *
195 * Function with realloc semantics called to enlarge the buffer.
196 *
197 * Since: 2.24
198 **/
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));
206  
207 /**
208 * GMemoryOutputStream:destroy-function: (skip)
209 *
210 * Function called with the buffer as argument when the stream is destroyed.
211 *
212 * Since: 2.24
213 **/
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));
221 }
222  
223 static void
224 g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface)
225 {
226 iface->is_writable = g_memory_output_stream_is_writable;
227 iface->create_source = g_memory_output_stream_create_source;
228 }
229  
230 static void
231 g_memory_output_stream_set_property (GObject *object,
232 guint prop_id,
233 const GValue *value,
234 GParamSpec *pspec)
235 {
236 GMemoryOutputStream *stream;
237 GMemoryOutputStreamPrivate *priv;
238  
239 stream = G_MEMORY_OUTPUT_STREAM (object);
240 priv = stream->priv;
241  
242 switch (prop_id)
243 {
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;
259 }
260 }
261  
262 static void
263 g_memory_output_stream_get_property (GObject *object,
264 guint prop_id,
265 GValue *value,
266 GParamSpec *pspec)
267 {
268 GMemoryOutputStream *stream;
269 GMemoryOutputStreamPrivate *priv;
270  
271 stream = G_MEMORY_OUTPUT_STREAM (object);
272 priv = stream->priv;
273  
274 switch (prop_id)
275 {
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;
294 }
295 }
296  
297 static void
298 g_memory_output_stream_finalize (GObject *object)
299 {
300 GMemoryOutputStream *stream;
301 GMemoryOutputStreamPrivate *priv;
302  
303 stream = G_MEMORY_OUTPUT_STREAM (object);
304 priv = stream->priv;
305  
306 if (priv->destroy)
307 priv->destroy (priv->data);
308  
309 G_OBJECT_CLASS (g_memory_output_stream_parent_class)->finalize (object);
310 }
311  
312 static void
313 g_memory_output_stream_seekable_iface_init (GSeekableIface *iface)
314 {
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;
320 }
321  
322  
323 static void
324 g_memory_output_stream_init (GMemoryOutputStream *stream)
325 {
326 stream->priv = g_memory_output_stream_get_instance_private (stream);
327 stream->priv->pos = 0;
328 stream->priv->valid_len = 0;
329 }
330  
331 /**
332 * g_memory_output_stream_new: (skip)
333 * @data: (allow-none): pointer to a chunk of memory to use, or %NULL
334 * @size: the size of @data
335 * @realloc_function: (allow-none): a function with realloc() semantics (like g_realloc())
336 * to be called when @data needs to be grown, or %NULL
337 * @destroy_function: (allow-none): a function to be called on @data when the stream is
338 * finalized, or %NULL
339 *
340 * Creates a new #GMemoryOutputStream.
341 *
342 * In most cases this is not the function you want. See
343 * g_memory_output_stream_new_resizable() instead.
344 *
345 * If @data is non-%NULL, the stream will use that for its internal storage.
346 *
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.
354 *
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.
363 *
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).
369 *
370 * |[<!-- language="C" -->
371 * // a stream that can grow
372 * stream = g_memory_output_stream_new (NULL, 0, realloc, free);
373 *
374 * // another stream that can grow
375 * stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
376 *
377 * // a fixed-size stream
378 * data = malloc (200);
379 * stream3 = g_memory_output_stream_new (data, 200, NULL, free);
380 * ]|
381 *
382 * Returns: A newly created #GMemoryOutputStream object.
383 **/
384 GOutputStream *
385 g_memory_output_stream_new (gpointer data,
386 gsize size,
387 GReallocFunc realloc_function,
388 GDestroyNotify destroy_function)
389 {
390 GOutputStream *stream;
391  
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);
398  
399 return stream;
400 }
401  
402 /**
403 * g_memory_output_stream_new_resizable:
404 *
405 * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
406 * for memory allocation.
407 *
408 * Since: 2.36
409 */
410 GOutputStream *
411 g_memory_output_stream_new_resizable (void)
412 {
413 return g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
414 }
415  
416 /**
417 * g_memory_output_stream_get_data:
418 * @ostream: a #GMemoryOutputStream
419 *
420 * Gets any loaded data from the @ostream.
421 *
422 * Note that the returned pointer may become invalid on the next
423 * write or truncate operation on the stream.
424 *
425 * Returns: (transfer none): pointer to the stream's data, or %NULL if the data
426 * has been stolen
427 **/
428 gpointer
429 g_memory_output_stream_get_data (GMemoryOutputStream *ostream)
430 {
431 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
432  
433 return ostream->priv->data;
434 }
435  
436 /**
437 * g_memory_output_stream_get_size:
438 * @ostream: a #GMemoryOutputStream
439 *
440 * Gets the size of the currently allocated data area (available from
441 * g_memory_output_stream_get_data()).
442 *
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.
448 *
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.
452 *
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().
455 *
456 * Returns: the number of bytes allocated for the data buffer
457 */
458 gsize
459 g_memory_output_stream_get_size (GMemoryOutputStream *ostream)
460 {
461 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
462  
463 return ostream->priv->len;
464 }
465  
466 /**
467 * g_memory_output_stream_get_data_size:
468 * @ostream: a #GMemoryOutputStream
469 *
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.
472 *
473 * Returns: the number of bytes written to the stream
474 *
475 * Since: 2.18
476 */
477 gsize
478 g_memory_output_stream_get_data_size (GMemoryOutputStream *ostream)
479 {
480 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
481  
482 return ostream->priv->valid_len;
483 }
484  
485 /**
486 * g_memory_output_stream_steal_data:
487 * @ostream: a #GMemoryOutputStream
488 *
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.
493 *
494 * @ostream must be closed before calling this function.
495 *
496 * Returns: (transfer full): the stream's data, or %NULL if it has previously
497 * been stolen
498 *
499 * Since: 2.26
500 **/
501 gpointer
502 g_memory_output_stream_steal_data (GMemoryOutputStream *ostream)
503 {
504 gpointer data;
505  
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);
508  
509 data = ostream->priv->data;
510 ostream->priv->data = NULL;
511  
512 return data;
513 }
514  
515 /**
516 * g_memory_output_stream_steal_as_bytes:
517 * @ostream: a #GMemoryOutputStream
518 *
519 * Returns data from the @ostream as a #GBytes. @ostream must be
520 * closed before calling this function.
521 *
522 * Returns: (transfer full): the stream's data
523 *
524 * Since: 2.34
525 **/
526 GBytes *
527 g_memory_output_stream_steal_as_bytes (GMemoryOutputStream *ostream)
528 {
529 GBytes *result;
530  
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);
533  
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;
539  
540 return result;
541 }
542  
543 static gboolean
544 array_resize (GMemoryOutputStream *ostream,
545 gsize size,
546 gboolean allow_partial,
547 GError **error)
548 {
549 GMemoryOutputStreamPrivate *priv;
550 gpointer data;
551 gsize len;
552  
553 priv = ostream->priv;
554  
555 if (priv->len == size)
556 return TRUE;
557  
558 if (!priv->realloc_fn)
559 {
560 if (allow_partial &&
561 priv->pos < priv->len)
562 return TRUE; /* Short write */
563  
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;
569 }
570  
571 len = priv->len;
572 data = priv->realloc_fn (priv->data, size);
573  
574 if (size > 0 && !data)
575 {
576 if (allow_partial &&
577 priv->pos < priv->len)
578 return TRUE; /* Short write */
579  
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;
585 }
586  
587 if (size > len)
588 memset ((guint8 *)data + len, 0, size - len);
589  
590 priv->data = data;
591 priv->len = size;
592  
593 if (priv->len < priv->valid_len)
594 priv->valid_len = priv->len;
595  
596 return TRUE;
597 }
598  
599 static gsize
600 g_nearest_pow (gsize num)
601 {
602 gsize n = 1;
603  
604 while (n < num && n > 0)
605 n <<= 1;
606  
607 return n;
608 }
609  
610 static gssize
611 g_memory_output_stream_write (GOutputStream *stream,
612 const void *buffer,
613 gsize count,
614 GCancellable *cancellable,
615 GError **error)
616 {
617 GMemoryOutputStream *ostream;
618 GMemoryOutputStreamPrivate *priv;
619 guint8 *dest;
620 gsize new_size;
621  
622 ostream = G_MEMORY_OUTPUT_STREAM (stream);
623 priv = ostream->priv;
624  
625 if (count == 0)
626 return 0;
627  
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;
632  
633 if (priv->pos + count > priv->len)
634 {
635 /* At least enough to fit the write, rounded up for greater than
636 * linear growth.
637 *
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.
642 */
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;
649  
650 new_size = MAX (new_size, MIN_ARRAY_SIZE);
651 if (!array_resize (ostream, new_size, TRUE, error))
652 return -1;
653 }
654  
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);
658  
659 dest = (guint8 *)priv->data + priv->pos;
660 memcpy (dest, buffer, count);
661 priv->pos += count;
662  
663 if (priv->pos > priv->valid_len)
664 priv->valid_len = priv->pos;
665  
666 return count;
667  
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;
676 }
677  
678 static gboolean
679 g_memory_output_stream_close (GOutputStream *stream,
680 GCancellable *cancellable,
681 GError **error)
682 {
683 return TRUE;
684 }
685  
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)
692 {
693 GTask *task;
694  
695 task = g_task_new (stream, cancellable, callback, data);
696  
697 /* will always return TRUE */
698 g_memory_output_stream_close (stream, cancellable, NULL);
699  
700 g_task_return_boolean (task, TRUE);
701 g_object_unref (task);
702 }
703  
704 static gboolean
705 g_memory_output_stream_close_finish (GOutputStream *stream,
706 GAsyncResult *result,
707 GError **error)
708 {
709 g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
710  
711 return g_task_propagate_boolean (G_TASK (result), error);
712 }
713  
714 static goffset
715 g_memory_output_stream_tell (GSeekable *seekable)
716 {
717 GMemoryOutputStream *stream;
718 GMemoryOutputStreamPrivate *priv;
719  
720 stream = G_MEMORY_OUTPUT_STREAM (seekable);
721 priv = stream->priv;
722  
723 return priv->pos;
724 }
725  
726 static gboolean
727 g_memory_output_stream_can_seek (GSeekable *seekable)
728 {
729 return TRUE;
730 }
731  
732 static gboolean
733 g_memory_output_stream_seek (GSeekable *seekable,
734 goffset offset,
735 GSeekType type,
736 GCancellable *cancellable,
737 GError **error)
738 {
739 GMemoryOutputStream *stream;
740 GMemoryOutputStreamPrivate *priv;
741 goffset absolute;
742  
743 stream = G_MEMORY_OUTPUT_STREAM (seekable);
744 priv = stream->priv;
745  
746 switch (type)
747 {
748 case G_SEEK_CUR:
749 absolute = priv->pos + offset;
750 break;
751  
752 case G_SEEK_SET:
753 absolute = offset;
754 break;
755  
756 case G_SEEK_END:
757 /* For resizable streams, we consider the end to be the data
758 * length. For fixed-sized streams, we consider the end to be the
759 * size of the buffer.
760 */
761 if (priv->realloc_fn)
762 absolute = priv->valid_len + offset;
763 else
764 absolute = priv->len + offset;
765 break;
766  
767 default:
768 g_set_error_literal (error,
769 G_IO_ERROR,
770 G_IO_ERROR_INVALID_ARGUMENT,
771 _("Invalid GSeekType supplied"));
772  
773 return FALSE;
774 }
775  
776 if (absolute < 0)
777 {
778 g_set_error_literal (error,
779 G_IO_ERROR,
780 G_IO_ERROR_INVALID_ARGUMENT,
781 _("Requested seek before the beginning of the stream"));
782 return FALSE;
783 }
784  
785 /* Can't seek past the end of a fixed-size stream.
786 *
787 * Note: seeking to the non-existent byte at the end of a fixed-sized
788 * stream is valid (eg: a 1-byte fixed sized stream can have position
789 * 0 or 1). Therefore '>' is what we want.
790 * */
791 if (priv->realloc_fn == NULL && absolute > priv->len)
792 {
793 g_set_error_literal (error,
794 G_IO_ERROR,
795 G_IO_ERROR_INVALID_ARGUMENT,
796 _("Requested seek beyond the end of the stream"));
797 return FALSE;
798 }
799  
800 priv->pos = absolute;
801  
802 return TRUE;
803 }
804  
805 static gboolean
806 g_memory_output_stream_can_truncate (GSeekable *seekable)
807 {
808 GMemoryOutputStream *ostream;
809 GMemoryOutputStreamPrivate *priv;
810  
811 ostream = G_MEMORY_OUTPUT_STREAM (seekable);
812 priv = ostream->priv;
813  
814 /* We do not allow truncation of fixed-sized streams */
815 return priv->realloc_fn != NULL;
816 }
817  
818 static gboolean
819 g_memory_output_stream_truncate (GSeekable *seekable,
820 goffset offset,
821 GCancellable *cancellable,
822 GError **error)
823 {
824 GMemoryOutputStream *ostream = G_MEMORY_OUTPUT_STREAM (seekable);
825  
826 if (!array_resize (ostream, offset, FALSE, error))
827 return FALSE;
828  
829 ostream->priv->valid_len = offset;
830  
831 return TRUE;
832 }
833  
834 static gboolean
835 g_memory_output_stream_is_writable (GPollableOutputStream *stream)
836 {
837 return TRUE;
838 }
839  
840 static GSource *
841 g_memory_output_stream_create_source (GPollableOutputStream *stream,
842 GCancellable *cancellable)
843 {
844 GSource *base_source, *pollable_source;
845  
846 base_source = g_timeout_source_new (0);
847 pollable_source = g_pollable_source_new_full (stream, base_source, cancellable);
848 g_source_unref (base_source);
849  
850 return pollable_source;
851 }