src/gthread/Cond.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  =
  26  * outPack = gthread
  27  * outFile = Cond
  28  * strct   = GCond
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Cond
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - g_cond_
  40  * omit structs:
  41  * omit prefixes:
  42  * omit code:
  43  * imports:
  44  *      - glib.Date
  45  *      - gthread.Mutex
  46  * structWrap:
  47  *      - GDate* -> Date
  48  *      - GMutex* -> Mutex
  49  * local aliases:
  50  */
  51
  52 module gthread.Cond;
  53
  54 private import gthread.gthreadtypes;
  55
  56 private import lib.gthread;
  57
  58 private import glib.Date;
  59 private import gthread.Mutex;
  60
  61 /**
  62  * Description
  63  * Threads act almost like processes, but unlike processes all threads of
  64  * one process share the same memory. This is good, as it provides easy
  65  * communication between the involved threads via this shared memory, and
  66  * it is bad, because strange things (so called "Heisenbugs") might
  67  * happen if the program is not carefully designed. In particular, due to
  68  * the concurrent nature of threads, no assumptions on the order of
  69  * execution of code running in different threads can be made, unless
  70  * order is explicitly forced by the programmer through synchronization
  71  * primitives.
  72  * The aim of the thread related functions in GLib is to provide a
  73  * portable means for writing multi-threaded software. There are
  74  * primitives for mutexes to protect the access to portions of memory
  75  * (GMutex, GStaticMutex, G_LOCK_DEFINE, GStaticRecMutex and
  76  * GStaticRWLock). There are primitives for condition variables to allow
  77  * synchronization of threads (GCond). There are primitives
  78  * for thread-private data - data that every thread has a private instance of
  79  * (GPrivate, GStaticPrivate). Last but definitely not least there are
  80  * primitives to portably create and manage threads (GThread).
  81  * You must call g_thread_init() before executing any other GLib
  82  * functions in a threaded GLib program. After that, GLib is completely
  83  * thread safe (all global data is automatically locked), but individual
  84  * data structure instances are not automatically locked for performance
  85  * reasons. So, for example you must coordinate accesses to the same
  86  * GHashTable from multiple threads. The two notable exceptions from
  87  * this rule are GMainLoop and GAsyncQueue,
  88  * which are threadsafe and needs no further
  89  * application-level locking to be accessed from multiple threads.
  90  */
  91 public class Cond
  92 {
  93
  94         /** the main Gtk struct */
  95         protected GCond* gCond;
  96
  97
  98         public GCond* getCondStruct()
  99         {
 100                 return gCond;
 101         }
 102
 103
 104         /** the main Gtk struct as a void* */
 105         protected void* getStruct()
 106         {
 107                 return cast(void*)gCond;
 108         }
 109
 110         /**
 111          * Sets our main struct and passes it to the parent class
 112          */
 113         public this (GCond* gCond)
 114         {
 115                 this.gCond = gCond;
 116         }
 117
 118         /**
 119          */
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180         /**
 181          * Creates a new GCond. This function will abort, if g_thread_init()
 182          * has not been called yet.
 183          * Returns:
 184          * a new GCond.
 185          */
 186         public this ()
 187         {
 188                 // GCond* g_cond_new ();
 189                 this(cast(GCond*)g_cond_new() );
 190         }
 191
 192         /**
 193          * If threads are waiting for cond, exactly one of them is woken up. It
 194          * is good practice to hold the same lock as the waiting thread while
 195          * calling this function, though not required.
 196          * This function can be used even if g_thread_init() has not yet been called,
 197          * and, in that case, will do nothing.
 198          * cond:
 199          * a GCond.
 200          */
 201         public void signal()
 202         {
 203                 // void g_cond_signal (GCond *cond);
 204                 g_cond_signal(gCond);
 205         }
 206
 207         /**
 208          * If threads are waiting for cond, all of them are woken up. It is good
 209          * practice to lock the same mutex as the waiting threads, while calling
 210          * this function, though not required.
 211          * This function can be used even if g_thread_init() has not yet been called,
 212          * and, in that case, will do nothing.
 213          * cond:
 214          * a GCond.
 215          */
 216         public void broadcast()
 217         {
 218                 // void g_cond_broadcast (GCond *cond);
 219                 g_cond_broadcast(gCond);
 220         }
 221
 222         /**
 223          * Waits until this thread is woken up on cond. The mutex is unlocked
 224          * before falling asleep and locked again before resuming.
 225          * This function can be used even if g_thread_init() has not yet been
 226          * called, and, in that case, will immediately return.
 227          * cond:
 228          * a GCond.
 229          * mutex:
 230          * a GMutex, that is currently locked.
 231          */
 232         public void wait(Mutex mutex)
 233         {
 234                 // void g_cond_wait (GCond *cond,  GMutex *mutex);
 235                 g_cond_wait(gCond, (mutex is null) ? null : mutex.getMutexStruct());
 236         }
 237
 238         /**
 239          * Waits until this thread is woken up on cond, but not longer than
 240          * until the time specified by abs_time. The mutex is
 241          * unlocked before falling asleep and locked again before resuming.
 242          * If abs_time is NULL, g_cond_timed_wait() acts like g_cond_wait().
 243          * This function can be used even if g_thread_init() has not yet been
 244          * called, and, in that case, will immediately return TRUE.
 245          * To easily calculate abs_time a combination of g_get_current_time()
 246          * and g_time_val_add() can be used.
 247          * cond:
 248          * a GCond.
 249          * mutex:
 250          * a GMutex that is currently locked.
 251          * abs_time:
 252          * a GTimeVal, determining the final time.
 253          * Returns:
 254          * TRUE if cond was signalled, or FALSE on timeout.
 255          */
 256         public int timedWait(Mutex mutex, GTimeVal* absTime)
 257         {
 258                 // gboolean g_cond_timed_wait (GCond *cond,  GMutex *mutex,  GTimeVal *abs_time);
 259                 return g_cond_timed_wait(gCond, (mutex is null) ? null : mutex.getMutexStruct(), absTime);
 260         }
 261
 262         /**
 263          * Destroys the GCond.
 264          * cond:
 265          * a GCond.
 266          */
 267         public void free()
 268         {
 269                 // void g_cond_free (GCond *cond);
 270                 g_cond_free(gCond);
 271         }
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286 }