gio/gmemoryinputstream.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: Christian Kellner <gicmo@gnome.org>
  21  */
  22
  23 #include <config.h>
  24 #include "gmemoryinputstream.h"
  25 #include "ginputstream.h"
  26 #include "gseekable.h"
  27 #include "string.h"
  28 #include "gsimpleasyncresult.h"
  29 #include "glibintl.h"
  30
  31 /**
  32  * SECTION:gmemoryinputstream
  33  * @short_description: streaming input operations on memory chunks
  34  * @see_also: #GMemoryOutputStream.
  35  *
  36  * #GMemoryInputStream is a class for using arbitrary
  37  * memory chunks as input for GIO streaming input operations.
  38  *
  39  */
  40
  41 struct _GMemoryInputStreamPrivate {
  42   guint8 *buffer;
  43   gsize   pos;
  44   gsize   len;
  45   gboolean free_data;
  46 };
  47
  48 static gssize   g_memory_input_stream_read         (GInputStream         *stream,
  49                                                     void                 *buffer,
  50                                                     gsize                 count,
  51                                                     GCancellable         *cancellable,
  52                                                     GError              **error);
  53 static gssize   g_memory_input_stream_skip         (GInputStream         *stream,
  54                                                     gsize                 count,
  55                                                     GCancellable         *cancellable,
  56                                                     GError              **error);
  57 static gboolean g_memory_input_stream_close        (GInputStream         *stream,
  58                                                     GCancellable         *cancellable,
  59                                                     GError              **error);
  60 static void     g_memory_input_stream_read_async   (GInputStream         *stream,
  61                                                     void                 *buffer,
  62                                                     gsize                 count,
  63                                                     int                   io_priority,
  64                                                     GCancellable         *cancellable,
  65                                                     GAsyncReadyCallback   callback,
  66                                                     gpointer              user_data);
  67 static gssize   g_memory_input_stream_read_finish  (GInputStream         *stream,
  68                                                     GAsyncResult         *result,
  69                                                     GError              **error);
  70 static void     g_memory_input_stream_skip_async   (GInputStream         *stream,
  71                                                     gsize                 count,
  72                                                     int                   io_priority,
  73                                                     GCancellable         *cancellabl,
  74                                                     GAsyncReadyCallback   callback,
  75                                                     gpointer              datae);
  76 static gssize   g_memory_input_stream_skip_finish  (GInputStream         *stream,
  77                                                     GAsyncResult         *result,
  78                                                     GError              **error);
  79 static void     g_memory_input_stream_close_async  (GInputStream         *stream,
  80                                                     int                   io_priority,
  81                                                     GCancellable         *cancellabl,
  82                                                     GAsyncReadyCallback   callback,
  83                                                     gpointer              data);
  84 static gboolean g_memory_input_stream_close_finish (GInputStream         *stream,
  85                                                     GAsyncResult         *result,
  86                                                     GError              **error);
  87
  88 static void     g_memory_input_stream_seekable_iface_init (GSeekableIface  *iface);
  89 static goffset  g_memory_input_stream_tell                (GSeekable       *seekable);
  90 static gboolean g_memory_input_stream_can_seek            (GSeekable       *seekable);
  91 static gboolean g_memory_input_stream_seek                (GSeekable       *seekable,
  92                                                            goffset          offset,
  93                                                            GSeekType        type,
  94                                                            GCancellable    *cancellable,
  95                                                            GError         **error);
  96 static gboolean g_memory_input_stream_can_truncate        (GSeekable       *seekable);
  97 static gboolean g_memory_input_stream_truncate            (GSeekable       *seekable,
  98                                                            goffset          offset,
  99                                                            GCancellable    *cancellable,
 100                                                            GError         **error);
 101 static void     g_memory_input_stream_finalize            (GObject         *object);
 102
 103 G_DEFINE_TYPE_WITH_CODE (GMemoryInputStream, g_memory_input_stream, G_TYPE_INPUT_STREAM,
 104                          G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
 105                                                 g_memory_input_stream_seekable_iface_init))
 106
 107
 108 static void
 109 g_memory_input_stream_class_init (GMemoryInputStreamClass *klass)
 110 {
 111   GObjectClass *object_class;
 112   GInputStreamClass *istream_class;
 113
 114   g_type_class_add_private (klass, sizeof (GMemoryInputStreamPrivate));
 115
 116   object_class = G_OBJECT_CLASS (klass);
 117   object_class->finalize     = g_memory_input_stream_finalize;
 118
 119   istream_class = G_INPUT_STREAM_CLASS (klass);
 120   istream_class->read  = g_memory_input_stream_read;
 121   istream_class->skip  = g_memory_input_stream_skip;
 122   istream_class->close = g_memory_input_stream_close;
 123
 124   istream_class->read_async  = g_memory_input_stream_read_async;
 125   istream_class->read_finish  = g_memory_input_stream_read_finish;
 126   istream_class->skip_async  = g_memory_input_stream_skip_async;
 127   istream_class->skip_finish  = g_memory_input_stream_skip_finish;
 128   istream_class->close_async = g_memory_input_stream_close_async;
 129   istream_class->close_finish = g_memory_input_stream_close_finish;
 130 }
 131
 132 static void
 133 g_memory_input_stream_finalize (GObject *object)
 134 {
 135   GMemoryInputStream        *stream;
 136
 137   stream = G_MEMORY_INPUT_STREAM (object);
 138
 139   if (stream->priv->free_data)
 140     g_free (stream->priv->buffer);
 141
 142   if (G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize)
 143     (*G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize) (object);
 144 }
 145
 146 static void
 147 g_memory_input_stream_seekable_iface_init (GSeekableIface *iface)
 148 {
 149   iface->tell         = g_memory_input_stream_tell;
 150   iface->can_seek     = g_memory_input_stream_can_seek;
 151   iface->seek         = g_memory_input_stream_seek;
 152   iface->can_truncate = g_memory_input_stream_can_truncate;
 153   iface->truncate     = g_memory_input_stream_truncate;
 154 }
 155
 156 static void
 157 g_memory_input_stream_init (GMemoryInputStream *stream)
 158 {
 159   stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
 160                                               G_TYPE_MEMORY_INPUT_STREAM,
 161                                               GMemoryInputStreamPrivate);
 162 }
 163
 164 /**
 165  * g_memory_input_stream_set_free_data:
 166  * @stream:
 167  * @free_data:
 168  *
 169  **/
 170 void
 171 g_memory_input_stream_set_free_data (GMemoryInputStream *stream,
 172                                      gboolean free_data)
 173 {
 174   g_return_if_fail (G_IS_MEMORY_INPUT_STREAM (stream));
 175
 176   stream->priv->free_data = free_data;
 177 }
 178
 179 /**
 180  * g_memory_input_stream_from_data:
 181  * @data: input data.
 182  * @len: length of the data.
 183  *
 184  * Returns: new #GInputStream read from @data of @len bytes.
 185  **/
 186 GInputStream *
 187 g_memory_input_stream_from_data (const void *data, gssize len)
 188 {
 189   GInputStream *stream;
 190   GMemoryInputStream *memory_stream;
 191
 192   g_return_val_if_fail (data != NULL, NULL);
 193
 194   stream = g_object_new (G_TYPE_MEMORY_INPUT_STREAM, NULL);
 195   memory_stream = G_MEMORY_INPUT_STREAM (stream);
 196
 197   if (len == -1)
 198     len = strlen (data);
 199
 200   memory_stream->priv->buffer = (guint8 *)data;
 201   memory_stream->priv->len = len;
 202
 203   return stream;
 204 }
 205
 206 static gssize
 207 g_memory_input_stream_read (GInputStream *stream,
 208                             void         *buffer,
 209                             gsize         count,
 210                             GCancellable *cancellable,
 211                             GError      **error)
 212 {
 213   GMemoryInputStream *memory_stream;
 214   GMemoryInputStreamPrivate * priv;
 215
 216   memory_stream = G_MEMORY_INPUT_STREAM (stream);
 217   priv = memory_stream->priv;
 218
 219   count = MIN (count, priv->len - priv->pos);
 220   memcpy (buffer, priv->buffer + priv->pos, count);
 221   priv->pos += count;
 222
 223   return count;
 224 }
 225
 226 /**
 227  * g_memory_input_stream_get_data:
 228  * @stream:
 229  *
 230  * Returns:
 231  **/
 232 const void *
 233 g_memory_input_stream_get_data (GMemoryInputStream *stream)
 234 {
 235   g_return_val_if_fail (G_IS_MEMORY_INPUT_STREAM (stream), NULL);
 236
 237   return stream->priv->buffer;
 238 }
 239
 240 /**
 241  * g_memory_input_stream_get_data_size:
 242  * @stream:
 243  *
 244  * Returns:
 245  **/
 246 gsize
 247 g_memory_input_stream_get_data_size (GMemoryInputStream *stream)
 248 {
 249   g_return_val_if_fail (G_IS_MEMORY_INPUT_STREAM (stream), -1);
 250
 251   return stream->priv->len;
 252 }
 253
 254 static gssize
 255 g_memory_input_stream_skip (GInputStream              *stream,
 256                             gsize                      count,
 257                             GCancellable              *cancellable,
 258                             GError                   **error)
 259 {
 260   GMemoryInputStream *memory_stream;
 261   GMemoryInputStreamPrivate *priv;
 262
 263   memory_stream = G_MEMORY_INPUT_STREAM (stream);
 264   priv = memory_stream->priv;
 265
 266   count = MIN (count, priv->len - priv->pos);
 267   priv->pos += count;
 268
 269   return count;
 270
 271
 272 }
 273
 274 static gboolean
 275 g_memory_input_stream_close (GInputStream *stream,
 276                              GCancellable *cancellable,
 277                              GError      **error)
 278 {
 279   return TRUE;
 280 }
 281
 282 static void
 283 g_memory_input_stream_read_async (GInputStream              *stream,
 284                                   void                      *buffer,
 285                                   gsize                      count,
 286                                   int                        io_priority,
 287                                   GCancellable              *cancellable,
 288                                   GAsyncReadyCallback        callback,
 289                                   gpointer                   user_data)
 290 {
 291   GSimpleAsyncResult *simple;
 292   gssize nread;
 293
 294   nread =  g_memory_input_stream_read (stream,  buffer, count, cancellable, NULL);
 295   simple = g_simple_async_result_new (G_OBJECT (stream),
 296                                       callback,
 297                                       user_data,
 298                                       g_memory_input_stream_read_async);
 299   g_simple_async_result_set_op_res_gssize (simple, nread);
 300   g_simple_async_result_complete_in_idle (simple);
 301   g_object_unref (simple);
 302 }
 303
 304 static gssize
 305 g_memory_input_stream_read_finish (GInputStream              *stream,
 306                                    GAsyncResult              *result,
 307                                    GError                   **error)
 308 {
 309   GSimpleAsyncResult *simple;
 310   gssize nread;
 311
 312   simple = G_SIMPLE_ASYNC_RESULT (result);
 313   g_assert (g_simple_async_result_get_source_tag (simple) == g_memory_input_stream_read_async);
 314
 315   nread = g_simple_async_result_get_op_res_gssize (simple);
 316   return nread;
 317 }
 318
 319 static void
 320 g_memory_input_stream_skip_async (GInputStream              *stream,
 321                                   gsize                      count,
 322                                   int                        io_priority,
 323                                   GCancellable              *cancellable,
 324                                   GAsyncReadyCallback        callback,
 325                                   gpointer                   user_data)
 326 {
 327   GSimpleAsyncResult *simple;
 328   gssize nskipped;
 329
 330   nskipped = g_memory_input_stream_skip (stream, count, cancellable, NULL);
 331   simple = g_simple_async_result_new (G_OBJECT (stream),
 332                                       callback,
 333                                       user_data,
 334                                       g_memory_input_stream_skip_async);
 335   g_simple_async_result_set_op_res_gssize (simple, nskipped);
 336   g_simple_async_result_complete_in_idle (simple);
 337   g_object_unref (simple);
 338 }
 339
 340 static gssize
 341 g_memory_input_stream_skip_finish (GInputStream              *stream,
 342                                    GAsyncResult              *result,
 343                                    GError                   **error)
 344 {
 345   GSimpleAsyncResult *simple;
 346   gssize nskipped;
 347
 348   simple = G_SIMPLE_ASYNC_RESULT (result);
 349   g_assert (g_simple_async_result_get_source_tag (simple) == g_memory_input_stream_skip_async);
 350
 351   nskipped = g_simple_async_result_get_op_res_gssize (simple);
 352   return nskipped;
 353 }
 354
 355 static void
 356 g_memory_input_stream_close_async (GInputStream              *stream,
 357                                    int                        io_priority,
 358                                    GCancellable              *cancellable,
 359                                    GAsyncReadyCallback        callback,
 360                                    gpointer                   user_data)
 361 {
 362   GSimpleAsyncResult *simple;
 363
 364   simple = g_simple_async_result_new (G_OBJECT (stream),
 365                                       callback,
 366                                       user_data,
 367                                       g_memory_input_stream_close_async);
 368   g_simple_async_result_complete_in_idle (simple);
 369   g_object_unref (simple);
 370 }
 371
 372 static gboolean
 373 g_memory_input_stream_close_finish (GInputStream              *stream,
 374                                     GAsyncResult              *result,
 375                                     GError                   **error)
 376 {
 377   return TRUE;
 378 }
 379
 380 static goffset
 381 g_memory_input_stream_tell (GSeekable *seekable)
 382 {
 383   GMemoryInputStream *memory_stream;
 384   GMemoryInputStreamPrivate * priv;
 385
 386   memory_stream = G_MEMORY_INPUT_STREAM (seekable);
 387   priv = memory_stream->priv;
 388
 389   return priv->pos;
 390 }
 391
 392 static
 393 gboolean g_memory_input_stream_can_seek (GSeekable *seekable)
 394 {
 395   return TRUE;
 396 }
 397
 398 static gboolean
 399 g_memory_input_stream_seek (GSeekable       *seekable,
 400                             goffset          offset,
 401                             GSeekType        type,
 402                             GCancellable    *cancellable,
 403                             GError         **error)
 404 {
 405   GMemoryInputStream *memory_stream;
 406   GMemoryInputStreamPrivate * priv;
 407   goffset absolute;
 408
 409   memory_stream = G_MEMORY_INPUT_STREAM (seekable);
 410   priv = memory_stream->priv;
 411
 412   switch (type) {
 413
 414     case G_SEEK_CUR:
 415       absolute = priv->pos + offset;
 416       break;
 417
 418     case G_SEEK_SET:
 419       absolute = offset;
 420       break;
 421
 422     case G_SEEK_END:
 423       absolute = priv->len + offset;
 424       break;
 425
 426     default:
 427       g_set_error (error,
 428                    G_IO_ERROR,
 429                    G_IO_ERROR_INVALID_ARGUMENT,
 430                    "Invalid GSeekType supplied");
 431
 432       return FALSE;
 433   }
 434
 435   if (absolute < 0 || absolute > priv->len)
 436     {
 437       g_set_error (error,
 438                    G_IO_ERROR,
 439                    G_IO_ERROR_INVALID_ARGUMENT,
 440                    "Invalid seek request");
 441       return FALSE;
 442     }
 443
 444   priv->pos = absolute;
 445
 446   return TRUE;
 447 }
 448
 449 static gboolean
 450 g_memory_input_stream_can_truncate (GSeekable *seekable)
 451 {
 452   return FALSE;
 453 }
 454
 455 static gboolean
 456 g_memory_input_stream_truncate (GSeekable      *seekable,
 457                                 goffset          offset,
 458                                 GCancellable    *cancellable,
 459                                 GError         **error)
 460 {
 461   g_set_error (error,
 462                G_IO_ERROR,
 463                G_IO_ERROR_NOT_SUPPORTED,
 464                "Cannot seek on GMemoryInputStream");
 465   return FALSE;
 466 }
 467
 468 /* vim: ts=2 sw=2 et */
 469