1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2010 Red Hat, Inc.
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.
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.
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.
25 #include "gpollableinputstream.h"
26 #include "gasynchelper.h"
27 #include "gio-marshal.h"
31 * SECTION:gpollableinputstream
32 * @short_description: Interface for pollable input streams
34 * @see_also: #GInputStream, #GPollableOutputStream, #GFileDescriptorBased
36 * #GPollableInputStream is implemented by #GInputStream<!-- -->s that
37 * can be polled for readiness to read. This can be used when
38 * interfacing with a non-gio API that expects
39 * unix-file-descriptor-style asynchronous I/O rather than gio-style.
44 G_DEFINE_INTERFACE (GPollableInputStream, g_pollable_input_stream, G_TYPE_INPUT_STREAM)
46 static gboolean g_pollable_input_stream_default_can_poll (GPollableInputStream *stream);
47 static gssize g_pollable_input_stream_default_read_nonblocking (GPollableInputStream *stream,
53 g_pollable_input_stream_default_init (GPollableInputStreamInterface *iface)
55 iface->can_poll = g_pollable_input_stream_default_can_poll;
56 iface->read_nonblocking = g_pollable_input_stream_default_read_nonblocking;
60 g_pollable_input_stream_default_can_poll (GPollableInputStream *stream)
66 * g_pollable_input_stream_can_poll:
67 * @stream: a #GPollableInputStream.
69 * Checks if @stream is actually pollable. Some classes may implement
70 * #GPollableInputStream but have only certain instances of that class
71 * be pollable. If this method returns %FALSE, then the behavior of
72 * other #GPollableInputStream methods is undefined.
74 * For any given stream, the value returned by this method is constant;
75 * a stream cannot switch from pollable to non-pollable or vice versa.
77 * Returns: %TRUE if @stream is pollable, %FALSE if not.
82 g_pollable_input_stream_can_poll (GPollableInputStream *stream)
84 g_return_val_if_fail (G_IS_POLLABLE_INPUT_STREAM (stream), FALSE);
86 return G_POLLABLE_INPUT_STREAM_GET_INTERFACE (stream)->can_poll (stream);
90 * g_pollable_input_stream_is_readable:
91 * @stream: a #GPollableInputStream.
93 * Checks if @stream can be read.
95 * Note that some stream types may not be able to implement this 100%
96 * reliably, and it is possible that a call to g_input_stream_read()
97 * after this returns %TRUE would still block. To guarantee
98 * non-blocking behavior, you should always use
99 * g_pollable_input_stream_read_nonblocking(), which will return a
100 * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
102 * Returns: %TRUE if @stream is readable, %FALSE if not. If an error
103 * has occurred on @stream, this will result in
104 * g_pollable_input_stream_is_readable() returning %TRUE, and the
105 * next attempt to read will return the error.
110 g_pollable_input_stream_is_readable (GPollableInputStream *stream)
112 g_return_val_if_fail (G_IS_POLLABLE_INPUT_STREAM (stream), FALSE);
114 return G_POLLABLE_INPUT_STREAM_GET_INTERFACE (stream)->is_readable (stream);
118 * g_pollable_input_stream_create_source:
119 * @stream: a #GPollableInputStream.
120 * @cancellable: a #GCancellable, or %NULL
122 * Creates a #GSource that triggers when @stream can be read, or
123 * @cancellable is triggered or an error occurs. The callback on the
124 * source is of the #GPollableSourceFunc type.
126 * As with g_pollable_input_stream_is_readable(), it is possible that
127 * the stream may not actually be readable even after the source
128 * triggers, so you should use
129 * g_pollable_input_stream_read_nonblocking() rather than
130 * g_input_stream_read() from the callback.
132 * Returns: a new #GSource
137 g_pollable_input_stream_create_source (GPollableInputStream *stream,
138 GCancellable *cancellable)
140 g_return_val_if_fail (G_IS_POLLABLE_INPUT_STREAM (stream), NULL);
142 return G_POLLABLE_INPUT_STREAM_GET_INTERFACE (stream)->
143 create_source (stream, cancellable);
147 g_pollable_input_stream_default_read_nonblocking (GPollableInputStream *stream,
152 if (!g_pollable_input_stream_is_readable (stream))
154 g_set_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK,
155 g_strerror (EAGAIN));
159 return g_input_stream_read (G_INPUT_STREAM (stream), buffer, size,
164 * g_pollable_input_stream_read_nonblocking:
165 * @stream: a #GPollableInputStream
166 * @buffer: a buffer to read data into (which should be at least @size
168 * @size: the number of bytes you want to read
169 * @cancellable: a #GCancellable, or %NULL
170 * @error: #GError for error reporting, or %NULL to ignore.
172 * Attempts to read up to @size bytes from @stream into @buffer, as
173 * with g_input_stream_read(). If @stream is not currently readable,
174 * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
175 * use g_pollable_input_stream_create_source() to create a #GSource
176 * that will be triggered when @stream is readable.
178 * Note that since this method never blocks, you cannot actually
179 * use @cancellable to cancel it. However, it will return an error
180 * if @cancellable has already been cancelled when you call, which
181 * may happen if you call this method after a source triggers due
182 * to having been cancelled.
184 * Return value: the number of bytes read, or -1 on error (including
185 * %G_IO_ERROR_WOULD_BLOCK).
188 g_pollable_input_stream_read_nonblocking (GPollableInputStream *stream,
191 GCancellable *cancellable,
194 g_return_val_if_fail (G_IS_POLLABLE_INPUT_STREAM (stream), -1);
196 if (g_cancellable_set_error_if_cancelled (cancellable, error))
199 return G_POLLABLE_INPUT_STREAM_GET_INTERFACE (stream)->
200 read_nonblocking (stream, buffer, size, error);
203 /* GPollableSource */
212 pollable_source_prepare (GSource *source,
220 pollable_source_check (GSource *source)
226 pollable_source_dispatch (GSource *source,
227 GSourceFunc callback,
230 GPollableSourceFunc func = (GPollableSourceFunc)callback;
231 GPollableSource *pollable_source = (GPollableSource *)source;
233 return (*func) (pollable_source->stream, user_data);
237 pollable_source_finalize (GSource *source)
239 GPollableSource *pollable_source = (GPollableSource *)source;
241 g_object_unref (pollable_source->stream);
245 pollable_source_closure_callback (GObject *stream,
248 GClosure *closure = data;
250 GValue param = { 0, };
251 GValue result_value = { 0, };
254 g_value_init (&result_value, G_TYPE_BOOLEAN);
256 g_value_init (¶m, G_TYPE_OBJECT);
257 g_value_set_object (¶m, stream);
259 g_closure_invoke (closure, &result_value, 1, ¶m, NULL);
261 result = g_value_get_boolean (&result_value);
262 g_value_unset (&result_value);
263 g_value_unset (¶m);
268 static GSourceFuncs pollable_source_funcs =
270 pollable_source_prepare,
271 pollable_source_check,
272 pollable_source_dispatch,
273 pollable_source_finalize,
274 (GSourceFunc)pollable_source_closure_callback,
275 (GSourceDummyMarshal)_gio_marshal_BOOLEAN__VOID,
279 * g_pollable_source_new:
280 * @pollable_stream: the stream associated with the new source
282 * Utility method for #GPollableInputStream and #GPollableOutputStream
283 * implementations. Creates a new #GSource that expects a callback of
284 * type #GPollableSourceFunc. The new source does not actually do
285 * anything on its own; use g_source_add_child_source() to add other
286 * sources to it to cause it to trigger.
288 * Return value: the new #GSource.
293 g_pollable_source_new (GObject *pollable_stream)
296 GPollableSource *pollable_source;
298 source = g_source_new (&pollable_source_funcs, sizeof (GPollableSource));
299 g_source_set_name (source, "GPollableSource");
300 pollable_source = (GPollableSource *)source;
301 pollable_source->stream = g_object_ref (pollable_stream);