Lines Matching full:error
62 GError **error);
72 GError **error);
82 GError **error);
90 GError **error);
98 GError **error);
159 * @error: location to store the error occuring, or %NULL to ignore
165 * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
168 * It is not an error if this is not the same as the requested size, as it
169 * can happen e.g. on a partial i/o error, or if there is not enough
175 * was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If an
177 * partial result will be returned, without an error.
179 * On error -1 is returned and @error is set accordingly.
181 * Return value: Number of bytes written, or -1 on error
188 GError **error)
201 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
210 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
215 if (!g_output_stream_set_pending (stream, error))
221 res = class->write_fn (stream, buffer, count, cancellable, error);
239 * @error: location to store the error occuring, or %NULL to ignore
245 * write as many bytes as requested, only stopping on an error.
250 * If there is an error during the operation FALSE is returned and @error
251 * is set to indicate the error status, @bytes_written is updated to contain
252 * the number of bytes written into the stream before the error occurred.
254 * Return value: %TRUE on success, %FALSE if there was an error
262 GError **error)
274 cancellable, error);
283 g_warning ("Write returned zero without error");
298 * @error: location to store the error occuring, or %NULL to ignore
307 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
309 * Return value: %TRUE on success, %FALSE on error
314 GError **error)
321 if (!g_output_stream_set_pending (stream, error))
332 res = class->flush (stream, cancellable, error);
349 * @error: a #GError location to store the error occuring, or %NULL to
361 GError **error)
371 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
376 if (!g_output_stream_set_pending (stream, error))
385 res = class->splice (stream, source, flags, cancellable, error);
400 GError **error)
411 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
420 n_read = g_input_stream_read (source, buffer, sizeof (buffer), cancellable, error);
433 n_written = class->write_fn (stream, p, n_read, cancellable, error);
449 error = NULL; /* Ignore further errors */
460 if (!class->close_fn (stream, cancellable, error))
475 * @error: location to store the error occuring, or %NULL to ignore
480 * Closing a stream multiple times will not return an error.
493 * On failure the first error that happened will be reported, but the close
496 * is important to check and report the error to the user, otherwise
501 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
504 * cancellation (as with any error) there is no guarantee that all written
512 GError **error)
524 if (!g_output_stream_set_pending (stream, error))
531 res = class->flush (stream, cancellable, error);
537 /* flushing caused the error that we want to return,
547 res = class->close_fn (stream, cancellable, error);
605 * %G_IO_ERROR_INVALID_ARGUMENT error.
608 * @callback. It is not an error if this is not the same as the
609 * requested size, as it can happen e.g. on a partial I/O error,
634 GError *error = NULL;
661 if (!g_output_stream_set_pending (stream, &error))
666 error);
667 g_error_free (error);
683 * @error: a #GError location to store the error occuring, or %NULL to
693 GError **error)
704 if (g_simple_async_result_propagate_error (simple, error))
713 return class->write_finish (stream, result, error);
769 GError *error = NULL;
784 if (!g_output_stream_set_pending (stream, &error))
789 error);
790 g_error_free (error);
810 * @error: a #GError location to store the error occuring, or %NULL to
820 GError **error)
831 if (g_simple_async_result_propagate_error (simple, error))
836 return class->splice_finish (stream, result, error);
863 GError *error = NULL;
867 if (!g_output_stream_set_pending (stream, &error))
872 error);
873 g_error_free (error);
901 * @error: a #GError location to store the error occuring, or %NULL to
911 GError **error)
922 if (g_simple_async_result_propagate_error (simple, error))
931 return klass->flush_finish (stream, result, error);
963 GError *error = NULL;
978 if (!g_output_stream_set_pending (stream, &error))
983 error);
984 g_error_free (error);
999 * @error: a #GError location to store the error occuring, or %NULL to
1009 GError **error)
1020 if (g_simple_async_result_propagate_error (simple, error))
1029 return class->close_finish (stream, result, error);
1067 * @error: a #GError location to store the error occuring, or %NULL to
1072 * @error.
1078 GError **error)
1084 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
1091 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
1092 /* Translators: This is an error you get if there is
1135 GError *error = NULL;
1140 cancellable, &error);
1143 g_simple_async_result_set_from_error (res, error);
1144 g_error_free (error);
1173 GError **error)
1196 GError *error = NULL;
1207 &error);
1210 g_simple_async_result_set_from_error (result, error);
1211 g_error_free (error);
1243 GError **error)
1261 GError *error = NULL;
1266 result = class->flush (G_OUTPUT_STREAM (object), cancellable, &error);
1270 g_simple_async_result_set_from_error (res, error);
1271 g_error_free (error);
1293 GError **error)
1304 GError *error = NULL;
1313 result = class->close_fn (G_OUTPUT_STREAM (object), cancellable, &error);
1316 g_simple_async_result_set_from_error (res, error);
1317 g_error_free (error);
1341 GError **error)
