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