• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
24 #error "Only <gio/gio.h> can be included directly."
25 #endif
26 
27 #ifndef __G_OUTPUT_STREAM_H__
28 #define __G_OUTPUT_STREAM_H__
29 
30 #include <gio/giotypes.h>
31 
32 G_BEGIN_DECLS
33 
34 #define G_TYPE_OUTPUT_STREAM         (g_output_stream_get_type ())
35 #define G_OUTPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_OUTPUT_STREAM, GOutputStream))
36 #define G_OUTPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_OUTPUT_STREAM, GOutputStreamClass))
37 #define G_IS_OUTPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_OUTPUT_STREAM))
38 #define G_IS_OUTPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_OUTPUT_STREAM))
39 #define G_OUTPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_OUTPUT_STREAM, GOutputStreamClass))
40 
41 /**
42  * GOutputStream:
43  *
44  * Base class for writing output.
45  *
46  * All classes derived from GOutputStream should implement synchronous
47  * writing, splicing, flushing and closing streams, but may implement
48  * asynchronous versions.
49  **/
50 typedef struct _GOutputStreamClass    GOutputStreamClass;
51 typedef struct _GOutputStreamPrivate  GOutputStreamPrivate;
52 
53 struct _GOutputStream
54 {
55   GObject parent_instance;
56 
57   /*< private >*/
58   GOutputStreamPrivate *priv;
59 };
60 
61 
62 struct _GOutputStreamClass
63 {
64   GObjectClass parent_class;
65 
66   /* Sync ops: */
67 
68   gssize      (* write_fn)      (GOutputStream            *stream,
69                                  const void               *buffer,
70                                  gsize                     count,
71                                  GCancellable             *cancellable,
72                                  GError                  **error);
73   gssize      (* splice)        (GOutputStream            *stream,
74                                  GInputStream             *source,
75                                  GOutputStreamSpliceFlags  flags,
76                                  GCancellable             *cancellable,
77                                  GError                  **error);
78   gboolean    (* flush)	        (GOutputStream            *stream,
79                                  GCancellable             *cancellable,
80                                  GError                  **error);
81   gboolean    (* close_fn)      (GOutputStream            *stream,
82                                  GCancellable             *cancellable,
83                                  GError                  **error);
84 
85   /* Async ops: (optional in derived classes) */
86 
87   void        (* write_async)   (GOutputStream            *stream,
88                                  const void               *buffer,
89                                  gsize                     count,
90                                  int                       io_priority,
91                                  GCancellable             *cancellable,
92                                  GAsyncReadyCallback       callback,
93                                  gpointer                  user_data);
94   gssize      (* write_finish)  (GOutputStream            *stream,
95                                  GAsyncResult             *result,
96                                  GError                  **error);
97   void        (* splice_async)  (GOutputStream            *stream,
98                                  GInputStream             *source,
99                                  GOutputStreamSpliceFlags  flags,
100                                  int                       io_priority,
101                                  GCancellable             *cancellable,
102                                  GAsyncReadyCallback       callback,
103                                  gpointer                  data);
104   gssize      (* splice_finish) (GOutputStream            *stream,
105                                  GAsyncResult             *result,
106                                  GError                  **error);
107   void        (* flush_async)   (GOutputStream            *stream,
108                                  int                       io_priority,
109                                  GCancellable             *cancellable,
110                                  GAsyncReadyCallback       callback,
111                                  gpointer                  user_data);
112   gboolean    (* flush_finish)  (GOutputStream            *stream,
113                                  GAsyncResult             *result,
114                                  GError                  **error);
115   void        (* close_async)   (GOutputStream            *stream,
116                                  int                       io_priority,
117                                  GCancellable             *cancellable,
118                                  GAsyncReadyCallback       callback,
119                                  gpointer                  user_data);
120   gboolean    (* close_finish)  (GOutputStream            *stream,
121                                  GAsyncResult             *result,
122                                  GError                  **error);
123 
124   /*< private >*/
125   /* Padding for future expansion */
126   void (*_g_reserved1) (void);
127   void (*_g_reserved2) (void);
128   void (*_g_reserved3) (void);
129   void (*_g_reserved4) (void);
130   void (*_g_reserved5) (void);
131   void (*_g_reserved6) (void);
132   void (*_g_reserved7) (void);
133   void (*_g_reserved8) (void);
134 };
135 
136 GType    g_output_stream_get_type      (void) G_GNUC_CONST;
137 
138 gssize   g_output_stream_write         (GOutputStream             *stream,
139 					const void                *buffer,
140 					gsize                      count,
141 					GCancellable              *cancellable,
142 					GError                   **error);
143 gboolean g_output_stream_write_all     (GOutputStream             *stream,
144 					const void                *buffer,
145 					gsize                      count,
146 					gsize                     *bytes_written,
147 					GCancellable              *cancellable,
148 					GError                   **error);
149 gssize   g_output_stream_splice        (GOutputStream             *stream,
150 					GInputStream              *source,
151 					GOutputStreamSpliceFlags   flags,
152 					GCancellable              *cancellable,
153 					GError                   **error);
154 gboolean g_output_stream_flush         (GOutputStream             *stream,
155 					GCancellable              *cancellable,
156 					GError                   **error);
157 gboolean g_output_stream_close         (GOutputStream             *stream,
158 					GCancellable              *cancellable,
159 					GError                   **error);
160 void     g_output_stream_write_async   (GOutputStream             *stream,
161 					const void                *buffer,
162 					gsize                      count,
163 					int                        io_priority,
164 					GCancellable              *cancellable,
165 					GAsyncReadyCallback        callback,
166 					gpointer                   user_data);
167 gssize   g_output_stream_write_finish  (GOutputStream             *stream,
168 					GAsyncResult              *result,
169 					GError                   **error);
170 void     g_output_stream_splice_async  (GOutputStream             *stream,
171 					GInputStream              *source,
172 					GOutputStreamSpliceFlags   flags,
173 					int                        io_priority,
174 					GCancellable              *cancellable,
175 					GAsyncReadyCallback        callback,
176 					gpointer                   user_data);
177 gssize   g_output_stream_splice_finish (GOutputStream             *stream,
178 					GAsyncResult              *result,
179 					GError                   **error);
180 void     g_output_stream_flush_async   (GOutputStream             *stream,
181 					int                        io_priority,
182 					GCancellable              *cancellable,
183 					GAsyncReadyCallback        callback,
184 					gpointer                   user_data);
185 gboolean g_output_stream_flush_finish  (GOutputStream             *stream,
186 					GAsyncResult              *result,
187 					GError                   **error);
188 void     g_output_stream_close_async   (GOutputStream             *stream,
189 					int                        io_priority,
190 					GCancellable              *cancellable,
191 					GAsyncReadyCallback        callback,
192 					gpointer                   user_data);
193 gboolean g_output_stream_close_finish  (GOutputStream             *stream,
194 					GAsyncResult              *result,
195 					GError                   **error);
196 
197 gboolean g_output_stream_is_closed     (GOutputStream             *stream);
198 gboolean g_output_stream_has_pending   (GOutputStream             *stream);
199 gboolean g_output_stream_set_pending   (GOutputStream             *stream,
200 					GError                   **error);
201 void     g_output_stream_clear_pending (GOutputStream             *stream);
202 
203 
204 G_END_DECLS
205 
206 #endif /* __G_OUTPUT_STREAM_H__ */
207