gio/gdataoutputstream.c

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