← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rgtk2/trusty

« back to all changes in this revision

Viewing changes to src/gioManuals.c

  • Committer: Bazaar Package Importer
  • Author(s): Dirk Eddelbuettel
  • Date: 2010-11-03 11:35:46 UTC
  • mfrom: (1.3.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20101103113546-a7fi7jdxdebp0tw1
Tags: 2.20.1-1
* New upstream release

* debian/control: Set (Build-)Depends: to current R version
* debian/control: Set Standards-Version: to current version 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gioManuals.c
 
1
#include "RGtk2/gio.h"
 
2
#include "gioFuncs.h"
 
3
 
 
4
USER_OBJECT_
 
5
S_g_input_stream_read(USER_OBJECT_ s_object, USER_OBJECT_ s_count,
 
6
                      USER_OBJECT_ s_cancellable)
 
7
{
 
8
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9
#if GIO_CHECK_VERSION(2, 16, 0)
 
10
  GInputStream* object = G_INPUT_STREAM(getPtrValue(s_object));
 
11
  gsize count = ((gsize)asCNumeric(s_count));
 
12
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
13
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
14
                                                        
 
15
  gssize ans;
 
16
  guchar* buffer = R_alloc(count, sizeof(guchar));
 
17
  GError* error = NULL;
 
18
 
 
19
  ans = g_input_stream_read(object, buffer, count, cancellable, &error);
 
20
 
 
21
  _result = asRInteger(ans);
 
22
 
 
23
  _result = retByVal(_result, "buffer", asRRawArrayWithSize(buffer, count),
 
24
                     "error", asRGError(error), NULL);
 
25
  ;
 
26
  CLEANUP(g_error_free, error);;
 
27
#else
 
28
  error("g_input_stream_read exists only in gio >= 2.16.0");
 
29
#endif
 
30
 
 
31
  return(_result);
 
32
}
 
33
 
 
34
USER_OBJECT_
 
35
S_g_input_stream_read_all(USER_OBJECT_ s_object, USER_OBJECT_ s_count,
 
36
                          USER_OBJECT_ s_cancellable)
 
37
{
 
38
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
39
#if GIO_CHECK_VERSION(2, 16, 0)
 
40
  GInputStream* object = G_INPUT_STREAM(getPtrValue(s_object));
 
41
  gsize count = ((gsize)asCNumeric(s_count));
 
42
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
43
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
44
 
 
45
  gboolean ans;
 
46
  guchar* buffer = R_alloc(count, sizeof(guchar));
 
47
  gsize bytes_read;
 
48
  GError* error = NULL;
 
49
 
 
50
  ans = g_input_stream_read_all(object, buffer, count, &bytes_read,
 
51
                                cancellable, &error);
 
52
 
 
53
  _result = asRLogical(ans);
 
54
 
 
55
  _result = retByVal(_result, "buffer", asRRawArrayWithSize(buffer, count),
 
56
                     "bytes.read", asRNumeric(bytes_read),
 
57
                     "error", asRGError(error), NULL);
 
58
  ;
 
59
  ;
 
60
  CLEANUP(g_error_free, error);;
 
61
#else
 
62
  error("g_input_stream_read_all exists only in gio >= 2.16.0");
 
63
#endif
 
64
 
 
65
  return(_result);
 
66
}
 
67
 
 
68
/* Strategy: allocate the buffer, stick it with user data. Have the
 
69
   readFinish() call get the user data from the async result, return
 
70
   the buffer instead of only the length (and free the buffer).  */
 
71
 
 
72
USER_OBJECT_
 
73
S_g_input_stream_read_async(USER_OBJECT_ s_object,
 
74
                            USER_OBJECT_ s_count, USER_OBJECT_ s_io_priority,
 
75
                            USER_OBJECT_ s_cancellable, USER_OBJECT_ s_callback,
 
76
                            USER_OBJECT_ s_user_data)
 
77
{
 
78
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
79
#if GIO_CHECK_VERSION(2, 16, 0)
 
80
  GAsyncReadyCallback callback = ((GAsyncReadyCallback)S_GAsyncReadyCallback);
 
81
  R_CallbackData* user_data = R_createCBData(s_callback, s_user_data); 
 
82
  GInputStream* object = G_INPUT_STREAM(getPtrValue(s_object));
 
83
  gsize count = ((gsize)asCNumeric(s_count));
 
84
  guchar* buffer = g_new(guchar, count);
 
85
  int io_priority = ((int)asCInteger(s_io_priority));
 
86
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
87
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
88
  
 
89
  user_data->extra = buffer;
 
90
  
 
91
  g_input_stream_read_async(object, buffer, count, io_priority, cancellable,
 
92
                            callback, user_data);
 
93
  
 
94
#else
 
95
  error("g_input_stream_read_async exists only in gio >= 2.16.0");
 
96
#endif
 
97
 
 
98
  return(_result);
 
99
}
 
100
USER_OBJECT_
 
101
S_g_input_stream_read_finish(USER_OBJECT_ s_object, USER_OBJECT_ s_result)
 
102
{
 
103
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
104
#if GIO_CHECK_VERSION(2, 16, 0)
 
105
  GInputStream* object = G_INPUT_STREAM(getPtrValue(s_object));
 
106
  GAsyncResult* result = G_ASYNC_RESULT(getPtrValue(s_result));
 
107
  R_CallbackData* user_data =
 
108
    (R_CallbackData *)g_async_result_get_user_data(result);
 
109
  
 
110
  gssize ans;
 
111
  GError* error = NULL;
 
112
  guchar *buffer = (guchar *)user_data->extra;
 
113
 
 
114
  ans = g_input_stream_read_finish(object, result, &error);
 
115
 
 
116
  if (ans >= 0)
 
117
    _result = asRRawArrayWithSize(buffer, ans);
 
118
 
 
119
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
120
  CLEANUP(g_error_free, error);;
 
121
#else
 
122
  error("g_input_stream_read_finish exists only in gio >= 2.16.0");
 
123
#endif
 
124
 
 
125
  return(_result);
 
126
}
 
127
 
 
128
 
 
129
/* Same as that generated, we use sprintf on the R side */
 
130
USER_OBJECT_
 
131
S_g_simple_async_result_new_error(USER_OBJECT_ s_source_object,
 
132
                                  USER_OBJECT_ s_callback,
 
133
                                  USER_OBJECT_ s_user_data,
 
134
                                  USER_OBJECT_ s_domain, USER_OBJECT_ s_code,
 
135
                                  USER_OBJECT_ s_format)
 
136
{
 
137
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
138
#if GIO_CHECK_VERSION(2, 16, 0)
 
139
  GAsyncReadyCallback callback = ((GAsyncReadyCallback)S_GAsyncReadyCallback);
 
140
  R_CallbackData* user_data = R_createCBData(s_callback, s_user_data);
 
141
  GObject* source_object = G_OBJECT(getPtrValue(s_source_object));
 
142
  GQuark domain = ((GQuark)asCNumeric(s_domain));
 
143
  gint code = ((gint)asCInteger(s_code));
 
144
  const char* format = ((const char*)asCString(s_format));
 
145
 
 
146
  GSimpleAsyncResult* ans;
 
147
 
 
148
  ans = g_simple_async_result_new_error(source_object, callback, user_data,
 
149
                                        domain, code, "%s", format);
 
150
 
 
151
  _result = toRPointerWithRef(ans, "GSimpleAsyncResult");
 
152
#else
 
153
  error("g_simple_async_result_new_error exists only in gio >= 2.16.0");
 
154
#endif
 
155
 
 
156
  return(_result);
 
157
}
 
158
USER_OBJECT_
 
159
S_g_simple_async_result_set_error(USER_OBJECT_ s_object, USER_OBJECT_ s_domain,
 
160
                                  USER_OBJECT_ s_code, USER_OBJECT_ s_format)
 
161
{
 
162
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
163
#if GIO_CHECK_VERSION(2, 16, 0)
 
164
  GSimpleAsyncResult* object = G_SIMPLE_ASYNC_RESULT(getPtrValue(s_object));
 
165
  GQuark domain = ((GQuark)asCNumeric(s_domain));
 
166
  gint code = ((gint)asCInteger(s_code));
 
167
  const char* format = ((const char*)asCString(s_format));
 
168
 
 
169
 
 
170
  g_simple_async_result_set_error(object, domain, code, "%s", format);
 
171
 
 
172
#else
 
173
  error("g_simple_async_result_set_error exists only in gio >= 2.16.0");
 
174
#endif
 
175
 
 
176
  return(_result);
 
177
}
 
178
USER_OBJECT_
 
179
S_g_simple_async_report_error_in_idle(USER_OBJECT_ s_object,
 
180
                                      USER_OBJECT_ s_callback,
 
181
                                      USER_OBJECT_ s_user_data,
 
182
                                      USER_OBJECT_ s_domain,
 
183
                                      USER_OBJECT_ s_code,
 
184
                                      USER_OBJECT_ s_format)
 
185
{
 
186
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
187
#if GIO_CHECK_VERSION(2, 16, 0)
 
188
  GAsyncReadyCallback callback = ((GAsyncReadyCallback)S_GAsyncReadyCallback);
 
189
  R_CallbackData* user_data = R_createCBData(s_callback, s_user_data);
 
190
  GObject* object = G_OBJECT(getPtrValue(s_object));
 
191
  GQuark domain = ((GQuark)asCNumeric(s_domain));
 
192
  gint code = ((gint)asCInteger(s_code));
 
193
  const char* format = ((const char*)asCString(s_format));
 
194
 
 
195
 
 
196
  g_simple_async_report_error_in_idle(object, callback, user_data, domain, code,
 
197
                                      format);
 
198
 
 
199
#else
 
200
  error("g_simple_async_report_error_in_idle exists only in gio >= 2.16.0");
 
201
#endif
 
202
 
 
203
  return(_result);
 
204
}
 
205
 
 
206
/* Handle properties */
 
207
 
 
208
USER_OBJECT_
 
209
S_g_async_initable_new_async(USER_OBJECT_ s_object_type,
 
210
                             USER_OBJECT_ s_io_priority,
 
211
                             USER_OBJECT_ s_cancellable,
 
212
                             USER_OBJECT_ s_callback, USER_OBJECT_ s_user_data,
 
213
                             USER_OBJECT_ s_properties)
 
214
{
 
215
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
216
#if GIO_CHECK_VERSION(2, 22, 0)
 
217
  GAsyncReadyCallback callback = ((GAsyncReadyCallback)S_GAsyncReadyCallback);
 
218
  R_CallbackData* user_data = R_createCBData(s_callback, s_user_data);
 
219
  GType object_type = ((GType)asCNumeric(s_object_type));
 
220
  GObjectClass *object_class = G_OBJECT_CLASS(g_type_class_ref(object_type));
 
221
  int io_priority = ((int)asCInteger(s_io_priority));
 
222
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
223
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
224
 
 
225
  int i, n = GET_LENGTH(s_properties);
 
226
  GParameter *params = g_new0(GParameter, n);
 
227
  USER_OBJECT_ propNames = GET_NAMES(s_properties);
 
228
 
 
229
  for(i = 0; i < n; i++) {
 
230
    params[i].name = asCString(STRING_ELT(propNames, i));
 
231
    R_setGValueForProperty(&params[i].value, object_class, params[i].name,
 
232
                           VECTOR_ELT(s_properties, i));
 
233
  }
 
234
 
 
235
  g_async_initable_newv_async(object_type, n, params, io_priority, cancellable,
 
236
                              callback, user_data);
 
237
 
 
238
  g_free(params);
 
239
 
 
240
#else
 
241
  error("g_async_initable_new_async exists only in gio >= 2.22.0");
 
242
#endif
 
243
 
 
244
  return(_result);
 
245
}
 
246
USER_OBJECT_
 
247
S_g_initable_new(USER_OBJECT_ s_object_type, USER_OBJECT_ s_cancellable,
 
248
                 USER_OBJECT_ s_properties)
 
249
{
 
250
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
251
#if GIO_CHECK_VERSION(2, 22, 0)
 
252
  GType object_type = ((GType)asCNumeric(s_object_type));
 
253
  GObjectClass *object_class = G_OBJECT_CLASS(g_type_class_ref(object_type));
 
254
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
255
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
256
  
 
257
  gpointer ans;
 
258
  GError* error = NULL;
 
259
  
 
260
  int i, n = GET_LENGTH(s_properties);
 
261
  GParameter *params = g_new0(GParameter, n);
 
262
  USER_OBJECT_ propNames = GET_NAMES(s_properties);
 
263
 
 
264
  for(i = 0; i < n; i++) {
 
265
    params[i].name = asCString(STRING_ELT(propNames, i));
 
266
    R_setGValueForProperty(&params[i].value, object_class, params[i].name,
 
267
                           VECTOR_ELT(s_properties, i));
 
268
  }
 
269
 
 
270
  ans = g_initable_newv(object_type, n, params, cancellable, &error);
 
271
 
 
272
  _result = ans;
 
273
 
 
274
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
275
  CLEANUP(g_error_free, error);;
 
276
#else
 
277
  error("g_initable_new exists only in gio >= 2.22.0");
 
278
#endif
 
279
 
 
280
  return(_result);
 
281
}
 
282
 
 
283
/* Buffer preallocation */
 
284
 
 
285
USER_OBJECT_
 
286
S_g_socket_receive(USER_OBJECT_ s_object, USER_OBJECT_ s_size,
 
287
                   USER_OBJECT_ s_cancellable)
 
288
{
 
289
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
290
#if GIO_CHECK_VERSION(2, 22, 0)
 
291
  GSocket* object = G_SOCKET(getPtrValue(s_object));
 
292
  gsize size = ((gsize)asCNumeric(s_size));
 
293
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
294
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
295
 
 
296
  gssize ans;
 
297
  gchar* buffer = R_alloc(size, sizeof(guchar));
 
298
  GError* error = NULL;
 
299
 
 
300
  ans = g_socket_receive(object, buffer, size, cancellable, &error);
 
301
 
 
302
  _result = asRInteger(ans);
 
303
 
 
304
  _result = retByVal(_result, "buffer", asRRawArrayWithSize(buffer, size),
 
305
                     "error", asRGError(error), NULL);
 
306
  ;
 
307
  CLEANUP(g_error_free, error);;
 
308
#else
 
309
  error("g_socket_receive exists only in gio >= 2.22.0");
 
310
#endif
 
311
 
 
312
  return(_result);
 
313
}
 
314
 
 
315
USER_OBJECT_
 
316
S_g_socket_receive_from(USER_OBJECT_ s_object, USER_OBJECT_ s_size,
 
317
                        USER_OBJECT_ s_cancellable)
 
318
{
 
319
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
320
#if GIO_CHECK_VERSION(2, 22, 0)
 
321
  GSocket* object = G_SOCKET(getPtrValue(s_object));
 
322
  gsize size = ((gsize)asCNumeric(s_size));
 
323
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
324
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
325
 
 
326
  gssize ans;
 
327
  GSocketAddress* address = NULL;
 
328
  guchar *buffer = R_alloc(size, sizeof(guchar));
 
329
  GError* error = NULL;
 
330
 
 
331
  ans = g_socket_receive_from(object, &address, buffer, size, cancellable,
 
332
                              &error);
 
333
 
 
334
  _result = asRInteger(ans);
 
335
 
 
336
  _result = retByVal(_result,
 
337
                     "address", toRPointerWithFinalizer(address, "GSocketAddress", (RPointerFinalizer) g_object_unref),
 
338
                     "buffer", asRRawArrayWithSize(buffer, size),
 
339
                     "error", asRGError(error),
 
340
                     NULL);
 
341
  ;
 
342
  ;
 
343
  CLEANUP(g_error_free, error);;
 
344
#else
 
345
  error("g_socket_receive_from exists only in gio >= 2.22.0");
 
346
#endif
 
347
 
 
348
  return(_result);
 
349
}
 
350
 
 
351
/* These allow multiple i/o vectors, but is this optimization worth it
 
352
   in R? Probably not, so we just create a single vector. Their
 
353
   utility is in socket control messages, whatever those are. */
 
354
 
 
355
USER_OBJECT_
 
356
S_g_socket_receive_message(USER_OBJECT_ s_object, USER_OBJECT_ s_num_vectors,
 
357
                           USER_OBJECT_ s_flags, USER_OBJECT_ s_cancellable)
 
358
{
 
359
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
360
#if GIO_CHECK_VERSION(2, 22, 0)
 
361
  GSocket* object = G_SOCKET(getPtrValue(s_object));
 
362
  gint num_vectors = asCInteger(s_num_vectors);
 
363
  gint flags = asCInteger(s_flags);
 
364
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
365
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
366
 
 
367
  gssize ans;
 
368
  GSocketAddress* address = NULL;
 
369
  guchar *buffer = R_alloc(num_vectors, sizeof(guchar));
 
370
  GInputVector vectors[] = {
 
371
    { buffer, num_vectors }
 
372
  };
 
373
  GSocketControlMessage** messages = NULL;
 
374
  gint num_messages;
 
375
  GError* error = NULL;
 
376
 
 
377
  ans = g_socket_receive_message(object, &address, vectors, num_vectors,
 
378
                                 &messages, &num_messages, &flags, cancellable,
 
379
                                 &error);
 
380
 
 
381
  _result = asRInteger(ans);
 
382
 
 
383
  _result = retByVal(_result,
 
384
                     "address", toRPointerWithFinalizer(address, "GSocketAddress", (RPointerFinalizer) g_object_unref),
 
385
                     "vectors", toRPointer(vectors, "GInputVector"),
 
386
                     "messages", toRPointerWithFinalizerArrayWithSize(messages, "GSocketControlMessage", (RPointerFinalizer) g_object_unref, num_messages),
 
387
                     "num.messages", asRInteger(num_messages),
 
388
                     "flags", asRInteger(flags),
 
389
                     "error", asRGError(error), NULL);
 
390
  ;
 
391
  ;
 
392
  CLEANUP(g_free, messages);;
 
393
  ;
 
394
  CLEANUP(g_error_free, error);;
 
395
#else
 
396
  error("g_socket_receive_message exists only in gio >= 2.22.0");
 
397
#endif
 
398
 
 
399
  return(_result);
 
400
}
 
401
 
 
402
USER_OBJECT_
 
403
S_g_socket_send_message(USER_OBJECT_ s_object, USER_OBJECT_ s_address,
 
404
                        USER_OBJECT_ s_vectors, USER_OBJECT_ s_messages,
 
405
                        USER_OBJECT_ s_flags, USER_OBJECT_ s_cancellable)
 
406
{
 
407
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
408
#if GIO_CHECK_VERSION(2, 22, 0)
 
409
  GSocket* object = G_SOCKET(getPtrValue(s_object));
 
410
  GSocketAddress* address = G_SOCKET_ADDRESS(getPtrValue(s_address));
 
411
  GOutputVector vectors[] = {
 
412
    { RAW(s_vectors), GET_LENGTH(s_vectors) }
 
413
  };
 
414
  gint num_vectors = ((gint)GET_LENGTH(s_vectors));
 
415
  GSocketControlMessage** messages = s_messages == NULL_USER_OBJECT ? NULL : ((GSocketControlMessage**)asCArray(s_messages, GSocketControlMessage*, getPtrValue));
 
416
  gint num_messages = ((gint)GET_LENGTH(s_messages));
 
417
  gint flags = ((gint)asCInteger(s_flags));
 
418
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL :
 
419
    G_CANCELLABLE(getPtrValue(s_cancellable));
 
420
 
 
421
  gssize ans;
 
422
  GError* error = NULL;
 
423
 
 
424
  ans = g_socket_send_message(object, address, vectors, num_vectors, messages,
 
425
                              num_messages, flags, cancellable, &error);
 
426
 
 
427
  _result = asRInteger(ans);
 
428
 
 
429
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
430
  CLEANUP(g_error_free, error);;
 
431
#else
 
432
  error("g_socket_send_message exists only in gio >= 2.22.0");
 
433
#endif
 
434
 
 
435
  return(_result);
 
436
}
 
437
 
 
438
/* Special memory management of the buffer */
 
439
USER_OBJECT_
 
440
S_g_memory_output_stream_new(USER_OBJECT_ s_len)
 
441
{
 
442
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
443
#if GIO_CHECK_VERSION(2, 16, 0)
 
444
  gsize len = asCInteger(s_len);
 
445
  gpointer data = g_new(guchar, len);
 
446
 
 
447
  GOutputStream* ans;
 
448
 
 
449
  ans = g_memory_output_stream_new(data, len, g_realloc, g_free);
 
450
 
 
451
  _result = toRPointerWithFinalizer(ans, "GOutputStream", (RPointerFinalizer) g_object_unref);
 
452
#else
 
453
  error("g_memory_output_stream_new exists only in gio >= 2.16.0");
 
454
#endif
 
455
 
 
456
  return(_result);
 
457
}