gio/gfilterinputstream.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 "gfilterinputstream.h"
  25 #include "ginputstream.h"
  26 #include "glibintl.h"
  27
  28 /**
  29  * SECTION:gfilterinputstream
  30  * @short_description: Filter Input Stream
  31  *
  32  **/
  33
  34 enum {
  35   PROP_0,
  36   PROP_BASE_STREAM
  37 };
  38
  39 static void     g_filter_input_stream_set_property (GObject      *object,
  40                                                     guint         prop_id,
  41                                                     const GValue *value,
  42                                                     GParamSpec   *pspec);
  43
  44 static void     g_filter_input_stream_get_property (GObject      *object,
  45                                                     guint         prop_id,
  46                                                     GValue       *value,
  47                                                     GParamSpec   *pspec);
  48 static void     g_filter_input_stream_finalize     (GObject *object);
  49
  50
  51 static gssize   g_filter_input_stream_read         (GInputStream         *stream,
  52                                                     void                 *buffer,
  53                                                     gsize                 count,
  54                                                     GCancellable         *cancellable,
  55                                                     GError              **error);
  56 static gssize   g_filter_input_stream_skip         (GInputStream         *stream,
  57                                                     gsize                 count,
  58                                                     GCancellable         *cancellable,
  59                                                     GError              **error);
  60 static gboolean g_filter_input_stream_close        (GInputStream         *stream,
  61                                                     GCancellable         *cancellable,
  62                                                     GError              **error);
  63 static void     g_filter_input_stream_read_async   (GInputStream         *stream,
  64                                                     void                 *buffer,
  65                                                     gsize                 count,
  66                                                     int                   io_priority,
  67                                                     GCancellable         *cancellable,
  68                                                     GAsyncReadyCallback   callback,
  69                                                     gpointer              user_data);
  70 static gssize   g_filter_input_stream_read_finish  (GInputStream         *stream,
  71                                                     GAsyncResult         *result,
  72                                                     GError              **error);
  73 static void     g_filter_input_stream_skip_async   (GInputStream         *stream,
  74                                                     gsize                 count,
  75                                                     int                   io_priority,
  76                                                     GCancellable         *cancellabl,
  77                                                     GAsyncReadyCallback   callback,
  78                                                     gpointer              datae);
  79 static gssize   g_filter_input_stream_skip_finish  (GInputStream         *stream,
  80                                                     GAsyncResult         *result,
  81                                                     GError              **error);
  82 static void     g_filter_input_stream_close_async  (GInputStream         *stream,
  83                                                     int                   io_priority,
  84                                                     GCancellable         *cancellabl,
  85                                                     GAsyncReadyCallback   callback,
  86                                                     gpointer              data);
  87 static gboolean g_filter_input_stream_close_finish (GInputStream         *stream,
  88                                                     GAsyncResult         *result,
  89                                                     GError              **error);
  90
  91 G_DEFINE_TYPE (GFilterInputStream, g_filter_input_stream, G_TYPE_INPUT_STREAM)
  92
  93
  94 static void
  95 g_filter_input_stream_class_init (GFilterInputStreamClass *klass)
  96 {
  97   GObjectClass *object_class;
  98   GInputStreamClass *istream_class;
  99
 100   object_class = G_OBJECT_CLASS (klass);
 101   object_class->get_property = g_filter_input_stream_get_property;
 102   object_class->set_property = g_filter_input_stream_set_property;
 103   object_class->finalize     = g_filter_input_stream_finalize;
 104
 105   istream_class = G_INPUT_STREAM_CLASS (klass);
 106   istream_class->read  = g_filter_input_stream_read;
 107   istream_class->skip  = g_filter_input_stream_skip;
 108   istream_class->close = g_filter_input_stream_close;
 109
 110   istream_class->read_async   = g_filter_input_stream_read_async;
 111   istream_class->read_finish  = g_filter_input_stream_read_finish;
 112   istream_class->skip_async   = g_filter_input_stream_skip_async;
 113   istream_class->skip_finish  = g_filter_input_stream_skip_finish;
 114   istream_class->close_async  = g_filter_input_stream_close_async;
 115   istream_class->close_finish = g_filter_input_stream_close_finish;
 116
 117   g_object_class_install_property (object_class,
 118                                    PROP_BASE_STREAM,
 119                                    g_param_spec_object ("base-stream",
 120                                                          P_("The Filter Base Stream"),
 121                                                          P_("The underlying base stream the io ops will be done on"),
 122                                                          G_TYPE_INPUT_STREAM,
 123                                                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 124                                                          G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 125
 126 }
 127
 128 static void
 129 g_filter_input_stream_set_property (GObject         *object,
 130                                     guint            prop_id,
 131                                     const GValue    *value,
 132                                     GParamSpec      *pspec)
 133 {
 134   GFilterInputStream *filter_stream;
 135   GObject *obj;
 136
 137   filter_stream = G_FILTER_INPUT_STREAM (object);
 138
 139   switch (prop_id)
 140     {
 141     case PROP_BASE_STREAM:
 142       obj = g_value_dup_object (value);
 143       filter_stream->base_stream = G_INPUT_STREAM (obj);
 144       break;
 145
 146     default:
 147       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 148       break;
 149     }
 150
 151 }
 152
 153 static void
 154 g_filter_input_stream_get_property (GObject    *object,
 155                                     guint       prop_id,
 156                                     GValue     *value,
 157                                     GParamSpec *pspec)
 158 {
 159   GFilterInputStream *filter_stream;
 160
 161   filter_stream = G_FILTER_INPUT_STREAM (object);
 162
 163   switch (prop_id)
 164     {
 165     case PROP_BASE_STREAM:
 166       g_value_set_object (value, filter_stream->base_stream);
 167       break;
 168
 169     default:
 170       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 171       break;
 172     }
 173
 174 }
 175
 176 static void
 177 g_filter_input_stream_finalize (GObject *object)
 178 {
 179   GFilterInputStream *stream;
 180
 181   stream = G_FILTER_INPUT_STREAM (object);
 182
 183   g_object_unref (stream->base_stream);
 184
 185   if (G_OBJECT_CLASS (g_filter_input_stream_parent_class)->finalize)
 186     (*G_OBJECT_CLASS (g_filter_input_stream_parent_class)->finalize) (object);
 187 }
 188
 189 static void
 190 g_filter_input_stream_init (GFilterInputStream *stream)
 191 {
 192
 193 }
 194
 195 /**
 196  * g_filter_input_stream_get_base_stream:
 197  * @stream: a #GFilterInputStream.
 198  *
 199  * Gets the base stream for the filter stream.
 200  *
 201  * Returns: a #GInputStream.
 202  **/
 203 GInputStream *
 204 g_filter_input_stream_get_base_stream (GFilterInputStream *stream)
 205 {
 206   g_return_val_if_fail (G_IS_FILTER_INPUT_STREAM (stream), NULL);
 207
 208   return stream->base_stream;
 209 }
 210
 211 static gssize
 212 g_filter_input_stream_read (GInputStream *stream,
 213                             void         *buffer,
 214                             gsize         count,
 215                             GCancellable *cancellable,
 216                             GError      **error)
 217 {
 218   GFilterInputStream *filter_stream;
 219   GInputStream       *base_stream;
 220   gssize              nread;
 221
 222   filter_stream = G_FILTER_INPUT_STREAM (stream);
 223   base_stream = filter_stream->base_stream;
 224
 225   nread = g_input_stream_read (base_stream,
 226                                buffer,
 227                                count,
 228                                cancellable,
 229                                error);
 230
 231   return nread;
 232 }
 233
 234 static gssize
 235 g_filter_input_stream_skip (GInputStream              *stream,
 236                             gsize                      count,
 237                             GCancellable              *cancellable,
 238                             GError                   **error)
 239 {
 240   GFilterInputStream *filter_stream;
 241   GInputStream       *base_stream;
 242   gssize              nskipped;
 243
 244   filter_stream = G_FILTER_INPUT_STREAM (stream);
 245   base_stream = filter_stream->base_stream;
 246
 247   nskipped = g_input_stream_skip (base_stream,
 248                                   count,
 249                                   cancellable,
 250                                   error);
 251   return nskipped;
 252 }
 253
 254 static gboolean
 255 g_filter_input_stream_close (GInputStream  *stream,
 256                              GCancellable  *cancellable,
 257                              GError       **error)
 258 {
 259   GFilterInputStream *filter_stream;
 260   GInputStream       *base_stream;
 261   gboolean            res;
 262
 263   filter_stream = G_FILTER_INPUT_STREAM (stream);
 264   base_stream = filter_stream->base_stream;
 265
 266   res = g_input_stream_close (base_stream,
 267                               cancellable,
 268                               error);
 269
 270   return res;
 271 }
 272
 273 static void
 274 g_filter_input_stream_read_async (GInputStream           *stream,
 275                                   void                   *buffer,
 276                                   gsize                   count,
 277                                   int                     io_priority,
 278                                   GCancellable           *cancellable,
 279                                   GAsyncReadyCallback     callback,
 280                                   gpointer                user_data)
 281 {
 282   GFilterInputStream *filter_stream;
 283   GInputStream       *base_stream;
 284
 285   filter_stream = G_FILTER_INPUT_STREAM (stream);
 286   base_stream = filter_stream->base_stream;
 287
 288   g_input_stream_read_async (base_stream,
 289                              buffer,
 290                              count,
 291                              io_priority,
 292                              cancellable,
 293                              callback,
 294                              user_data);
 295 }
 296
 297 static gssize
 298 g_filter_input_stream_read_finish (GInputStream  *stream,
 299                                    GAsyncResult  *result,
 300                                    GError       **error)
 301 {
 302   GFilterInputStream *filter_stream;
 303   GInputStream       *base_stream;
 304   gssize nread;
 305
 306   filter_stream = G_FILTER_INPUT_STREAM (stream);
 307   base_stream = filter_stream->base_stream;
 308
 309   nread = g_input_stream_read_finish (base_stream,
 310                                       result,
 311                                       error);
 312
 313   return nread;
 314 }
 315
 316 static void
 317 g_filter_input_stream_skip_async (GInputStream        *stream,
 318                                   gsize                count,
 319                                   int                  io_priority,
 320                                   GCancellable        *cancellable,
 321                                   GAsyncReadyCallback  callback,
 322                                   gpointer             user_data)
 323 {
 324   GFilterInputStream *filter_stream;
 325   GInputStream       *base_stream;
 326
 327   filter_stream = G_FILTER_INPUT_STREAM (stream);
 328   base_stream = filter_stream->base_stream;
 329
 330   g_input_stream_skip_async (base_stream,
 331                              count,
 332                              io_priority,
 333                              cancellable,
 334                              callback,
 335                              user_data);
 336
 337 }
 338
 339 static gssize
 340 g_filter_input_stream_skip_finish (GInputStream  *stream,
 341                                    GAsyncResult  *result,
 342                                    GError       **error)
 343 {
 344   GFilterInputStream *filter_stream;
 345   GInputStream       *base_stream;
 346   gssize nskipped;
 347
 348   filter_stream = G_FILTER_INPUT_STREAM (stream);
 349   base_stream = filter_stream->base_stream;
 350
 351   nskipped = g_input_stream_skip_finish (base_stream,
 352                                          result,
 353                                          error);
 354
 355   return nskipped;
 356 }
 357
 358 static void
 359 g_filter_input_stream_close_async (GInputStream         *stream,
 360                                    int                   io_priority,
 361                                    GCancellable         *cancellable,
 362                                    GAsyncReadyCallback   callback,
 363                                    gpointer              user_data)
 364 {
 365   GFilterInputStream *filter_stream;
 366   GInputStream       *base_stream;
 367
 368   filter_stream = G_FILTER_INPUT_STREAM (stream);
 369   base_stream = filter_stream->base_stream;
 370
 371   g_input_stream_close_async (base_stream,
 372                               io_priority,
 373                               cancellable,
 374                               callback,
 375                               user_data);
 376
 377
 378 }
 379
 380 static gboolean
 381 g_filter_input_stream_close_finish (GInputStream  *stream,
 382                                     GAsyncResult  *result,
 383                                     GError       **error)
 384 {
 385   GFilterInputStream *filter_stream;
 386   GInputStream       *base_stream;
 387   gboolean res;
 388
 389   filter_stream = G_FILTER_INPUT_STREAM (stream);
 390   base_stream = filter_stream->base_stream;
 391
 392   res = g_input_stream_close_finish (stream,
 393                                      result,
 394                                      error);
 395
 396   return res;
 397 }
 398
 399 /* vim: ts=2 sw=2 et */