mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-24 14:36:13 +01:00
Trivial cleanups
This commit is contained in:
Matthias Clasen
parent
48881bad99
commit
1ba87d1a0e
@ -53,9 +53,7 @@
|
||||
* buffered input stream's buffer, use
|
||||
* g_buffered_input_stream_set_buffer_size(). Note that the buffer's size
|
||||
* cannot be reduced below the size of the data within the buffer.
|
||||
*
|
||||
**/
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#define DEFAULT_BUFFER_SIZE 4096
|
||||
@ -86,46 +84,46 @@ static void g_buffered_input_stream_finalize (GObject *object);
|
||||
|
||||
|
||||
static gssize g_buffered_input_stream_skip (GInputStream *stream,
|
||||
gsize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
gsize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
static void g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
static gssize g_buffered_input_stream_skip_finish (GInputStream *stream,
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
static gssize g_buffered_input_stream_read (GInputStream *stream,
|
||||
void *buffer,
|
||||
gsize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
void *buffer,
|
||||
gsize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
static void g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
void *buffer,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
void *buffer,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
static gssize g_buffered_input_stream_read_finish (GInputStream *stream,
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
static gssize g_buffered_input_stream_real_fill (GBufferedInputStream *stream,
|
||||
gssize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
gssize count,
|
||||
GCancellable *cancellable,
|
||||
GError **error);
|
||||
static void g_buffered_input_stream_real_fill_async (GBufferedInputStream *stream,
|
||||
gssize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
gssize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data);
|
||||
static gssize g_buffered_input_stream_real_fill_finish (GBufferedInputStream *stream,
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
GAsyncResult *result,
|
||||
GError **error);
|
||||
|
||||
static void compact_buffer (GBufferedInputStream *stream);
|
||||
|
||||
@ -177,12 +175,12 @@ g_buffered_input_stream_class_init (GBufferedInputStreamClass *klass)
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_get_buffer_size:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @stream: a #GBufferedInputStream
|
||||
*
|
||||
* Gets the size of the input buffer.
|
||||
*
|
||||
* Returns: the current buffer size.
|
||||
**/
|
||||
*/
|
||||
gsize
|
||||
g_buffered_input_stream_get_buffer_size (GBufferedInputStream *stream)
|
||||
{
|
||||
@ -193,16 +191,16 @@ g_buffered_input_stream_get_buffer_size (GBufferedInputStream *stream)
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_set_buffer_size:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @size: a #gsize.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @size: a #gsize
|
||||
*
|
||||
* Sets the size of the internal buffer of @stream to @size, or to the
|
||||
* size of the contents of the buffer. The buffer can never be resized
|
||||
* smaller than its current contents.
|
||||
**/
|
||||
*/
|
||||
void
|
||||
g_buffered_input_stream_set_buffer_size (GBufferedInputStream *stream,
|
||||
gsize size)
|
||||
g_buffered_input_stream_set_buffer_size (GBufferedInputStream *stream,
|
||||
gsize size)
|
||||
{
|
||||
GBufferedInputStreamPrivate *priv;
|
||||
gsize in_buffer;
|
||||
@ -261,7 +259,6 @@ g_buffered_input_stream_set_property (GObject *object,
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
@ -313,13 +310,13 @@ g_buffered_input_stream_init (GBufferedInputStream *stream)
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_new:
|
||||
* @base_stream: a #GInputStream.
|
||||
* @base_stream: a #GInputStream
|
||||
*
|
||||
* Creates a new #GInputStream from the given @base_stream, with
|
||||
* a buffer set to the default size (4 kilobytes).
|
||||
*
|
||||
* Returns: a #GInputStream for the given @base_stream.
|
||||
**/
|
||||
*/
|
||||
GInputStream *
|
||||
g_buffered_input_stream_new (GInputStream *base_stream)
|
||||
{
|
||||
@ -336,14 +333,14 @@ g_buffered_input_stream_new (GInputStream *base_stream)
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_new_sized:
|
||||
* @base_stream: a #GInputStream.
|
||||
* @size: a #gsize.
|
||||
* @base_stream: a #GInputStream
|
||||
* @size: a #gsize
|
||||
*
|
||||
* Creates a new #GBufferedInputStream from the given @base_stream,
|
||||
* with a buffer set to @size.
|
||||
*
|
||||
* Returns: a #GInputStream.
|
||||
**/
|
||||
*/
|
||||
GInputStream *
|
||||
g_buffered_input_stream_new_sized (GInputStream *base_stream,
|
||||
gsize size)
|
||||
@ -362,10 +359,10 @@ g_buffered_input_stream_new_sized (GInputStream *base_stream,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_fill:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @count: the number of bytes that will be read from the stream.
|
||||
* @cancellable: optional #GCancellable object, %NULL to ignore.
|
||||
* @error: location to store the error occuring, or %NULL to ignore.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @count: the number of bytes that will be read from the stream
|
||||
* @cancellable: optional #GCancellable object, %NULL to ignore
|
||||
* @error: location to store the error occuring, or %NULL to ignore
|
||||
*
|
||||
* Tries to read @count bytes from the stream into the buffer.
|
||||
* Will block during this read.
|
||||
@ -394,7 +391,7 @@ g_buffered_input_stream_new_sized (GInputStream *base_stream,
|
||||
*
|
||||
* Returns: the number of bytes read into @stream's buffer, up to @count,
|
||||
* or -1 on error.
|
||||
**/
|
||||
*/
|
||||
gssize
|
||||
g_buffered_input_stream_fill (GBufferedInputStream *stream,
|
||||
gssize count,
|
||||
@ -447,13 +444,13 @@ async_fill_callback_wrapper (GObject *source_object,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_fill_async:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @count: the number of bytes that will be read from the stream.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @count: the number of bytes that will be read from the stream
|
||||
* @io_priority: the <link linkend="io-priority">I/O priority</link>
|
||||
* of the request.
|
||||
* of the request
|
||||
* @cancellable: optional #GCancellable object
|
||||
* @callback: a #GAsyncReadyCallback.
|
||||
* @user_data: a #gpointer.
|
||||
* @callback: a #GAsyncReadyCallback
|
||||
* @user_data: a #gpointer
|
||||
*
|
||||
* Reads data into @stream's buffer asynchronously, up to @count size.
|
||||
* @io_priority can be used to prioritize reads. For the synchronous
|
||||
@ -461,7 +458,7 @@ async_fill_callback_wrapper (GObject *source_object,
|
||||
*
|
||||
* If @count is -1 then the attempted read size is equal to the number
|
||||
* of bytes that are required to fill the buffer.
|
||||
**/
|
||||
*/
|
||||
void
|
||||
g_buffered_input_stream_fill_async (GBufferedInputStream *stream,
|
||||
gssize count,
|
||||
@ -479,9 +476,9 @@ g_buffered_input_stream_fill_async (GBufferedInputStream *stream,
|
||||
if (count == 0)
|
||||
{
|
||||
simple = g_simple_async_result_new (G_OBJECT (stream),
|
||||
callback,
|
||||
user_data,
|
||||
g_buffered_input_stream_fill_async);
|
||||
callback,
|
||||
user_data,
|
||||
g_buffered_input_stream_fill_async);
|
||||
g_simple_async_result_complete_in_idle (simple);
|
||||
g_object_unref (simple);
|
||||
return;
|
||||
@ -490,20 +487,20 @@ g_buffered_input_stream_fill_async (GBufferedInputStream *stream,
|
||||
if (count < -1)
|
||||
{
|
||||
g_simple_async_report_error_in_idle (G_OBJECT (stream),
|
||||
callback,
|
||||
user_data,
|
||||
G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
|
||||
_("Too large count value passed to %s"),
|
||||
G_STRFUNC);
|
||||
callback,
|
||||
user_data,
|
||||
G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
|
||||
_("Too large count value passed to %s"),
|
||||
G_STRFUNC);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!g_input_stream_set_pending (G_INPUT_STREAM (stream), &error))
|
||||
{
|
||||
g_simple_async_report_gerror_in_idle (G_OBJECT (stream),
|
||||
callback,
|
||||
user_data,
|
||||
error);
|
||||
callback,
|
||||
user_data,
|
||||
error);
|
||||
g_error_free (error);
|
||||
return;
|
||||
}
|
||||
@ -518,14 +515,14 @@ g_buffered_input_stream_fill_async (GBufferedInputStream *stream,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_fill_finish:
|
||||
* @stream: a #GBufferedInputStream.
|
||||
* @result: a #GAsyncResult.
|
||||
* @error: a #GError.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @result: a #GAsyncResult
|
||||
* @error: a #GError
|
||||
*
|
||||
* Finishes an asynchronous read.
|
||||
*
|
||||
* Returns: a #gssize of the read stream, or %-1 on an error.
|
||||
**/
|
||||
*/
|
||||
gssize
|
||||
g_buffered_input_stream_fill_finish (GBufferedInputStream *stream,
|
||||
GAsyncResult *result,
|
||||
@ -554,12 +551,12 @@ g_buffered_input_stream_fill_finish (GBufferedInputStream *stream,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_get_available:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @stream: #GBufferedInputStream
|
||||
*
|
||||
* Gets the size of the available data within the stream.
|
||||
*
|
||||
* Returns: size of the available stream.
|
||||
**/
|
||||
*/
|
||||
gsize
|
||||
g_buffered_input_stream_get_available (GBufferedInputStream *stream)
|
||||
{
|
||||
@ -570,16 +567,16 @@ g_buffered_input_stream_get_available (GBufferedInputStream *stream)
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_peek:
|
||||
* @stream: a #GBufferedInputStream.
|
||||
* @buffer: a pointer to an allocated chunk of memory.
|
||||
* @offset: a #gsize.
|
||||
* @count: a #gsize.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @buffer: a pointer to an allocated chunk of memory
|
||||
* @offset: a #gsize
|
||||
* @count: a #gsize
|
||||
*
|
||||
* Peeks in the buffer, copying data of size @count into @buffer,
|
||||
* offset @offset bytes.
|
||||
*
|
||||
* Returns: a #gsize of the number of bytes peeked, or %-1 on error.
|
||||
**/
|
||||
* Returns: a #gsize of the number of bytes peeked, or -1 on error.
|
||||
*/
|
||||
gsize
|
||||
g_buffered_input_stream_peek (GBufferedInputStream *stream,
|
||||
void *buffer,
|
||||
@ -606,15 +603,15 @@ g_buffered_input_stream_peek (GBufferedInputStream *stream,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_peek_buffer:
|
||||
* @stream: a #GBufferedInputStream.
|
||||
* @count: a #gsize to get the number of bytes available in the buffer.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @count: a #gsize to get the number of bytes available in the buffer
|
||||
*
|
||||
* Returns the buffer with the currently available bytes. The returned
|
||||
* buffer must not be modified and will become invalid when reading from
|
||||
* the stream or filling the buffer.
|
||||
*
|
||||
* Returns: read-only buffer
|
||||
**/
|
||||
*/
|
||||
const void*
|
||||
g_buffered_input_stream_peek_buffer (GBufferedInputStream *stream,
|
||||
gsize *count)
|
||||
@ -787,7 +784,9 @@ g_buffered_input_stream_read (GInputStream *stream,
|
||||
return count;
|
||||
}
|
||||
|
||||
/* Full request not available, read all currently availbile and request refill for more */
|
||||
/* Full request not available, read all currently available and
|
||||
* request refill for more
|
||||
*/
|
||||
|
||||
memcpy (buffer, priv->buffer + priv->pos, available);
|
||||
priv->pos = 0;
|
||||
@ -805,10 +804,10 @@ g_buffered_input_stream_read (GInputStream *stream,
|
||||
base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
|
||||
|
||||
nread = g_input_stream_read (base_stream,
|
||||
(char *)buffer + bytes_read,
|
||||
count,
|
||||
cancellable,
|
||||
error);
|
||||
(char *)buffer + bytes_read,
|
||||
count,
|
||||
cancellable,
|
||||
error);
|
||||
|
||||
if (nread < 0 && bytes_read == 0)
|
||||
return -1;
|
||||
@ -841,9 +840,9 @@ g_buffered_input_stream_read (GInputStream *stream,
|
||||
|
||||
/**
|
||||
* g_buffered_input_stream_read_byte:
|
||||
* @stream: #GBufferedInputStream.
|
||||
* @cancellable: optional #GCancellable object, %NULL to ignore.
|
||||
* @error: location to store the error occuring, or %NULL to ignore.
|
||||
* @stream: a #GBufferedInputStream
|
||||
* @cancellable: optional #GCancellable object, %NULL to ignore
|
||||
* @error: location to store the error occuring, or %NULL to ignore
|
||||
*
|
||||
* Tries to read a single byte from the stream or the buffer. Will block
|
||||
* during this read.
|
||||
@ -860,7 +859,7 @@ g_buffered_input_stream_read (GInputStream *stream,
|
||||
* On error -1 is returned and @error is set accordingly.
|
||||
*
|
||||
* Returns: the byte read from the @stream, or -1 on end of stream or error.
|
||||
**/
|
||||
*/
|
||||
int
|
||||
g_buffered_input_stream_read_byte (GBufferedInputStream *stream,
|
||||
GCancellable *cancellable,
|
||||
@ -934,7 +933,7 @@ fill_async_callback (GObject *source_object,
|
||||
|
||||
error = NULL;
|
||||
res = g_input_stream_read_finish (G_INPUT_STREAM (source_object),
|
||||
result, &error);
|
||||
result, &error);
|
||||
|
||||
g_simple_async_result_set_op_res_gssize (simple, res);
|
||||
if (res == -1)
|
||||
@ -956,7 +955,9 @@ fill_async_callback (GObject *source_object,
|
||||
g_object_unref (object);
|
||||
}
|
||||
|
||||
/* Complete immediately, not in idle, since we're already in a mainloop callout */
|
||||
/* Complete immediately, not in idle, since we're already
|
||||
* in a mainloop callout
|
||||
*/
|
||||
g_simple_async_result_complete (simple);
|
||||
g_object_unref (simple);
|
||||
}
|
||||
@ -989,23 +990,23 @@ g_buffered_input_stream_real_fill_async (GBufferedInputStream *stream,
|
||||
compact_buffer (stream);
|
||||
|
||||
simple = g_simple_async_result_new (G_OBJECT (stream),
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_real_fill_async);
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_real_fill_async);
|
||||
|
||||
base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
|
||||
g_input_stream_read_async (base_stream,
|
||||
priv->buffer + priv->end,
|
||||
count,
|
||||
io_priority,
|
||||
cancellable,
|
||||
fill_async_callback,
|
||||
simple);
|
||||
priv->buffer + priv->end,
|
||||
count,
|
||||
io_priority,
|
||||
cancellable,
|
||||
fill_async_callback,
|
||||
simple);
|
||||
}
|
||||
|
||||
static gssize
|
||||
g_buffered_input_stream_real_fill_finish (GBufferedInputStream *stream,
|
||||
GAsyncResult *result,
|
||||
GError **error)
|
||||
GAsyncResult *result,
|
||||
GError **error)
|
||||
{
|
||||
GSimpleAsyncResult *simple;
|
||||
gssize nread;
|
||||
@ -1017,7 +1018,8 @@ g_buffered_input_stream_real_fill_finish (GBufferedInputStream *stream,
|
||||
return nread;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
gssize bytes_read;
|
||||
gssize count;
|
||||
void *buffer;
|
||||
@ -1032,8 +1034,8 @@ free_read_async_data (gpointer _data)
|
||||
|
||||
static void
|
||||
large_read_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
{
|
||||
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
|
||||
ReadAsyncData *data;
|
||||
@ -1044,7 +1046,7 @@ large_read_callback (GObject *source_object,
|
||||
|
||||
error = NULL;
|
||||
nread = g_input_stream_read_finish (G_INPUT_STREAM (source_object),
|
||||
result, &error);
|
||||
result, &error);
|
||||
|
||||
/* Only report the error if we've not already read some data */
|
||||
if (nread < 0 && data->bytes_read == 0)
|
||||
@ -1056,15 +1058,17 @@ large_read_callback (GObject *source_object,
|
||||
if (error)
|
||||
g_error_free (error);
|
||||
|
||||
/* Complete immediately, not in idle, since we're already in a mainloop callout */
|
||||
/* Complete immediately, not in idle, since we're already
|
||||
* in a mainloop callout
|
||||
*/
|
||||
g_simple_async_result_complete (simple);
|
||||
g_object_unref (simple);
|
||||
}
|
||||
|
||||
static void
|
||||
read_fill_buffer_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
read_fill_buffer_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
{
|
||||
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
|
||||
GBufferedInputStream *bstream;
|
||||
@ -1081,7 +1085,7 @@ read_fill_buffer_callback (GObject *source_object,
|
||||
|
||||
error = NULL;
|
||||
nread = g_buffered_input_stream_fill_finish (bstream,
|
||||
result, &error);
|
||||
result, &error);
|
||||
|
||||
if (nread < 0 && data->bytes_read == 0)
|
||||
g_simple_async_result_set_from_error (simple, error);
|
||||
@ -1100,19 +1104,21 @@ read_fill_buffer_callback (GObject *source_object,
|
||||
if (error)
|
||||
g_error_free (error);
|
||||
|
||||
/* Complete immediately, not in idle, since we're already in a mainloop callout */
|
||||
/* Complete immediately, not in idle, since we're already
|
||||
* in a mainloop callout
|
||||
*/
|
||||
g_simple_async_result_complete (simple);
|
||||
g_object_unref (simple);
|
||||
}
|
||||
|
||||
static void
|
||||
g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
void *buffer,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data)
|
||||
g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
void *buffer,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data)
|
||||
{
|
||||
GBufferedInputStream *bstream;
|
||||
GBufferedInputStreamPrivate *priv;
|
||||
@ -1129,8 +1135,8 @@ g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
data->buffer = buffer;
|
||||
data->bytes_read = 0;
|
||||
simple = g_simple_async_result_new (G_OBJECT (stream),
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_read_async);
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_read_async);
|
||||
g_simple_async_result_set_op_res_gpointer (simple, data, free_read_async_data);
|
||||
|
||||
available = priv->end - priv->pos;
|
||||
@ -1147,7 +1153,9 @@ g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
}
|
||||
|
||||
|
||||
/* Full request not available, read all currently availbile and request refill for more */
|
||||
/* Full request not available, read all currently available
|
||||
* and request refill for more
|
||||
*/
|
||||
|
||||
memcpy (buffer, priv->buffer + priv->pos, available);
|
||||
priv->pos = 0;
|
||||
@ -1165,17 +1173,17 @@ g_buffered_input_stream_read_async (GInputStream *stream,
|
||||
base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
|
||||
|
||||
g_input_stream_read_async (base_stream,
|
||||
(char *)buffer + data->bytes_read,
|
||||
count,
|
||||
io_priority, cancellable,
|
||||
large_read_callback,
|
||||
simple);
|
||||
(char *)buffer + data->bytes_read,
|
||||
count,
|
||||
io_priority, cancellable,
|
||||
large_read_callback,
|
||||
simple);
|
||||
}
|
||||
else
|
||||
{
|
||||
class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream);
|
||||
class->fill_async (bstream, priv->len, io_priority, cancellable,
|
||||
read_fill_buffer_callback, simple);
|
||||
read_fill_buffer_callback, simple);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1196,7 +1204,8 @@ g_buffered_input_stream_read_finish (GInputStream *stream,
|
||||
return data->bytes_read;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
gssize bytes_skipped;
|
||||
gssize count;
|
||||
} SkipAsyncData;
|
||||
@ -1209,9 +1218,9 @@ free_skip_async_data (gpointer _data)
|
||||
}
|
||||
|
||||
static void
|
||||
large_skip_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
large_skip_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
{
|
||||
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
|
||||
SkipAsyncData *data;
|
||||
@ -1222,7 +1231,7 @@ large_skip_callback (GObject *source_object,
|
||||
|
||||
error = NULL;
|
||||
nread = g_input_stream_skip_finish (G_INPUT_STREAM (source_object),
|
||||
result, &error);
|
||||
result, &error);
|
||||
|
||||
/* Only report the error if we've not already read some data */
|
||||
if (nread < 0 && data->bytes_skipped == 0)
|
||||
@ -1234,15 +1243,17 @@ large_skip_callback (GObject *source_object,
|
||||
if (error)
|
||||
g_error_free (error);
|
||||
|
||||
/* Complete immediately, not in idle, since we're already in a mainloop callout */
|
||||
/* Complete immediately, not in idle, since we're already
|
||||
* in a mainloop callout
|
||||
*/
|
||||
g_simple_async_result_complete (simple);
|
||||
g_object_unref (simple);
|
||||
}
|
||||
|
||||
static void
|
||||
skip_fill_buffer_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
skip_fill_buffer_callback (GObject *source_object,
|
||||
GAsyncResult *result,
|
||||
gpointer user_data)
|
||||
{
|
||||
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
|
||||
GBufferedInputStream *bstream;
|
||||
@ -1259,12 +1270,11 @@ skip_fill_buffer_callback (GObject *source_object,
|
||||
|
||||
error = NULL;
|
||||
nread = g_buffered_input_stream_fill_finish (bstream,
|
||||
result, &error);
|
||||
result, &error);
|
||||
|
||||
if (nread < 0 && data->bytes_skipped == 0)
|
||||
g_simple_async_result_set_from_error (simple, error);
|
||||
|
||||
|
||||
if (nread > 0)
|
||||
{
|
||||
available = priv->end - priv->pos;
|
||||
@ -1277,18 +1287,20 @@ skip_fill_buffer_callback (GObject *source_object,
|
||||
if (error)
|
||||
g_error_free (error);
|
||||
|
||||
/* Complete immediately, not in idle, since we're already in a mainloop callout */
|
||||
/* Complete immediately, not in idle, since we're already
|
||||
* in a mainloop callout
|
||||
*/
|
||||
g_simple_async_result_complete (simple);
|
||||
g_object_unref (simple);
|
||||
}
|
||||
|
||||
static void
|
||||
g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data)
|
||||
g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
gsize count,
|
||||
int io_priority,
|
||||
GCancellable *cancellable,
|
||||
GAsyncReadyCallback callback,
|
||||
gpointer user_data)
|
||||
{
|
||||
GBufferedInputStream *bstream;
|
||||
GBufferedInputStreamPrivate *priv;
|
||||
@ -1304,8 +1316,8 @@ g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
data = g_slice_new (SkipAsyncData);
|
||||
data->bytes_skipped = 0;
|
||||
simple = g_simple_async_result_new (G_OBJECT (stream),
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_skip_async);
|
||||
callback, user_data,
|
||||
g_buffered_input_stream_skip_async);
|
||||
g_simple_async_result_set_op_res_gpointer (simple, data, free_skip_async_data);
|
||||
|
||||
available = priv->end - priv->pos;
|
||||
@ -1320,8 +1332,9 @@ g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Full request not available, skip all currently availbile and request refill for more */
|
||||
/* Full request not available, skip all currently available
|
||||
* and request refill for more
|
||||
*/
|
||||
|
||||
priv->pos = 0;
|
||||
priv->end = 0;
|
||||
@ -1338,16 +1351,16 @@ g_buffered_input_stream_skip_async (GInputStream *stream,
|
||||
base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
|
||||
|
||||
g_input_stream_skip_async (base_stream,
|
||||
count,
|
||||
io_priority, cancellable,
|
||||
large_skip_callback,
|
||||
simple);
|
||||
count,
|
||||
io_priority, cancellable,
|
||||
large_skip_callback,
|
||||
simple);
|
||||
}
|
||||
else
|
||||
{
|
||||
class = G_BUFFERED_INPUT_STREAM_GET_CLASS (stream);
|
||||
class->fill_async (bstream, priv->len, io_priority, cancellable,
|
||||
skip_fill_buffer_callback, simple);
|
||||
skip_fill_buffer_callback, simple);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user