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 * Author: Alexander Larsson <alexl@redhat.com>
19 */
20  
21 #include "config.h"
22 #include <string.h>
23 #include "gdataoutputstream.h"
24 #include "gseekable.h"
25 #include "gioenumtypes.h"
26 #include "gioerror.h"
27 #include "glibintl.h"
28  
29  
30 /**
31 * SECTION:gdataoutputstream
32 * @short_description: Data Output Stream
33 * @include: gio/gio.h
34 * @see_also: #GOutputStream
35 *
36 * Data output stream implements #GOutputStream and includes functions for
37 * writing data directly to an output stream.
38 *
39 **/
40  
41  
42  
43 struct _GDataOutputStreamPrivate {
44 GDataStreamByteOrder byte_order;
45 };
46  
47 enum {
48 PROP_0,
49 PROP_BYTE_ORDER
50 };
51  
52 static void g_data_output_stream_set_property (GObject *object,
53 guint prop_id,
54 const GValue *value,
55 GParamSpec *pspec);
56 static void g_data_output_stream_get_property (GObject *object,
57 guint prop_id,
58 GValue *value,
59 GParamSpec *pspec);
60  
61 static void g_data_output_stream_seekable_iface_init (GSeekableIface *iface);
62 static goffset g_data_output_stream_tell (GSeekable *seekable);
63 static gboolean g_data_output_stream_can_seek (GSeekable *seekable);
64 static gboolean g_data_output_stream_seek (GSeekable *seekable,
65 goffset offset,
66 GSeekType type,
67 GCancellable *cancellable,
68 GError **error);
69 static gboolean g_data_output_stream_can_truncate (GSeekable *seekable);
70 static gboolean g_data_output_stream_truncate (GSeekable *seekable,
71 goffset offset,
72 GCancellable *cancellable,
73 GError **error);
74  
75 G_DEFINE_TYPE_WITH_CODE (GDataOutputStream,
76 g_data_output_stream,
77 G_TYPE_FILTER_OUTPUT_STREAM,
78 G_ADD_PRIVATE (GDataOutputStream)
79 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
80 g_data_output_stream_seekable_iface_init))
81  
82  
83 static void
84 g_data_output_stream_class_init (GDataOutputStreamClass *klass)
85 {
86 GObjectClass *object_class;
87  
88 object_class = G_OBJECT_CLASS (klass);
89 object_class->get_property = g_data_output_stream_get_property;
90 object_class->set_property = g_data_output_stream_set_property;
91  
92 /**
93 * GDataOutputStream:byte-order:
94 *
95 * Determines the byte ordering that is used when writing
96 * multi-byte entities (such as integers) to the stream.
97 */
98 g_object_class_install_property (object_class,
99 PROP_BYTE_ORDER,
100 g_param_spec_enum ("byte-order",
101 P_("Byte order"),
102 P_("The byte order"),
103 G_TYPE_DATA_STREAM_BYTE_ORDER,
104 G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
105 G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_BLURB));
106  
107 }
108  
109 static void
110 g_data_output_stream_set_property (GObject *object,
111 guint prop_id,
112 const GValue *value,
113 GParamSpec *pspec)
114 {
115 GDataOutputStream *dstream;
116  
117 dstream = G_DATA_OUTPUT_STREAM (object);
118  
119 switch (prop_id)
120 {
121 case PROP_BYTE_ORDER:
122 g_data_output_stream_set_byte_order (dstream, g_value_get_enum (value));
123 break;
124  
125 default:
126 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
127 break;
128 }
129 }
130  
131 static void
132 g_data_output_stream_get_property (GObject *object,
133 guint prop_id,
134 GValue *value,
135 GParamSpec *pspec)
136 {
137 GDataOutputStreamPrivate *priv;
138 GDataOutputStream *dstream;
139  
140 dstream = G_DATA_OUTPUT_STREAM (object);
141 priv = dstream->priv;
142  
143 switch (prop_id)
144 {
145 case PROP_BYTE_ORDER:
146 g_value_set_enum (value, priv->byte_order);
147 break;
148  
149 default:
150 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
151 break;
152 }
153 }
154  
155 static void
156 g_data_output_stream_init (GDataOutputStream *stream)
157 {
158 stream->priv = g_data_output_stream_get_instance_private (stream);
159 stream->priv->byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
160 }
161  
162 static void
163 g_data_output_stream_seekable_iface_init (GSeekableIface *iface)
164 {
165 iface->tell = g_data_output_stream_tell;
166 iface->can_seek = g_data_output_stream_can_seek;
167 iface->seek = g_data_output_stream_seek;
168 iface->can_truncate = g_data_output_stream_can_truncate;
169 iface->truncate_fn = g_data_output_stream_truncate;
170 }
171  
172 /**
173 * g_data_output_stream_new:
174 * @base_stream: a #GOutputStream.
175 *
176 * Creates a new data output stream for @base_stream.
177 *
178 * Returns: #GDataOutputStream.
179 **/
180 GDataOutputStream *
181 g_data_output_stream_new (GOutputStream *base_stream)
182 {
183 GDataOutputStream *stream;
184  
185 g_return_val_if_fail (G_IS_OUTPUT_STREAM (base_stream), NULL);
186  
187 stream = g_object_new (G_TYPE_DATA_OUTPUT_STREAM,
188 "base-stream", base_stream,
189 NULL);
190  
191 return stream;
192 }
193  
194 /**
195 * g_data_output_stream_set_byte_order:
196 * @stream: a #GDataOutputStream.
197 * @order: a %GDataStreamByteOrder.
198 *
199 * Sets the byte order of the data output stream to @order.
200 **/
201 void
202 g_data_output_stream_set_byte_order (GDataOutputStream *stream,
203 GDataStreamByteOrder order)
204 {
205 GDataOutputStreamPrivate *priv;
206 g_return_if_fail (G_IS_DATA_OUTPUT_STREAM (stream));
207 priv = stream->priv;
208 if (priv->byte_order != order)
209 {
210 priv->byte_order = order;
211 g_object_notify (G_OBJECT (stream), "byte-order");
212 }
213 }
214  
215 /**
216 * g_data_output_stream_get_byte_order:
217 * @stream: a #GDataOutputStream.
218 *
219 * Gets the byte order for the stream.
220 *
221 * Returns: the #GDataStreamByteOrder for the @stream.
222 **/
223 GDataStreamByteOrder
224 g_data_output_stream_get_byte_order (GDataOutputStream *stream)
225 {
226 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
227  
228 return stream->priv->byte_order;
229 }
230  
231 /**
232 * g_data_output_stream_put_byte:
233 * @stream: a #GDataOutputStream.
234 * @data: a #guchar.
235 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
236 * @error: a #GError, %NULL to ignore.
237 *
238 * Puts a byte into the output stream.
239 *
240 * Returns: %TRUE if @data was successfully added to the @stream.
241 **/
242 gboolean
243 g_data_output_stream_put_byte (GDataOutputStream *stream,
244 guchar data,
245 GCancellable *cancellable,
246 GError **error)
247 {
248 gsize bytes_written;
249  
250 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
251  
252 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
253 &data, 1,
254 &bytes_written,
255 cancellable, error);
256 }
257  
258 /**
259 * g_data_output_stream_put_int16:
260 * @stream: a #GDataOutputStream.
261 * @data: a #gint16.
262 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
263 * @error: a #GError, %NULL to ignore.
264 *
265 * Puts a signed 16-bit integer into the output stream.
266 *
267 * Returns: %TRUE if @data was successfully added to the @stream.
268 **/
269 gboolean
270 g_data_output_stream_put_int16 (GDataOutputStream *stream,
271 gint16 data,
272 GCancellable *cancellable,
273 GError **error)
274 {
275 gsize bytes_written;
276  
277 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
278  
279 switch (stream->priv->byte_order)
280 {
281 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
282 data = GINT16_TO_BE (data);
283 break;
284 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
285 data = GINT16_TO_LE (data);
286 break;
287 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
288 default:
289 break;
290 }
291  
292 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
293 &data, 2,
294 &bytes_written,
295 cancellable, error);
296 }
297  
298 /**
299 * g_data_output_stream_put_uint16:
300 * @stream: a #GDataOutputStream.
301 * @data: a #guint16.
302 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
303 * @error: a #GError, %NULL to ignore.
304 *
305 * Puts an unsigned 16-bit integer into the output stream.
306 *
307 * Returns: %TRUE if @data was successfully added to the @stream.
308 **/
309 gboolean
310 g_data_output_stream_put_uint16 (GDataOutputStream *stream,
311 guint16 data,
312 GCancellable *cancellable,
313 GError **error)
314 {
315 gsize bytes_written;
316  
317 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
318  
319 switch (stream->priv->byte_order)
320 {
321 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
322 data = GUINT16_TO_BE (data);
323 break;
324 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
325 data = GUINT16_TO_LE (data);
326 break;
327 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
328 default:
329 break;
330 }
331  
332 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
333 &data, 2,
334 &bytes_written,
335 cancellable, error);
336 }
337  
338 /**
339 * g_data_output_stream_put_int32:
340 * @stream: a #GDataOutputStream.
341 * @data: a #gint32.
342 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
343 * @error: a #GError, %NULL to ignore.
344 *
345 * Puts a signed 32-bit integer into the output stream.
346 *
347 * Returns: %TRUE if @data was successfully added to the @stream.
348 **/
349 gboolean
350 g_data_output_stream_put_int32 (GDataOutputStream *stream,
351 gint32 data,
352 GCancellable *cancellable,
353 GError **error)
354 {
355 gsize bytes_written;
356  
357 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
358  
359 switch (stream->priv->byte_order)
360 {
361 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
362 data = GINT32_TO_BE (data);
363 break;
364 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
365 data = GINT32_TO_LE (data);
366 break;
367 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
368 default:
369 break;
370 }
371  
372 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
373 &data, 4,
374 &bytes_written,
375 cancellable, error);
376 }
377  
378 /**
379 * g_data_output_stream_put_uint32:
380 * @stream: a #GDataOutputStream.
381 * @data: a #guint32.
382 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
383 * @error: a #GError, %NULL to ignore.
384 *
385 * Puts an unsigned 32-bit integer into the stream.
386 *
387 * Returns: %TRUE if @data was successfully added to the @stream.
388 **/
389 gboolean
390 g_data_output_stream_put_uint32 (GDataOutputStream *stream,
391 guint32 data,
392 GCancellable *cancellable,
393 GError **error)
394 {
395 gsize bytes_written;
396  
397 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
398  
399 switch (stream->priv->byte_order)
400 {
401 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
402 data = GUINT32_TO_BE (data);
403 break;
404 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
405 data = GUINT32_TO_LE (data);
406 break;
407 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
408 default:
409 break;
410 }
411  
412 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
413 &data, 4,
414 &bytes_written,
415 cancellable, error);
416 }
417  
418 /**
419 * g_data_output_stream_put_int64:
420 * @stream: a #GDataOutputStream.
421 * @data: a #gint64.
422 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
423 * @error: a #GError, %NULL to ignore.
424 *
425 * Puts a signed 64-bit integer into the stream.
426 *
427 * Returns: %TRUE if @data was successfully added to the @stream.
428 **/
429 gboolean
430 g_data_output_stream_put_int64 (GDataOutputStream *stream,
431 gint64 data,
432 GCancellable *cancellable,
433 GError **error)
434 {
435 gsize bytes_written;
436  
437 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
438  
439 switch (stream->priv->byte_order)
440 {
441 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
442 data = GINT64_TO_BE (data);
443 break;
444 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
445 data = GINT64_TO_LE (data);
446 break;
447 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
448 default:
449 break;
450 }
451  
452 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
453 &data, 8,
454 &bytes_written,
455 cancellable, error);
456 }
457  
458 /**
459 * g_data_output_stream_put_uint64:
460 * @stream: a #GDataOutputStream.
461 * @data: a #guint64.
462 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
463 * @error: a #GError, %NULL to ignore.
464 *
465 * Puts an unsigned 64-bit integer into the stream.
466 *
467 * Returns: %TRUE if @data was successfully added to the @stream.
468 **/
469 gboolean
470 g_data_output_stream_put_uint64 (GDataOutputStream *stream,
471 guint64 data,
472 GCancellable *cancellable,
473 GError **error)
474 {
475 gsize bytes_written;
476  
477 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
478  
479 switch (stream->priv->byte_order)
480 {
481 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
482 data = GUINT64_TO_BE (data);
483 break;
484 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
485 data = GUINT64_TO_LE (data);
486 break;
487 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
488 default:
489 break;
490 }
491  
492 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
493 &data, 8,
494 &bytes_written,
495 cancellable, error);
496 }
497  
498 /**
499 * g_data_output_stream_put_string:
500 * @stream: a #GDataOutputStream.
501 * @str: a string.
502 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
503 * @error: a #GError, %NULL to ignore.
504 *
505 * Puts a string into the output stream.
506 *
507 * Returns: %TRUE if @string was successfully added to the @stream.
508 **/
509 gboolean
510 g_data_output_stream_put_string (GDataOutputStream *stream,
511 const char *str,
512 GCancellable *cancellable,
513 GError **error)
514 {
515 gsize bytes_written;
516  
517 g_return_val_if_fail (G_IS_DATA_OUTPUT_STREAM (stream), FALSE);
518 g_return_val_if_fail (str != NULL, FALSE);
519  
520 return g_output_stream_write_all (G_OUTPUT_STREAM (stream),
521 str, strlen (str),
522 &bytes_written,
523 cancellable, error);
524 }
525  
526 static goffset
527 g_data_output_stream_tell (GSeekable *seekable)
528 {
529 GOutputStream *base_stream;
530 GSeekable *base_stream_seekable;
531  
532 base_stream = G_FILTER_OUTPUT_STREAM (seekable)->base_stream;
533 if (!G_IS_SEEKABLE (base_stream))
534 return 0;
535 base_stream_seekable = G_SEEKABLE (base_stream);
536 return g_seekable_tell (base_stream_seekable);
537 }
538  
539 static gboolean
540 g_data_output_stream_can_seek (GSeekable *seekable)
541 {
542 GOutputStream *base_stream;
543  
544 base_stream = G_FILTER_OUTPUT_STREAM (seekable)->base_stream;
545 return G_IS_SEEKABLE (base_stream) && g_seekable_can_seek (G_SEEKABLE (base_stream));
546 }
547  
548 static gboolean
549 g_data_output_stream_seek (GSeekable *seekable,
550 goffset offset,
551 GSeekType type,
552 GCancellable *cancellable,
553 GError **error)
554 {
555 GOutputStream *base_stream;
556 GSeekable *base_stream_seekable;
557  
558 base_stream = G_FILTER_OUTPUT_STREAM (seekable)->base_stream;
559 if (!G_IS_SEEKABLE (base_stream))
560 {
561 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
562 _("Seek not supported on base stream"));
563 return FALSE;
564 }
565  
566 base_stream_seekable = G_SEEKABLE (base_stream);
567 return g_seekable_seek (base_stream_seekable, offset, type, cancellable, error);
568 }
569  
570 static gboolean
571 g_data_output_stream_can_truncate (GSeekable *seekable)
572 {
573 GOutputStream *base_stream;
574  
575 base_stream = G_FILTER_OUTPUT_STREAM (seekable)->base_stream;
576 return G_IS_SEEKABLE (base_stream) && g_seekable_can_truncate (G_SEEKABLE (base_stream));
577 }
578  
579 static gboolean
580 g_data_output_stream_truncate (GSeekable *seekable,
581 goffset offset,
582 GCancellable *cancellable,
583 GError **error)
584 {
585 GOutputStream *base_stream;
586 GSeekable *base_stream_seekable;
587  
588 base_stream = G_FILTER_OUTPUT_STREAM (seekable)->base_stream;
589 if (!G_IS_SEEKABLE (base_stream))
590 {
591 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
592 _("Truncate not supported on base stream"));
593 return FALSE;
594 }
595  
596 base_stream_seekable = G_SEEKABLE (base_stream);
597 return g_seekable_truncate (base_stream_seekable, offset, cancellable, error);
598 }