void rbgio_gasyncinitable_new_async(GType type, VALUE parameters, VALUE io_priority, VALUE cancellable, VALUE block) { static ID s_id_length; struct rbgio_gasyncinitable_new_async_data data; if (s_id_length == 0) s_id_length = rb_intern("length"); if (!g_type_is_a(type, G_TYPE_OBJECT)) rb_raise(rb_eArgError, "%s is not a descendant of GObject", g_type_name(type)); if (NIL_P(parameters)) { SAVE_BLOCK(block); g_async_initable_newv_async(type, 0, NULL, RVAL2IOPRIORITYDEFAULT(io_priority), RVAL2GCANCELLABLE(cancellable), rbgio_async_ready_callback, (gpointer)block); return; } else { parameters = rb_convert_type(parameters, T_HASH, "Hash", "to_hash"); } data.gclass = G_OBJECT_CLASS(g_type_class_ref(type)); data.io_priority = RVAL2IOPRIORITYDEFAULT(io_priority); data.cancellable = RVAL2GCANCELLABLE(cancellable); data.block = block; data.rbparameters = parameters; data.index = 0; data.n_parameters = RVAL2GUINT(rb_funcall(parameters, s_id_length, 0)); data.parameters = ALLOCA_N(GParameter, data.n_parameters); rb_ensure(rbgio_gasyncinitable_new_async_body, (VALUE)&data, rbgio_gasyncinitable_new_async_ensure, (VALUE)&data); return; }
static VALUE rg_splice_async(int argc, VALUE *argv, VALUE self) { VALUE rbsource, rbflags, rbio_priority, rbcancellable, block; GInputStream *source; GOutputStreamSpliceFlags flags; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "12&", &rbsource, &rbflags, &rbio_priority, &rbcancellable, &block); source = RVAL2GINPUTSTREAM(rbsource); flags = RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(rbflags); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_output_stream_splice_async(_SELF(self), source, flags, io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }
/* TODO: Does it make sense to use buffer and count? We should probably * provide a better wrapper that simply pumps out buffer while count hasn't * been reached, calling the callback with the bytes written, then with the * result. */ static VALUE rg_write_async(int argc, VALUE *argv, VALUE self) { VALUE rbbuffer, rbcount, rbio_priority, rbcancellable, block; const gchar *buffer; gsize count; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "22&", &rbbuffer, &rbcount, &rbio_priority, &rbcancellable, &block); buffer = RVAL2CSTR(rbbuffer); count = RVAL2GSIZE(rbcount); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_output_stream_write_async(_SELF(self), buffer, count, io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }
static VALUE rg_close_async(int argc, VALUE *argv, VALUE self) { VALUE rbio_priority, rbcancellable, block; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "01&", &rbio_priority, &rbcancellable, &block); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_io_stream_close_async(_SELF(self), io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }
static VALUE rg_s_push_job(int argc, VALUE *argv, VALUE self) { VALUE rbio_priority, rbcancellable, block; gint io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "02", &rbio_priority, &rbcancellable); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); block = rb_block_proc(); SAVE_BLOCK(block); g_io_scheduler_push_job(ioscheduler_job_callback, (gpointer)block, ioscheduler_job_callback_free, io_priority, cancellable); return self; }
static VALUE fileenumerator_next_files_async(int argc, VALUE *argv, VALUE self) { VALUE rbnum_files, rbio_priority, rbcancellable, block; int num_files; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "12&", &rbnum_files, &rbio_priority, &rbcancellable, &block); num_files = NUM2INT(rbnum_files); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_file_enumerator_next_files_async(_SELF(self), num_files, io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }
static VALUE rg_fill_async(int argc, VALUE *argv, VALUE self) { VALUE rbcount, rbio_priority, rbcancellable, block; gssize count; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "03&", &rbcount, &rbio_priority, &rbcancellable, &block); count = NIL_P(rbcount) ? -1 : RVAL2GSSIZE(rbcount); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_buffered_input_stream_fill_async(_SELF(self), count, io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }
static VALUE rg_query_info_async(int argc, VALUE *argv, VALUE self) { VALUE rbattributes, rbio_priority, rbcancellable, block; const char *attributes; int io_priority; GCancellable *cancellable; rb_scan_args(argc, argv, "03&", &rbattributes, &rbio_priority, &rbcancellable, &block); attributes = RVAL2ATTRIBUTESDEFAULT(rbattributes); io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_file_input_stream_query_info_async(_SELF(self), attributes, io_priority, cancellable, rbgio_async_ready_callback, (gpointer)block); return self; }