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