1 /* promise.c generated by valac 0.46.6, the Vala compiler
2 * generated from promise.vala, do not modify */
3
4 /* promise.vala
5 *
6 * Copyright (C) 2013 Maciej Piechotka
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Maciej Piechotka <uzytkownik2@gmail.com>
24 */
25
26 #include <glib-object.h>
27 #include <glib.h>
28 #include <gio/gio.h>
29 #include <string.h>
30 #include <async.h>
31 #include <gobject/gvaluecollector.h>
32
33 #define GEE_TYPE_PROMISE (gee_promise_get_type ())
34 #define GEE_PROMISE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_PROMISE, GeePromise))
35 #define GEE_PROMISE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_PROMISE, GeePromiseClass))
36 #define GEE_IS_PROMISE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_PROMISE))
37 #define GEE_IS_PROMISE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_PROMISE))
38 #define GEE_PROMISE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_PROMISE, GeePromiseClass))
39
40 typedef struct _GeePromise GeePromise;
41 typedef struct _GeePromiseClass GeePromiseClass;
42 typedef struct _GeePromisePrivate GeePromisePrivate;
43
44 #define GEE_PROMISE_TYPE_FUTURE (gee_promise_future_get_type ())
45 #define GEE_PROMISE_FUTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PROMISE_TYPE_FUTURE, GeePromiseFuture))
46 #define GEE_PROMISE_FUTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PROMISE_TYPE_FUTURE, GeePromiseFutureClass))
47 #define GEE_PROMISE_IS_FUTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PROMISE_TYPE_FUTURE))
48 #define GEE_PROMISE_IS_FUTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PROMISE_TYPE_FUTURE))
49 #define GEE_PROMISE_FUTURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PROMISE_TYPE_FUTURE, GeePromiseFutureClass))
50
51 typedef struct _GeePromiseFuture GeePromiseFuture;
52 typedef struct _GeePromiseFutureClass GeePromiseFutureClass;
53 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
54 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
55
56 #define GEE_TYPE_FUTURE (gee_future_get_type ())
57 #define GEE_FUTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_FUTURE, GeeFuture))
58 #define GEE_IS_FUTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_FUTURE))
59 #define GEE_FUTURE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_FUTURE, GeeFutureIface))
60
61 typedef struct _GeeFuture GeeFuture;
62 typedef struct _GeeFutureIface GeeFutureIface;
63 typedef gpointer (*GeeFutureMapFunc) (gconstpointer value, gpointer user_data);
64 typedef gconstpointer (*GeeFutureLightMapFunc) (gconstpointer value, gpointer user_data);
65 typedef gpointer (*GeeFutureZipFunc) (gconstpointer a, gconstpointer b, gpointer user_data);
66 typedef GeeFuture* (*GeeFutureFlatMapFunc) (gconstpointer value, gpointer user_data);
67 typedef struct _GeePromiseFuturePrivate GeePromiseFuturePrivate;
68 typedef enum {
69 GEE_PROMISE_FUTURE_STATE_INIT,
70 GEE_PROMISE_FUTURE_STATE_ABANDON,
71 GEE_PROMISE_FUTURE_STATE_EXCEPTION,
72 GEE_PROMISE_FUTURE_STATE_READY
73 } GeePromiseFutureState;
74
75 #define GEE_PROMISE_FUTURE_TYPE_STATE (gee_promise_future_state_get_type ())
76
77 #define GEE_FUTURE_TYPE_SOURCE_FUNC_ARRAY_ELEMENT (gee_future_source_func_array_element_get_type ())
78 typedef struct _GeeFutureSourceFuncArrayElement GeeFutureSourceFuncArrayElement;
79 enum {
80 GEE_PROMISE_FUTURE_0_PROPERTY,
81 GEE_PROMISE_FUTURE_G_TYPE,
82 GEE_PROMISE_FUTURE_G_DUP_FUNC,
83 GEE_PROMISE_FUTURE_G_DESTROY_FUNC,
84 GEE_PROMISE_FUTURE_READY_PROPERTY,
85 GEE_PROMISE_FUTURE_EXCEPTION_PROPERTY,
86 GEE_PROMISE_FUTURE_NUM_PROPERTIES
87 };
88 static GParamSpec* gee_promise_future_properties[GEE_PROMISE_FUTURE_NUM_PROPERTIES];
89 typedef struct _GeePromiseFutureWaitAsyncData GeePromiseFutureWaitAsyncData;
90 typedef struct _GeeParamSpecPromise GeeParamSpecPromise;
91 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
92 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
93 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
94 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
95
96 struct _GeePromise {
97 GTypeInstance parent_instance;
98 volatile int ref_count;
99 GeePromisePrivate * priv;
100 };
101
102 struct _GeePromiseClass {
103 GTypeClass parent_class;
104 void (*finalize) (GeePromise *self);
105 };
106
107 struct _GeePromisePrivate {
108 GType g_type;
109 GBoxedCopyFunc g_dup_func;
110 GDestroyNotify g_destroy_func;
111 GeePromiseFuture* _future;
112 };
113
114 typedef enum {
115 GEE_FUTURE_ERROR_ABANDON_PROMISE,
116 GEE_FUTURE_ERROR_EXCEPTION
117 } GeeFutureError;
118 #define GEE_FUTURE_ERROR gee_future_error_quark ()
119 struct _GeeFutureIface {
120 GTypeInterface parent_iface;
121 GType (*get_g_type) (GeeFuture* self);
122 GBoxedCopyFunc (*get_g_dup_func) (GeeFuture* self);
123 GDestroyNotify (*get_g_destroy_func) (GeeFuture* self);
124 gconstpointer (*wait) (GeeFuture* self, GError** error);
125 gboolean (*wait_until) (GeeFuture* self, gint64 end_time, gconstpointer* value, GError** error);
126 void (*wait_async) (GeeFuture* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
127 gconstpointer (*wait_finish) (GeeFuture* self, GAsyncResult* _res_, GError** error);
128 GeeFuture* (*map) (GeeFuture* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFutureMapFunc func, gpointer func_target, GDestroyNotify func_target_destroy_notify);
129 GeeFuture* (*light_map) (GeeFuture* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFutureLightMapFunc func, gpointer func_target);
130 GeeFuture* (*zip) (GeeFuture* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GType b_type, GBoxedCopyFunc b_dup_func, GDestroyNotify b_destroy_func, GeeFutureZipFunc zip_func, gpointer zip_func_target, GeeFuture* second);
131 GeeFuture* (*flat_map) (GeeFuture* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFutureFlatMapFunc func, gpointer func_target, GDestroyNotify func_target_destroy_notify);
132 gconstpointer (*get_value) (GeeFuture* self);
133 gboolean (*get_ready) (GeeFuture* self);
134 GError* (*get_exception) (GeeFuture* self);
135 GeeFuture* (*light_map_fixed) (GeeFuture* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFutureLightMapFunc func, gpointer func_target, GDestroyNotify func_target_destroy_notify);
136 };
137
138 struct _GeePromiseFuture {
139 GObject parent_instance;
140 GeePromiseFuturePrivate * priv;
141 };
142
143 struct _GeePromiseFutureClass {
144 GObjectClass parent_class;
145 };
146
147 struct _GeeFutureSourceFuncArrayElement {
148 GSourceFunc func;
149 gpointer func_target;
150 GDestroyNotify func_target_destroy_notify;
151 };
152
153 struct _GeePromiseFuturePrivate {
154 GType g_type;
155 GBoxedCopyFunc g_dup_func;
156 GDestroyNotify g_destroy_func;
157 GMutex _mutex;
158 GCond _set;
159 GeePromiseFutureState _state;
160 gpointer _value;
161 GError* _exception;
162 GeeFutureSourceFuncArrayElement* _when_done;
163 gint _when_done_length1;
164 gint __when_done_size_;
165 };
166
167 struct _GeePromiseFutureWaitAsyncData {
168 int _state_;
169 GObject* _source_object_;
170 GAsyncResult* _res_;
171 GTask* _async_result;
172 GeePromiseFuture* self;
173 gconstpointer result;
174 GeePromiseFutureState state;
175 GeePromiseFutureState _tmp0_;
176 GeePromiseFutureState _tmp1_;
177 GeeFutureSourceFuncArrayElement* _tmp2_;
178 gint _tmp2__length1;
179 GeeFutureSourceFuncArrayElement _tmp3_;
180 GeePromiseFutureState _tmp4_;
181 GeePromiseFutureState _tmp5_;
182 GeePromiseFutureState _tmp6_;
183 GError* _tmp7_;
184 GError* _tmp8_;
185 gconstpointer _tmp9_;
186 GError* _inner_error0_;
187 };
188
189 struct _GeeParamSpecPromise {
190 GParamSpec parent_instance;
191 };
192
193 static gint GeePromise_private_offset;
194 static gpointer gee_promise_parent_class = NULL;
195 static gint GeePromiseFuture_private_offset;
196 static gpointer gee_promise_future_parent_class = NULL;
197 static GeeFutureIface * gee_promise_future_gee_future_parent_iface = NULL;
198
199 gpointer gee_promise_ref (gpointer instance);
200 void gee_promise_unref (gpointer instance);
201 GParamSpec* gee_param_spec_promise (const gchar* name,
202 const gchar* nick,
203 const gchar* blurb,
204 GType object_type,
205 GParamFlags flags);
206 void gee_value_set_promise (GValue* value,
207 gpointer v_object);
208 void gee_value_take_promise (GValue* value,
209 gpointer v_object);
210 gpointer gee_value_get_promise (const GValue* value);
211 GType gee_promise_get_type (void) G_GNUC_CONST;
212 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeePromise, gee_promise_unref)
213 static GType gee_promise_future_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
214 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeePromiseFuture, g_object_unref)
215 static void gee_promise_future_abandon (GeePromiseFuture* self);
216 GeePromise* gee_promise_new (GType g_type,
217 GBoxedCopyFunc g_dup_func,
218 GDestroyNotify g_destroy_func);
219 GeePromise* gee_promise_construct (GType object_type,
220 GType g_type,
221 GBoxedCopyFunc g_dup_func,
222 GDestroyNotify g_destroy_func);
223 static GeePromiseFuture* gee_promise_future_new (GType g_type,
224 GBoxedCopyFunc g_dup_func,
225 GDestroyNotify g_destroy_func);
226 static GeePromiseFuture* gee_promise_future_construct (GType object_type,
227 GType g_type,
228 GBoxedCopyFunc g_dup_func,
229 GDestroyNotify g_destroy_func);
230 void gee_promise_set_value (GeePromise* self,
231 gpointer value);
232 static void gee_promise_future_set_value (GeePromiseFuture* self,
233 gpointer value);
234 void gee_promise_set_exception (GeePromise* self,
235 GError* exception);
236 static void gee_promise_future_set_exception (GeePromiseFuture* self,
237 GError* exception);
238 GQuark gee_future_error_quark (void);
239 GType gee_future_get_type (void) G_GNUC_CONST;
240 GeeFuture* gee_promise_get_future (GeePromise* self);
241 static GType gee_promise_future_state_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
242 G_GNUC_INTERNAL GType gee_future_source_func_array_element_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
243 G_GNUC_INTERNAL GeeFutureSourceFuncArrayElement* gee_future_source_func_array_element_dup (const GeeFutureSourceFuncArrayElement* self);
244 G_GNUC_INTERNAL void gee_future_source_func_array_element_free (GeeFutureSourceFuncArrayElement* self);
245 G_GNUC_INTERNAL void gee_future_source_func_array_element_copy (const GeeFutureSourceFuncArrayElement* self,
246 GeeFutureSourceFuncArrayElement* dest);
247 G_GNUC_INTERNAL void gee_future_source_func_array_element_destroy (GeeFutureSourceFuncArrayElement* self);
248 static void _vala_GeeFutureSourceFuncArrayElement_array_free (GeeFutureSourceFuncArrayElement * array,
249 gint array_length);
250 static gconstpointer gee_promise_future_real_wait (GeeFuture* base,
251 GError** error);
252 static gboolean gee_promise_future_real_wait_until (GeeFuture* base,
253 gint64 end_time,
254 gconstpointer* value,
255 GError** error);
256 static void gee_promise_future_real_wait_async_data_free (gpointer _data);
257 static void gee_promise_future_real_wait_async (GeeFuture* base,
258 GAsyncReadyCallback _callback_,
259 gpointer _user_data_);
260 static gboolean gee_promise_future_real_wait_async_co (GeePromiseFutureWaitAsyncData* _data_);
261 void gee_future_wait_async (GeeFuture* self,
262 GAsyncReadyCallback _callback_,
263 gpointer _user_data_);
264 gconstpointer gee_future_wait_finish (GeeFuture* self,
265 GAsyncResult* _res_,
266 GError** error);
267 static gboolean _gee_promise_future_real_wait_async_co_gsource_func (gpointer self);
268 G_GNUC_INTERNAL void gee_future_source_func_array_element_init (GeeFutureSourceFuncArrayElement *self,
269 GSourceFunc func,
270 gpointer func_target,
271 GDestroyNotify func_target_destroy_notify);
272 static void _vala_array_add2 (GeeFutureSourceFuncArrayElement* * array,
273 int* length,
274 int* size,
275 const GeeFutureSourceFuncArrayElement* value);
276 static void gee_promise_future_wait_async_ready (GObject* source_object,
277 GAsyncResult* _res_,
278 gpointer _user_data_);
279 static void gee_promise_future_finalize (GObject * obj);
280 gboolean gee_future_get_ready (GeeFuture* self);
281 GError* gee_future_get_exception (GeeFuture* self);
282 static void _vala_gee_promise_future_get_property (GObject * object,
283 guint property_id,
284 GValue * value,
285 GParamSpec * pspec);
286 static void _vala_gee_promise_future_set_property (GObject * object,
287 guint property_id,
288 const GValue * value,
289 GParamSpec * pspec);
290 static void gee_promise_finalize (GeePromise * obj);
291 static void _vala_clear_GMutex (GMutex * mutex);
292 static void _vala_clear_GRecMutex (GRecMutex * mutex);
293 static void _vala_clear_GRWLock (GRWLock * mutex);
294 static void _vala_clear_GCond (GCond * mutex);
295
296 static inline gpointer
gee_promise_get_instance_private(GeePromise * self)297 gee_promise_get_instance_private (GeePromise* self)
298 {
299 return G_STRUCT_MEMBER_P (self, GeePromise_private_offset);
300 }
301
302 GeePromise*
gee_promise_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func)303 gee_promise_construct (GType object_type,
304 GType g_type,
305 GBoxedCopyFunc g_dup_func,
306 GDestroyNotify g_destroy_func)
307 {
308 GeePromise* self = NULL;
309 GeePromiseFuture* _tmp0_;
310 self = (GeePromise*) g_type_create_instance (object_type);
311 self->priv->g_type = g_type;
312 self->priv->g_dup_func = g_dup_func;
313 self->priv->g_destroy_func = g_destroy_func;
314 _tmp0_ = gee_promise_future_new (g_type, (GBoxedCopyFunc) g_dup_func, (GDestroyNotify) g_destroy_func);
315 _g_object_unref0 (self->priv->_future);
316 self->priv->_future = _tmp0_;
317 return self;
318 }
319
320 GeePromise*
gee_promise_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func)321 gee_promise_new (GType g_type,
322 GBoxedCopyFunc g_dup_func,
323 GDestroyNotify g_destroy_func)
324 {
325 return gee_promise_construct (GEE_TYPE_PROMISE, g_type, g_dup_func, g_destroy_func);
326 }
327
328 /**
329 * Sets the value of the future.
330 *
331 * @param value Value of future
332 */
333 void
gee_promise_set_value(GeePromise * self,gpointer value)334 gee_promise_set_value (GeePromise* self,
335 gpointer value)
336 {
337 GeePromiseFuture* _tmp0_;
338 gpointer _tmp1_;
339 g_return_if_fail (self != NULL);
340 _tmp0_ = self->priv->_future;
341 _tmp1_ = value;
342 value = NULL;
343 gee_promise_future_set_value (_tmp0_, _tmp1_);
344 ((value == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (value = (self->priv->g_destroy_func (value), NULL));
345 }
346
347 /**
348 * Sets the exception.
349 *
350 * @param exception Exception thrown
351 */
352 void
gee_promise_set_exception(GeePromise * self,GError * exception)353 gee_promise_set_exception (GeePromise* self,
354 GError* exception)
355 {
356 GeePromiseFuture* _tmp0_;
357 GError* _tmp1_;
358 g_return_if_fail (self != NULL);
359 _tmp0_ = self->priv->_future;
360 _tmp1_ = exception;
361 exception = NULL;
362 gee_promise_future_set_exception (_tmp0_, _tmp1_);
363 _g_error_free0 (exception);
364 }
365
366 GeeFuture*
gee_promise_get_future(GeePromise * self)367 gee_promise_get_future (GeePromise* self)
368 {
369 GeeFuture* result;
370 GeePromiseFuture* _tmp0_;
371 g_return_val_if_fail (self != NULL, NULL);
372 _tmp0_ = self->priv->_future;
373 result = (GeeFuture*) _tmp0_;
374 return result;
375 }
376
377 static inline gpointer
gee_promise_future_get_instance_private(GeePromiseFuture * self)378 gee_promise_future_get_instance_private (GeePromiseFuture* self)
379 {
380 return G_STRUCT_MEMBER_P (self, GeePromiseFuture_private_offset);
381 }
382
383 static GType
gee_promise_future_state_get_type(void)384 gee_promise_future_state_get_type (void)
385 {
386 static volatile gsize gee_promise_future_state_type_id__volatile = 0;
387 if (g_once_init_enter (&gee_promise_future_state_type_id__volatile)) {
388 static const GEnumValue values[] = {{GEE_PROMISE_FUTURE_STATE_INIT, "GEE_PROMISE_FUTURE_STATE_INIT", "init"}, {GEE_PROMISE_FUTURE_STATE_ABANDON, "GEE_PROMISE_FUTURE_STATE_ABANDON", "abandon"}, {GEE_PROMISE_FUTURE_STATE_EXCEPTION, "GEE_PROMISE_FUTURE_STATE_EXCEPTION", "exception"}, {GEE_PROMISE_FUTURE_STATE_READY, "GEE_PROMISE_FUTURE_STATE_READY", "ready"}, {0, NULL, NULL}};
389 GType gee_promise_future_state_type_id;
390 gee_promise_future_state_type_id = g_enum_register_static ("GeePromiseFutureState", values);
391 g_once_init_leave (&gee_promise_future_state_type_id__volatile, gee_promise_future_state_type_id);
392 }
393 return gee_promise_future_state_type_id__volatile;
394 }
395
396 static void
_vala_GeeFutureSourceFuncArrayElement_array_free(GeeFutureSourceFuncArrayElement * array,gint array_length)397 _vala_GeeFutureSourceFuncArrayElement_array_free (GeeFutureSourceFuncArrayElement * array,
398 gint array_length)
399 {
400 if (array != NULL) {
401 int i;
402 for (i = 0; i < array_length; i = i + 1) {
403 gee_future_source_func_array_element_destroy (&array[i]);
404 }
405 }
406 g_free (array);
407 }
408
409 static GeePromiseFuture*
gee_promise_future_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func)410 gee_promise_future_construct (GType object_type,
411 GType g_type,
412 GBoxedCopyFunc g_dup_func,
413 GDestroyNotify g_destroy_func)
414 {
415 GeePromiseFuture * self = NULL;
416 GeeFutureSourceFuncArrayElement* _tmp0_;
417 self = (GeePromiseFuture*) g_object_new (object_type, NULL);
418 self->priv->g_type = g_type;
419 self->priv->g_dup_func = g_dup_func;
420 self->priv->g_destroy_func = g_destroy_func;
421 _tmp0_ = g_new0 (GeeFutureSourceFuncArrayElement, 0);
422 self->priv->_when_done = (_vala_GeeFutureSourceFuncArrayElement_array_free (self->priv->_when_done, self->priv->_when_done_length1), NULL);
423 self->priv->_when_done = _tmp0_;
424 self->priv->_when_done_length1 = 0;
425 self->priv->__when_done_size_ = self->priv->_when_done_length1;
426 return self;
427 }
428
429 static GeePromiseFuture*
gee_promise_future_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func)430 gee_promise_future_new (GType g_type,
431 GBoxedCopyFunc g_dup_func,
432 GDestroyNotify g_destroy_func)
433 {
434 return gee_promise_future_construct (GEE_PROMISE_TYPE_FUTURE, g_type, g_dup_func, g_destroy_func);
435 }
436
437 static gconstpointer
gee_promise_future_real_wait(GeeFuture * base,GError ** error)438 gee_promise_future_real_wait (GeeFuture* base,
439 GError** error)
440 {
441 GeePromiseFuture * self;
442 GeePromiseFutureState state = 0;
443 GeePromiseFutureState _tmp0_;
444 GeePromiseFutureState _tmp3_;
445 GError* _inner_error0_ = NULL;
446 gconstpointer result = NULL;
447 self = (GeePromiseFuture*) base;
448 g_mutex_lock (&self->priv->_mutex);
449 _tmp0_ = self->priv->_state;
450 state = _tmp0_;
451 while (TRUE) {
452 GeePromiseFutureState _tmp1_;
453 GeePromiseFutureState _tmp2_;
454 _tmp1_ = self->priv->_state;
455 if (!(_tmp1_ == GEE_PROMISE_FUTURE_STATE_INIT)) {
456 break;
457 }
458 g_cond_wait (&self->priv->_set, &self->priv->_mutex);
459 _tmp2_ = self->priv->_state;
460 state = _tmp2_;
461 }
462 g_mutex_unlock (&self->priv->_mutex);
463 _tmp3_ = state;
464 switch (_tmp3_) {
465 case GEE_PROMISE_FUTURE_STATE_ABANDON:
466 {
467 GError* _tmp4_;
468 _tmp4_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_ABANDON_PROMISE, "Promise has been abandon");
469 _inner_error0_ = _tmp4_;
470 if (_inner_error0_->domain == GEE_FUTURE_ERROR) {
471 g_propagate_error (error, _inner_error0_);
472 return NULL;
473 } else {
474 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
475 g_clear_error (&_inner_error0_);
476 return NULL;
477 }
478 }
479 case GEE_PROMISE_FUTURE_STATE_EXCEPTION:
480 {
481 GError* _tmp5_;
482 _tmp5_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_EXCEPTION, "Exception has been thrown");
483 _inner_error0_ = _tmp5_;
484 if (_inner_error0_->domain == GEE_FUTURE_ERROR) {
485 g_propagate_error (error, _inner_error0_);
486 return NULL;
487 } else {
488 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
489 g_clear_error (&_inner_error0_);
490 return NULL;
491 }
492 }
493 case GEE_PROMISE_FUTURE_STATE_READY:
494 {
495 gconstpointer _tmp6_;
496 _tmp6_ = self->priv->_value;
497 result = _tmp6_;
498 return result;
499 }
500 default:
501 {
502 g_assert_not_reached ();
503 }
504 }
505 }
506
507 static gboolean
gee_promise_future_real_wait_until(GeeFuture * base,gint64 end_time,gconstpointer * value,GError ** error)508 gee_promise_future_real_wait_until (GeeFuture* base,
509 gint64 end_time,
510 gconstpointer* value,
511 GError** error)
512 {
513 GeePromiseFuture * self;
514 gconstpointer _vala_value = NULL;
515 GeePromiseFutureState state = 0;
516 GeePromiseFutureState _tmp0_;
517 gboolean res = FALSE;
518 GeePromiseFutureState _tmp3_;
519 GError* _inner_error0_ = NULL;
520 gboolean result = FALSE;
521 self = (GeePromiseFuture*) base;
522 g_mutex_lock (&self->priv->_mutex);
523 _tmp0_ = self->priv->_state;
524 state = _tmp0_;
525 res = TRUE;
526 while (TRUE) {
527 GeePromiseFutureState _tmp1_;
528 GeePromiseFutureState _tmp2_;
529 _tmp1_ = self->priv->_state;
530 if (!(_tmp1_ == GEE_PROMISE_FUTURE_STATE_INIT)) {
531 break;
532 }
533 res = g_cond_wait_until (&self->priv->_set, &self->priv->_mutex, end_time);
534 if (!res) {
535 break;
536 }
537 _tmp2_ = self->priv->_state;
538 state = _tmp2_;
539 }
540 g_mutex_unlock (&self->priv->_mutex);
541 if (!res) {
542 _vala_value = NULL;
543 result = FALSE;
544 if (value) {
545 *value = _vala_value;
546 }
547 return result;
548 }
549 _tmp3_ = state;
550 switch (_tmp3_) {
551 case GEE_PROMISE_FUTURE_STATE_ABANDON:
552 {
553 GError* _tmp4_;
554 _tmp4_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_ABANDON_PROMISE, "Promise has been abandon");
555 _inner_error0_ = _tmp4_;
556 if (_inner_error0_->domain == GEE_FUTURE_ERROR) {
557 gboolean _tmp5_ = FALSE;
558 g_propagate_error (error, _inner_error0_);
559 return _tmp5_;
560 } else {
561 gboolean _tmp6_ = FALSE;
562 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
563 g_clear_error (&_inner_error0_);
564 return _tmp6_;
565 }
566 }
567 case GEE_PROMISE_FUTURE_STATE_EXCEPTION:
568 {
569 GError* _tmp7_;
570 _tmp7_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_EXCEPTION, "Exception has been thrown");
571 _inner_error0_ = _tmp7_;
572 if (_inner_error0_->domain == GEE_FUTURE_ERROR) {
573 gboolean _tmp8_ = FALSE;
574 g_propagate_error (error, _inner_error0_);
575 return _tmp8_;
576 } else {
577 gboolean _tmp9_ = FALSE;
578 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
579 g_clear_error (&_inner_error0_);
580 return _tmp9_;
581 }
582 }
583 case GEE_PROMISE_FUTURE_STATE_READY:
584 {
585 gconstpointer _tmp10_;
586 _tmp10_ = self->priv->_value;
587 _vala_value = _tmp10_;
588 result = TRUE;
589 if (value) {
590 *value = _vala_value;
591 }
592 return result;
593 }
594 default:
595 {
596 g_assert_not_reached ();
597 }
598 }
599 if (value) {
600 *value = _vala_value;
601 }
602 }
603
604 static void
gee_promise_future_real_wait_async_data_free(gpointer _data)605 gee_promise_future_real_wait_async_data_free (gpointer _data)
606 {
607 GeePromiseFutureWaitAsyncData* _data_;
608 _data_ = _data;
609 _g_object_unref0 (_data_->self);
610 g_slice_free (GeePromiseFutureWaitAsyncData, _data_);
611 }
612
613 static gpointer
_g_object_ref0(gpointer self)614 _g_object_ref0 (gpointer self)
615 {
616 return self ? g_object_ref (self) : NULL;
617 }
618
619 static void
gee_promise_future_real_wait_async(GeeFuture * base,GAsyncReadyCallback _callback_,gpointer _user_data_)620 gee_promise_future_real_wait_async (GeeFuture* base,
621 GAsyncReadyCallback _callback_,
622 gpointer _user_data_)
623 {
624 GeePromiseFuture * self;
625 GeePromiseFutureWaitAsyncData* _data_;
626 GeePromiseFuture* _tmp0_;
627 self = (GeePromiseFuture*) base;
628 _data_ = g_slice_new0 (GeePromiseFutureWaitAsyncData);
629 _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
630 g_task_set_task_data (_data_->_async_result, _data_, gee_promise_future_real_wait_async_data_free);
631 _tmp0_ = _g_object_ref0 (self);
632 _data_->self = _tmp0_;
633 gee_promise_future_real_wait_async_co (_data_);
634 }
635
636 static gconstpointer
gee_promise_future_wait_finish(GeeFuture * base,GAsyncResult * _res_,GError ** error)637 gee_promise_future_wait_finish (GeeFuture* base,
638 GAsyncResult* _res_,
639 GError** error)
640 {
641 gconstpointer result;
642 GeePromiseFutureWaitAsyncData* _data_;
643 _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
644 if (NULL == _data_) {
645 return NULL;
646 }
647 result = _data_->result;
648 _data_->result = NULL;
649 return result;
650 }
651
652 static gboolean
_gee_promise_future_real_wait_async_co_gsource_func(gpointer self)653 _gee_promise_future_real_wait_async_co_gsource_func (gpointer self)
654 {
655 gboolean result;
656 result = gee_promise_future_real_wait_async_co (self);
657 return result;
658 }
659
660 static void
_vala_array_add2(GeeFutureSourceFuncArrayElement ** array,int * length,int * size,const GeeFutureSourceFuncArrayElement * value)661 _vala_array_add2 (GeeFutureSourceFuncArrayElement* * array,
662 int* length,
663 int* size,
664 const GeeFutureSourceFuncArrayElement* value)
665 {
666 if ((*length) == (*size)) {
667 *size = (*size) ? (2 * (*size)) : 4;
668 *array = g_renew (GeeFutureSourceFuncArrayElement, *array, *size);
669 }
670 (*array)[(*length)++] = *value;
671 }
672
673 static void
gee_promise_future_wait_async_ready(GObject * source_object,GAsyncResult * _res_,gpointer _user_data_)674 gee_promise_future_wait_async_ready (GObject* source_object,
675 GAsyncResult* _res_,
676 gpointer _user_data_)
677 {
678 GeePromiseFutureWaitAsyncData* _data_;
679 _data_ = _user_data_;
680 _data_->_source_object_ = source_object;
681 _data_->_res_ = _res_;
682 gee_promise_future_real_wait_async_co (_data_);
683 }
684
685 static gboolean
gee_promise_future_real_wait_async_co(GeePromiseFutureWaitAsyncData * _data_)686 gee_promise_future_real_wait_async_co (GeePromiseFutureWaitAsyncData* _data_)
687 {
688 switch (_data_->_state_) {
689 case 0:
690 goto _state_0;
691 case 1:
692 goto _state_1;
693 default:
694 g_assert_not_reached ();
695 }
696 _state_0:
697 g_mutex_lock (&_data_->self->priv->_mutex);
698 _data_->_tmp0_ = _data_->self->priv->_state;
699 _data_->state = _data_->_tmp0_;
700 _data_->_tmp1_ = _data_->state;
701 if (_data_->_tmp1_ == GEE_PROMISE_FUTURE_STATE_INIT) {
702 _data_->_tmp2_ = _data_->self->priv->_when_done;
703 _data_->_tmp2__length1 = _data_->self->priv->_when_done_length1;
704 memset (&_data_->_tmp3_, 0, sizeof (GeeFutureSourceFuncArrayElement));
705 gee_future_source_func_array_element_init (&_data_->_tmp3_, _gee_promise_future_real_wait_async_co_gsource_func, _data_, NULL);
706 _vala_array_add2 (&_data_->self->priv->_when_done, &_data_->self->priv->_when_done_length1, &_data_->self->priv->__when_done_size_, &_data_->_tmp3_);
707 _data_->_state_ = 1;
708 gee_utils_async_yield_and_unlock (&_data_->self->priv->_mutex, gee_promise_future_wait_async_ready, _data_);
709 return FALSE;
710 _state_1:
711 gee_utils_async_yield_and_unlock_finish (_data_->_res_);
712 _data_->_tmp4_ = _data_->self->priv->_state;
713 _data_->state = _data_->_tmp4_;
714 } else {
715 g_mutex_unlock (&_data_->self->priv->_mutex);
716 }
717 _data_->_tmp5_ = _data_->state;
718 _vala_assert (_data_->_tmp5_ != GEE_PROMISE_FUTURE_STATE_INIT, "state != State.INIT");
719 _data_->_tmp6_ = _data_->state;
720 switch (_data_->_tmp6_) {
721 case GEE_PROMISE_FUTURE_STATE_ABANDON:
722 {
723 _data_->_tmp7_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_ABANDON_PROMISE, "Promise has been abandon");
724 _data_->_inner_error0_ = _data_->_tmp7_;
725 if (_data_->_inner_error0_->domain == GEE_FUTURE_ERROR) {
726 g_task_return_error (_data_->_async_result, _data_->_inner_error0_);
727 g_object_unref (_data_->_async_result);
728 return FALSE;
729 } else {
730 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error0_->message, g_quark_to_string (_data_->_inner_error0_->domain), _data_->_inner_error0_->code);
731 g_clear_error (&_data_->_inner_error0_);
732 g_object_unref (_data_->_async_result);
733 return FALSE;
734 }
735 }
736 case GEE_PROMISE_FUTURE_STATE_EXCEPTION:
737 {
738 _data_->_tmp8_ = g_error_new_literal (GEE_FUTURE_ERROR, GEE_FUTURE_ERROR_EXCEPTION, "Exception has been thrown");
739 _data_->_inner_error0_ = _data_->_tmp8_;
740 if (_data_->_inner_error0_->domain == GEE_FUTURE_ERROR) {
741 g_task_return_error (_data_->_async_result, _data_->_inner_error0_);
742 g_object_unref (_data_->_async_result);
743 return FALSE;
744 } else {
745 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error0_->message, g_quark_to_string (_data_->_inner_error0_->domain), _data_->_inner_error0_->code);
746 g_clear_error (&_data_->_inner_error0_);
747 g_object_unref (_data_->_async_result);
748 return FALSE;
749 }
750 }
751 case GEE_PROMISE_FUTURE_STATE_READY:
752 {
753 _data_->_tmp9_ = _data_->self->priv->_value;
754 _data_->result = _data_->_tmp9_;
755 g_task_return_pointer (_data_->_async_result, _data_, NULL);
756 if (_data_->_state_ != 0) {
757 while (!g_task_get_completed (_data_->_async_result)) {
758 g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
759 }
760 }
761 g_object_unref (_data_->_async_result);
762 return FALSE;
763 }
764 default:
765 {
766 g_assert_not_reached ();
767 }
768 }
769 }
770
771 static void
gee_promise_future_set_value(GeePromiseFuture * self,gpointer value)772 gee_promise_future_set_value (GeePromiseFuture* self,
773 gpointer value)
774 {
775 GeePromiseFutureState _tmp0_;
776 gpointer _tmp1_;
777 GeeFutureSourceFuncArrayElement* when_done = NULL;
778 GeeFutureSourceFuncArrayElement* _tmp2_;
779 gint _tmp2__length1;
780 gint when_done_length1;
781 gint _when_done_size_;
782 g_return_if_fail (self != NULL);
783 g_mutex_lock (&self->priv->_mutex);
784 _tmp0_ = self->priv->_state;
785 _vala_assert (_tmp0_ == GEE_PROMISE_FUTURE_STATE_INIT, "_state == State.INIT");
786 self->priv->_state = GEE_PROMISE_FUTURE_STATE_READY;
787 _tmp1_ = value;
788 value = NULL;
789 ((self->priv->_value == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->priv->_value = (self->priv->g_destroy_func (self->priv->_value), NULL));
790 self->priv->_value = _tmp1_;
791 g_cond_broadcast (&self->priv->_set);
792 g_mutex_unlock (&self->priv->_mutex);
793 _tmp2_ = self->priv->_when_done;
794 _tmp2__length1 = self->priv->_when_done_length1;
795 self->priv->_when_done = NULL;
796 self->priv->_when_done_length1 = 0;
797 when_done = _tmp2_;
798 when_done_length1 = _tmp2__length1;
799 _when_done_size_ = when_done_length1;
800 {
801 gint i = 0;
802 i = 0;
803 {
804 gboolean _tmp3_ = FALSE;
805 _tmp3_ = TRUE;
806 while (TRUE) {
807 GeeFutureSourceFuncArrayElement* _tmp5_;
808 gint _tmp5__length1;
809 GeeFutureSourceFuncArrayElement* _tmp6_;
810 gint _tmp6__length1;
811 GeeFutureSourceFuncArrayElement _tmp7_;
812 GSourceFunc _tmp8_;
813 gpointer _tmp8__target;
814 if (!_tmp3_) {
815 gint _tmp4_;
816 _tmp4_ = i;
817 i = _tmp4_ + 1;
818 }
819 _tmp3_ = FALSE;
820 _tmp5_ = when_done;
821 _tmp5__length1 = when_done_length1;
822 if (!(i < _tmp5__length1)) {
823 break;
824 }
825 _tmp6_ = when_done;
826 _tmp6__length1 = when_done_length1;
827 _tmp7_ = _tmp6_[i];
828 _tmp8_ = _tmp7_.func;
829 _tmp8__target = _tmp7_.func_target;
830 _tmp8_ (_tmp8__target);
831 }
832 }
833 }
834 when_done = (_vala_GeeFutureSourceFuncArrayElement_array_free (when_done, when_done_length1), NULL);
835 ((value == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (value = (self->priv->g_destroy_func (value), NULL));
836 }
837
838 static void
gee_promise_future_set_exception(GeePromiseFuture * self,GError * exception)839 gee_promise_future_set_exception (GeePromiseFuture* self,
840 GError* exception)
841 {
842 GeePromiseFutureState _tmp0_;
843 GError* _tmp1_;
844 GeeFutureSourceFuncArrayElement* when_done = NULL;
845 GeeFutureSourceFuncArrayElement* _tmp2_;
846 gint _tmp2__length1;
847 gint when_done_length1;
848 gint _when_done_size_;
849 g_return_if_fail (self != NULL);
850 g_mutex_lock (&self->priv->_mutex);
851 _tmp0_ = self->priv->_state;
852 _vala_assert (_tmp0_ == GEE_PROMISE_FUTURE_STATE_INIT, "_state == State.INIT");
853 self->priv->_state = GEE_PROMISE_FUTURE_STATE_EXCEPTION;
854 _tmp1_ = exception;
855 exception = NULL;
856 _g_error_free0 (self->priv->_exception);
857 self->priv->_exception = _tmp1_;
858 g_cond_broadcast (&self->priv->_set);
859 g_mutex_unlock (&self->priv->_mutex);
860 _tmp2_ = self->priv->_when_done;
861 _tmp2__length1 = self->priv->_when_done_length1;
862 self->priv->_when_done = NULL;
863 self->priv->_when_done_length1 = 0;
864 when_done = _tmp2_;
865 when_done_length1 = _tmp2__length1;
866 _when_done_size_ = when_done_length1;
867 {
868 gint i = 0;
869 i = 0;
870 {
871 gboolean _tmp3_ = FALSE;
872 _tmp3_ = TRUE;
873 while (TRUE) {
874 GeeFutureSourceFuncArrayElement* _tmp5_;
875 gint _tmp5__length1;
876 GeeFutureSourceFuncArrayElement* _tmp6_;
877 gint _tmp6__length1;
878 GeeFutureSourceFuncArrayElement _tmp7_;
879 GSourceFunc _tmp8_;
880 gpointer _tmp8__target;
881 if (!_tmp3_) {
882 gint _tmp4_;
883 _tmp4_ = i;
884 i = _tmp4_ + 1;
885 }
886 _tmp3_ = FALSE;
887 _tmp5_ = when_done;
888 _tmp5__length1 = when_done_length1;
889 if (!(i < _tmp5__length1)) {
890 break;
891 }
892 _tmp6_ = when_done;
893 _tmp6__length1 = when_done_length1;
894 _tmp7_ = _tmp6_[i];
895 _tmp8_ = _tmp7_.func;
896 _tmp8__target = _tmp7_.func_target;
897 _tmp8_ (_tmp8__target);
898 }
899 }
900 }
901 when_done = (_vala_GeeFutureSourceFuncArrayElement_array_free (when_done, when_done_length1), NULL);
902 _g_error_free0 (exception);
903 }
904
905 static void
gee_promise_future_abandon(GeePromiseFuture * self)906 gee_promise_future_abandon (GeePromiseFuture* self)
907 {
908 GeePromiseFutureState _tmp0_;
909 GeePromiseFutureState _tmp1_;
910 GeeFutureSourceFuncArrayElement* when_done = NULL;
911 GeeFutureSourceFuncArrayElement* _tmp2_;
912 gint _tmp2__length1;
913 gint when_done_length1;
914 gint _when_done_size_;
915 g_return_if_fail (self != NULL);
916 g_mutex_lock (&self->priv->_mutex);
917 _tmp0_ = self->priv->_state;
918 if (_tmp0_ != GEE_PROMISE_FUTURE_STATE_INIT) {
919 g_mutex_unlock (&self->priv->_mutex);
920 return;
921 }
922 _tmp1_ = self->priv->_state;
923 _vala_assert (_tmp1_ == GEE_PROMISE_FUTURE_STATE_INIT, "_state == State.INIT");
924 self->priv->_state = GEE_PROMISE_FUTURE_STATE_ABANDON;
925 g_cond_broadcast (&self->priv->_set);
926 g_mutex_unlock (&self->priv->_mutex);
927 _tmp2_ = self->priv->_when_done;
928 _tmp2__length1 = self->priv->_when_done_length1;
929 self->priv->_when_done = NULL;
930 self->priv->_when_done_length1 = 0;
931 when_done = _tmp2_;
932 when_done_length1 = _tmp2__length1;
933 _when_done_size_ = when_done_length1;
934 {
935 gint i = 0;
936 i = 0;
937 {
938 gboolean _tmp3_ = FALSE;
939 _tmp3_ = TRUE;
940 while (TRUE) {
941 GeeFutureSourceFuncArrayElement* _tmp5_;
942 gint _tmp5__length1;
943 GeeFutureSourceFuncArrayElement* _tmp6_;
944 gint _tmp6__length1;
945 GeeFutureSourceFuncArrayElement _tmp7_;
946 GSourceFunc _tmp8_;
947 gpointer _tmp8__target;
948 if (!_tmp3_) {
949 gint _tmp4_;
950 _tmp4_ = i;
951 i = _tmp4_ + 1;
952 }
953 _tmp3_ = FALSE;
954 _tmp5_ = when_done;
955 _tmp5__length1 = when_done_length1;
956 if (!(i < _tmp5__length1)) {
957 break;
958 }
959 _tmp6_ = when_done;
960 _tmp6__length1 = when_done_length1;
961 _tmp7_ = _tmp6_[i];
962 _tmp8_ = _tmp7_.func;
963 _tmp8__target = _tmp7_.func_target;
964 _tmp8_ (_tmp8__target);
965 }
966 }
967 }
968 when_done = (_vala_GeeFutureSourceFuncArrayElement_array_free (when_done, when_done_length1), NULL);
969 }
970
971 static gboolean
gee_promise_future_real_get_ready(GeeFuture * base)972 gee_promise_future_real_get_ready (GeeFuture* base)
973 {
974 gboolean result;
975 GeePromiseFuture* self;
976 gboolean _result_ = FALSE;
977 GeePromiseFutureState _tmp0_;
978 self = (GeePromiseFuture*) base;
979 g_mutex_lock (&self->priv->_mutex);
980 _tmp0_ = self->priv->_state;
981 _result_ = _tmp0_ != GEE_PROMISE_FUTURE_STATE_INIT;
982 g_mutex_unlock (&self->priv->_mutex);
983 result = _result_;
984 return result;
985 }
986
987 static GError*
gee_promise_future_real_get_exception(GeeFuture * base)988 gee_promise_future_real_get_exception (GeeFuture* base)
989 {
990 GError* result;
991 GeePromiseFuture* self;
992 GError* _tmp0_;
993 self = (GeePromiseFuture*) base;
994 _tmp0_ = self->priv->_exception;
995 result = _tmp0_;
996 return result;
997 }
998
999 static void
gee_promise_future_class_init(GeePromiseFutureClass * klass,gpointer klass_data)1000 gee_promise_future_class_init (GeePromiseFutureClass * klass,
1001 gpointer klass_data)
1002 {
1003 gee_promise_future_parent_class = g_type_class_peek_parent (klass);
1004 g_type_class_adjust_private_offset (klass, &GeePromiseFuture_private_offset);
1005 G_OBJECT_CLASS (klass)->get_property = _vala_gee_promise_future_get_property;
1006 G_OBJECT_CLASS (klass)->set_property = _vala_gee_promise_future_set_property;
1007 G_OBJECT_CLASS (klass)->finalize = gee_promise_future_finalize;
1008 g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PROMISE_FUTURE_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1009 g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PROMISE_FUTURE_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1010 g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PROMISE_FUTURE_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1011 g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PROMISE_FUTURE_READY_PROPERTY, gee_promise_future_properties[GEE_PROMISE_FUTURE_READY_PROPERTY] = g_param_spec_boolean ("ready", "ready", "ready", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1012 g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PROMISE_FUTURE_EXCEPTION_PROPERTY, gee_promise_future_properties[GEE_PROMISE_FUTURE_EXCEPTION_PROPERTY] = g_param_spec_pointer ("exception", "exception", "exception", G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1013 }
1014
1015 static GType
gee_promise_future_gee_future_get_g_type(GeePromiseFuture * self)1016 gee_promise_future_gee_future_get_g_type (GeePromiseFuture* self)
1017 {
1018 return self->priv->g_type;
1019 }
1020
1021 static GBoxedCopyFunc
gee_promise_future_gee_future_get_g_dup_func(GeePromiseFuture * self)1022 gee_promise_future_gee_future_get_g_dup_func (GeePromiseFuture* self)
1023 {
1024 return self->priv->g_dup_func;
1025 }
1026
1027 static GDestroyNotify
gee_promise_future_gee_future_get_g_destroy_func(GeePromiseFuture * self)1028 gee_promise_future_gee_future_get_g_destroy_func (GeePromiseFuture* self)
1029 {
1030 return self->priv->g_destroy_func;
1031 }
1032
1033 static void
gee_promise_future_gee_future_interface_init(GeeFutureIface * iface,gpointer iface_data)1034 gee_promise_future_gee_future_interface_init (GeeFutureIface * iface,
1035 gpointer iface_data)
1036 {
1037 gee_promise_future_gee_future_parent_iface = g_type_interface_peek_parent (iface);
1038 iface->wait = (gconstpointer (*) (GeeFuture*, GError**)) gee_promise_future_real_wait;
1039 iface->wait_until = (gboolean (*) (GeeFuture*, gint64, gconstpointer*, GError**)) gee_promise_future_real_wait_until;
1040 iface->wait_async = (void (*) (GeeFuture*, GAsyncReadyCallback, gpointer)) gee_promise_future_real_wait_async;
1041 iface->wait_finish = (gconstpointer (*) (GeeFuture*, GAsyncResult*, GError**)) gee_promise_future_wait_finish;
1042 iface->get_g_type = (GType (*) (GeeFuture *)) gee_promise_future_gee_future_get_g_type;
1043 iface->get_g_dup_func = (GBoxedCopyFunc (*) (GeeFuture *)) gee_promise_future_gee_future_get_g_dup_func;
1044 iface->get_g_destroy_func = (GDestroyNotify (*) (GeeFuture *)) gee_promise_future_gee_future_get_g_destroy_func;
1045 iface->get_ready = gee_promise_future_real_get_ready;
1046 iface->get_exception = gee_promise_future_real_get_exception;
1047 }
1048
1049 static void
gee_promise_future_instance_init(GeePromiseFuture * self,gpointer klass)1050 gee_promise_future_instance_init (GeePromiseFuture * self,
1051 gpointer klass)
1052 {
1053 self->priv = gee_promise_future_get_instance_private (self);
1054 g_mutex_init (&self->priv->_mutex);
1055 g_cond_init (&self->priv->_set);
1056 }
1057
1058 static void
gee_promise_future_finalize(GObject * obj)1059 gee_promise_future_finalize (GObject * obj)
1060 {
1061 GeePromiseFuture * self;
1062 self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_PROMISE_TYPE_FUTURE, GeePromiseFuture);
1063 _vala_clear_GMutex (&self->priv->_mutex);
1064 _vala_clear_GCond (&self->priv->_set);
1065 ((self->priv->_value == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->priv->_value = (self->priv->g_destroy_func (self->priv->_value), NULL));
1066 _g_error_free0 (self->priv->_exception);
1067 self->priv->_when_done = (_vala_GeeFutureSourceFuncArrayElement_array_free (self->priv->_when_done, self->priv->_when_done_length1), NULL);
1068 G_OBJECT_CLASS (gee_promise_future_parent_class)->finalize (obj);
1069 }
1070
1071 static GType
gee_promise_future_get_type(void)1072 gee_promise_future_get_type (void)
1073 {
1074 static volatile gsize gee_promise_future_type_id__volatile = 0;
1075 if (g_once_init_enter (&gee_promise_future_type_id__volatile)) {
1076 static const GTypeInfo g_define_type_info = { sizeof (GeePromiseFutureClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_promise_future_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePromiseFuture), 0, (GInstanceInitFunc) gee_promise_future_instance_init, NULL };
1077 static const GInterfaceInfo gee_future_info = { (GInterfaceInitFunc) gee_promise_future_gee_future_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1078 GType gee_promise_future_type_id;
1079 gee_promise_future_type_id = g_type_register_static (G_TYPE_OBJECT, "GeePromiseFuture", &g_define_type_info, 0);
1080 g_type_add_interface_static (gee_promise_future_type_id, GEE_TYPE_FUTURE, &gee_future_info);
1081 GeePromiseFuture_private_offset = g_type_add_instance_private (gee_promise_future_type_id, sizeof (GeePromiseFuturePrivate));
1082 g_once_init_leave (&gee_promise_future_type_id__volatile, gee_promise_future_type_id);
1083 }
1084 return gee_promise_future_type_id__volatile;
1085 }
1086
1087 static void
_vala_gee_promise_future_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)1088 _vala_gee_promise_future_get_property (GObject * object,
1089 guint property_id,
1090 GValue * value,
1091 GParamSpec * pspec)
1092 {
1093 GeePromiseFuture * self;
1094 self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_PROMISE_TYPE_FUTURE, GeePromiseFuture);
1095 switch (property_id) {
1096 case GEE_PROMISE_FUTURE_READY_PROPERTY:
1097 g_value_set_boolean (value, gee_future_get_ready ((GeeFuture*) self));
1098 break;
1099 case GEE_PROMISE_FUTURE_EXCEPTION_PROPERTY:
1100 g_value_set_pointer (value, gee_future_get_exception ((GeeFuture*) self));
1101 break;
1102 case GEE_PROMISE_FUTURE_G_TYPE:
1103 g_value_set_gtype (value, self->priv->g_type);
1104 break;
1105 case GEE_PROMISE_FUTURE_G_DUP_FUNC:
1106 g_value_set_pointer (value, self->priv->g_dup_func);
1107 break;
1108 case GEE_PROMISE_FUTURE_G_DESTROY_FUNC:
1109 g_value_set_pointer (value, self->priv->g_destroy_func);
1110 break;
1111 default:
1112 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1113 break;
1114 }
1115 }
1116
1117 static void
_vala_gee_promise_future_set_property(GObject * object,guint property_id,const GValue * value,GParamSpec * pspec)1118 _vala_gee_promise_future_set_property (GObject * object,
1119 guint property_id,
1120 const GValue * value,
1121 GParamSpec * pspec)
1122 {
1123 GeePromiseFuture * self;
1124 self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_PROMISE_TYPE_FUTURE, GeePromiseFuture);
1125 switch (property_id) {
1126 case GEE_PROMISE_FUTURE_G_TYPE:
1127 self->priv->g_type = g_value_get_gtype (value);
1128 break;
1129 case GEE_PROMISE_FUTURE_G_DUP_FUNC:
1130 self->priv->g_dup_func = g_value_get_pointer (value);
1131 break;
1132 case GEE_PROMISE_FUTURE_G_DESTROY_FUNC:
1133 self->priv->g_destroy_func = g_value_get_pointer (value);
1134 break;
1135 default:
1136 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1137 break;
1138 }
1139 }
1140
1141 static void
gee_value_promise_init(GValue * value)1142 gee_value_promise_init (GValue* value)
1143 {
1144 value->data[0].v_pointer = NULL;
1145 }
1146
1147 static void
gee_value_promise_free_value(GValue * value)1148 gee_value_promise_free_value (GValue* value)
1149 {
1150 if (value->data[0].v_pointer) {
1151 gee_promise_unref (value->data[0].v_pointer);
1152 }
1153 }
1154
1155 static void
gee_value_promise_copy_value(const GValue * src_value,GValue * dest_value)1156 gee_value_promise_copy_value (const GValue* src_value,
1157 GValue* dest_value)
1158 {
1159 if (src_value->data[0].v_pointer) {
1160 dest_value->data[0].v_pointer = gee_promise_ref (src_value->data[0].v_pointer);
1161 } else {
1162 dest_value->data[0].v_pointer = NULL;
1163 }
1164 }
1165
1166 static gpointer
gee_value_promise_peek_pointer(const GValue * value)1167 gee_value_promise_peek_pointer (const GValue* value)
1168 {
1169 return value->data[0].v_pointer;
1170 }
1171
1172 static gchar*
gee_value_promise_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1173 gee_value_promise_collect_value (GValue* value,
1174 guint n_collect_values,
1175 GTypeCValue* collect_values,
1176 guint collect_flags)
1177 {
1178 if (collect_values[0].v_pointer) {
1179 GeePromise * object;
1180 object = collect_values[0].v_pointer;
1181 if (object->parent_instance.g_class == NULL) {
1182 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1183 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1184 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1185 }
1186 value->data[0].v_pointer = gee_promise_ref (object);
1187 } else {
1188 value->data[0].v_pointer = NULL;
1189 }
1190 return NULL;
1191 }
1192
1193 static gchar*
gee_value_promise_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1194 gee_value_promise_lcopy_value (const GValue* value,
1195 guint n_collect_values,
1196 GTypeCValue* collect_values,
1197 guint collect_flags)
1198 {
1199 GeePromise ** object_p;
1200 object_p = collect_values[0].v_pointer;
1201 if (!object_p) {
1202 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1203 }
1204 if (!value->data[0].v_pointer) {
1205 *object_p = NULL;
1206 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1207 *object_p = value->data[0].v_pointer;
1208 } else {
1209 *object_p = gee_promise_ref (value->data[0].v_pointer);
1210 }
1211 return NULL;
1212 }
1213
1214 GParamSpec*
gee_param_spec_promise(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)1215 gee_param_spec_promise (const gchar* name,
1216 const gchar* nick,
1217 const gchar* blurb,
1218 GType object_type,
1219 GParamFlags flags)
1220 {
1221 GeeParamSpecPromise* spec;
1222 g_return_val_if_fail (g_type_is_a (object_type, GEE_TYPE_PROMISE), NULL);
1223 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1224 G_PARAM_SPEC (spec)->value_type = object_type;
1225 return G_PARAM_SPEC (spec);
1226 }
1227
1228 gpointer
gee_value_get_promise(const GValue * value)1229 gee_value_get_promise (const GValue* value)
1230 {
1231 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TYPE_PROMISE), NULL);
1232 return value->data[0].v_pointer;
1233 }
1234
1235 void
gee_value_set_promise(GValue * value,gpointer v_object)1236 gee_value_set_promise (GValue* value,
1237 gpointer v_object)
1238 {
1239 GeePromise * old;
1240 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TYPE_PROMISE));
1241 old = value->data[0].v_pointer;
1242 if (v_object) {
1243 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_TYPE_PROMISE));
1244 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1245 value->data[0].v_pointer = v_object;
1246 gee_promise_ref (value->data[0].v_pointer);
1247 } else {
1248 value->data[0].v_pointer = NULL;
1249 }
1250 if (old) {
1251 gee_promise_unref (old);
1252 }
1253 }
1254
1255 void
gee_value_take_promise(GValue * value,gpointer v_object)1256 gee_value_take_promise (GValue* value,
1257 gpointer v_object)
1258 {
1259 GeePromise * old;
1260 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TYPE_PROMISE));
1261 old = value->data[0].v_pointer;
1262 if (v_object) {
1263 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_TYPE_PROMISE));
1264 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1265 value->data[0].v_pointer = v_object;
1266 } else {
1267 value->data[0].v_pointer = NULL;
1268 }
1269 if (old) {
1270 gee_promise_unref (old);
1271 }
1272 }
1273
1274 static void
gee_promise_class_init(GeePromiseClass * klass,gpointer klass_data)1275 gee_promise_class_init (GeePromiseClass * klass,
1276 gpointer klass_data)
1277 {
1278 gee_promise_parent_class = g_type_class_peek_parent (klass);
1279 ((GeePromiseClass *) klass)->finalize = gee_promise_finalize;
1280 g_type_class_adjust_private_offset (klass, &GeePromise_private_offset);
1281 }
1282
1283 static void
gee_promise_instance_init(GeePromise * self,gpointer klass)1284 gee_promise_instance_init (GeePromise * self,
1285 gpointer klass)
1286 {
1287 self->priv = gee_promise_get_instance_private (self);
1288 self->ref_count = 1;
1289 }
1290
1291 static void
gee_promise_finalize(GeePromise * obj)1292 gee_promise_finalize (GeePromise * obj)
1293 {
1294 GeePromise * self;
1295 GeePromiseFuture* _tmp0_;
1296 self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_PROMISE, GeePromise);
1297 g_signal_handlers_destroy (self);
1298 _tmp0_ = self->priv->_future;
1299 gee_promise_future_abandon (_tmp0_);
1300 _g_object_unref0 (self->priv->_future);
1301 }
1302
1303 /**
1304 * Promise allows to set a value with associated {@link Future}. Please note that
1305 * value can be stored only once.
1306 *
1307 * Typically the producer will create promise and return {@link future} while
1308 * keeping the promise to itself. Then when value is ready it can call {@link set_value}.
1309 *
1310 * @see Future
1311 * @see task
1312 * @since 0.11.0
1313 */
1314 GType
gee_promise_get_type(void)1315 gee_promise_get_type (void)
1316 {
1317 static volatile gsize gee_promise_type_id__volatile = 0;
1318 if (g_once_init_enter (&gee_promise_type_id__volatile)) {
1319 static const GTypeValueTable g_define_type_value_table = { gee_value_promise_init, gee_value_promise_free_value, gee_value_promise_copy_value, gee_value_promise_peek_pointer, "p", gee_value_promise_collect_value, "p", gee_value_promise_lcopy_value };
1320 static const GTypeInfo g_define_type_info = { sizeof (GeePromiseClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_promise_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePromise), 0, (GInstanceInitFunc) gee_promise_instance_init, &g_define_type_value_table };
1321 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
1322 GType gee_promise_type_id;
1323 gee_promise_type_id = g_type_register_fundamental (g_type_fundamental_next (), "GeePromise", &g_define_type_info, &g_define_type_fundamental_info, 0);
1324 GeePromise_private_offset = g_type_add_instance_private (gee_promise_type_id, sizeof (GeePromisePrivate));
1325 g_once_init_leave (&gee_promise_type_id__volatile, gee_promise_type_id);
1326 }
1327 return gee_promise_type_id__volatile;
1328 }
1329
1330 gpointer
gee_promise_ref(gpointer instance)1331 gee_promise_ref (gpointer instance)
1332 {
1333 GeePromise * self;
1334 self = instance;
1335 g_atomic_int_inc (&self->ref_count);
1336 return instance;
1337 }
1338
1339 void
gee_promise_unref(gpointer instance)1340 gee_promise_unref (gpointer instance)
1341 {
1342 GeePromise * self;
1343 self = instance;
1344 if (g_atomic_int_dec_and_test (&self->ref_count)) {
1345 GEE_PROMISE_GET_CLASS (self)->finalize (self);
1346 g_type_free_instance ((GTypeInstance *) self);
1347 }
1348 }
1349
1350 static void
_vala_clear_GMutex(GMutex * mutex)1351 _vala_clear_GMutex (GMutex * mutex)
1352 {
1353 GMutex zero_mutex = { 0 };
1354 if (memcmp (mutex, &zero_mutex, sizeof (GMutex))) {
1355 g_mutex_clear (mutex);
1356 memset (mutex, 0, sizeof (GMutex));
1357 }
1358 }
1359
1360 static void
_vala_clear_GRecMutex(GRecMutex * mutex)1361 _vala_clear_GRecMutex (GRecMutex * mutex)
1362 {
1363 GRecMutex zero_mutex = { 0 };
1364 if (memcmp (mutex, &zero_mutex, sizeof (GRecMutex))) {
1365 g_rec_mutex_clear (mutex);
1366 memset (mutex, 0, sizeof (GRecMutex));
1367 }
1368 }
1369
1370 static void
_vala_clear_GRWLock(GRWLock * mutex)1371 _vala_clear_GRWLock (GRWLock * mutex)
1372 {
1373 GRWLock zero_mutex = { 0 };
1374 if (memcmp (mutex, &zero_mutex, sizeof (GRWLock))) {
1375 g_rw_lock_clear (mutex);
1376 memset (mutex, 0, sizeof (GRWLock));
1377 }
1378 }
1379
1380 static void
_vala_clear_GCond(GCond * mutex)1381 _vala_clear_GCond (GCond * mutex)
1382 {
1383 GCond zero_mutex = { 0 };
1384 if (memcmp (mutex, &zero_mutex, sizeof (GCond))) {
1385 g_cond_clear (mutex);
1386 memset (mutex, 0, sizeof (GCond));
1387 }
1388 }
1389
1390