00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00053 #ifndef _UCOMMON_THREAD_H_
00054 #define _UCOMMON_THREAD_H_
00055
00056 #ifndef _UCOMMON_CONFIG_H_
00057 #include <ucommon/platform.h>
00058 #endif
00059
00060 #ifndef _UCOMMON_ACCESS_H_
00061 #include <ucommon/access.h>
00062 #endif
00063
00064 #ifndef _UCOMMON_TIMERS_H_
00065 #include <ucommon/timers.h>
00066 #endif
00067
00068 #ifndef _UCOMMON_MEMORY_H_
00069 #include <ucommon/memory.h>
00070 #endif
00071
00072 NAMESPACE_UCOMMON
00073
00074 class SharedPointer;
00075
00086 class __EXPORT Conditional
00087 {
00088 private:
00089 friend class ConditionalAccess;
00090
00091 #ifdef _MSWINDOWS_
00092 enum {SIGNAL = 0, BROADCAST = 1};
00093 HANDLE events[2];
00094 unsigned waiting;
00095 CRITICAL_SECTION mlock;
00096 CRITICAL_SECTION mutex;
00097 #else
00098 #ifndef __PTH__
00099 class __LOCAL attribute
00100 {
00101 public:
00102 pthread_condattr_t attr;
00103 attribute();
00104 };
00105
00106 __LOCAL static attribute attr;
00107 #endif
00108
00109 pthread_cond_t cond;
00110 pthread_mutex_t mutex;
00111 #endif
00112
00113 protected:
00114 friend class TimedEvent;
00115
00121 bool wait(timeout_t timeout);
00122
00128 bool wait(struct timespec *timeout);
00129
00130 #ifdef _MSWINDOWS_
00131 inline void lock(void)
00132 {EnterCriticalSection(&mutex);};
00133
00134 inline void unlock(void)
00135 {LeaveCriticalSection(&mutex);};
00136
00137 void wait(void);
00138 void signal(void);
00139 void broadcast(void);
00140
00141 #else
00142
00145 inline void lock(void)
00146 {pthread_mutex_lock(&mutex);};
00147
00151 inline void unlock(void)
00152 {pthread_mutex_unlock(&mutex);};
00153
00157 inline void wait(void)
00158 {pthread_cond_wait(&cond, &mutex);};
00159
00163 inline void signal(void)
00164 {pthread_cond_signal(&cond);};
00165
00169 inline void broadcast(void)
00170 {pthread_cond_broadcast(&cond);};
00171 #endif
00172
00176 Conditional();
00177
00181 ~Conditional();
00182
00183 public:
00184 #if !defined(_MSWINDOWS_) && !defined(__PTH__)
00185
00190 static inline pthread_condattr_t *initializer(void)
00191 {return &attr.attr;};
00192 #endif
00193
00200 static void gettimeout(timeout_t timeout, struct timespec *hires);
00201 };
00202
00210 class __EXPORT ConditionalAccess : private Conditional
00211 {
00212 private:
00213 #ifndef _MSWINDOWS_
00214 pthread_cond_t bcast;
00215 #endif
00216
00217 protected:
00218 unsigned pending, waiting, sharing;
00219
00225 bool waitSignal(timeout_t timeout);
00226
00232 bool waitBroadcast(timeout_t timeout);
00233
00234
00240 bool waitSignal(struct timespec *timeout);
00241
00247 bool waitBroadcast(struct timespec *timeout);
00248
00255 inline static void gettimeout(timeout_t timeout, struct timespec *hires)
00256 {Conditional::gettimeout(timeout, hires);};
00257
00258
00259 #ifdef _MSWINDOWS_
00260 inline void lock(void)
00261 {EnterCriticalSection(&mutex);};
00262
00263 inline void unlock(void)
00264 {LeaveCriticalSection(&mutex);};
00265
00266 void waitSignal(void);
00267 void waitBroadcast(void);
00268
00269 inline void signal(void)
00270 {Conditional::signal();};
00271
00272 inline void broadcast(void)
00273 {Conditional::broadcast();};
00274
00275 #else
00276
00279 inline void lock(void)
00280 {pthread_mutex_lock(&mutex);};
00281
00285 inline void unlock(void)
00286 {pthread_mutex_unlock(&mutex);};
00287
00291 inline void waitSignal(void)
00292 {pthread_cond_wait(&cond, &mutex);};
00293
00297 inline void waitBroadcast(void)
00298 {pthread_cond_wait(&bcast, &mutex);};
00299
00300
00304 inline void signal(void)
00305 {pthread_cond_signal(&cond);};
00306
00310 inline void broadcast(void)
00311 {pthread_cond_broadcast(&bcast);};
00312 #endif
00313 public:
00317 ConditionalAccess();
00318
00322 ~ConditionalAccess();
00323
00327 void access(void);
00328
00332 void modify(void);
00333
00337 void release(void);
00338
00342 void commit(void);
00343
00350 void limit_sharing(unsigned max);
00351 };
00352
00361 class __EXPORT TimedEvent : public Timer
00362 {
00363 private:
00364 #ifdef _MSWINDOWS_
00365 HANDLE event;
00366 #else
00367 pthread_cond_t cond;
00368 bool signalled;
00369 #endif
00370 pthread_mutex_t mutex;
00371
00372 protected:
00377 void lock(void);
00378
00383 void release(void);
00384
00392 bool sync(void);
00393
00394 public:
00398 TimedEvent(void);
00399
00404 TimedEvent(timeout_t timeout);
00405
00410 TimedEvent(time_t timeout);
00411
00415 ~TimedEvent();
00416
00422 void signal(void);
00423
00430 bool wait(timeout_t timeout);
00431
00435 void reset(void);
00436
00441 inline static void signal(TimedEvent& timed)
00442 {timed.signal();};
00443
00448 inline static void reset(TimedEvent& timed)
00449 {timed.reset();};
00450
00457 inline static bool wait(TimedEvent& timed, timeout_t timeout)
00458 {return timed.wait(timeout);};
00459 };
00460
00468 class __EXPORT rexlock : private Conditional, public Exclusive
00469 {
00470 private:
00471 unsigned waiting;
00472 unsigned lockers;
00473 pthread_t locker;
00474
00475 __LOCAL void Exlock(void);
00476 __LOCAL void Unlock(void);
00477
00478 public:
00482 rexlock();
00483
00487 void lock(void);
00488
00492 void release(void);
00493
00498 unsigned getLocking(void);
00499
00504 unsigned getWaiting(void);
00505
00510 inline static void lock(rexlock& rex)
00511 {rex.lock();};
00512
00517 inline static void release(rexlock& rex)
00518 {rex.release();};
00519 };
00520
00533 class __EXPORT rwlock : private ConditionalAccess, public Exclusive, public Shared
00534 {
00535 private:
00536 unsigned writers;
00537 pthread_t writeid;
00538
00539 __LOCAL void Exlock(void);
00540 __LOCAL void Shlock(void);
00541 __LOCAL void Unlock(void);
00542
00543 public:
00551 class __EXPORT gaurd_reader
00552 {
00553 private:
00554 void *object;
00555
00556 public:
00561 gaurd_reader();
00562
00567 gaurd_reader(void *object);
00568
00572 ~gaurd_reader();
00573
00579 void set(void *object);
00580
00584 void release(void);
00585
00591 inline void operator=(void *pointer)
00592 {set(pointer);};
00593 };
00594
00602 class __EXPORT gaurd_writer
00603 {
00604 private:
00605 void *object;
00606
00607 public:
00612 gaurd_writer();
00613
00618 gaurd_writer(void *object);
00619
00623 ~gaurd_writer();
00624
00630 void set(void *object);
00631
00635 void release(void);
00636
00642 inline void operator=(void *pointer)
00643 {set(pointer);};
00644 };
00645
00649 rwlock();
00650
00656 bool modify(timeout_t timeout = Timer::inf);
00657
00663 bool access(timeout_t timeout = Timer::inf);
00664
00671 static void indexing(unsigned size);
00672
00680 static bool writer(void *object, timeout_t timeout = Timer::inf);
00681
00689 static bool reader(void *object, timeout_t timeout = Timer::inf);
00690
00695 static void release(void *object);
00696
00700 void release(void);
00701
00706 unsigned getAccess(void);
00707
00712 unsigned getModify(void);
00713
00718 unsigned getWaiting(void);
00719
00726 inline static bool modify(rwlock& lock, timeout_t timeout = Timer::inf)
00727 {return lock.modify(timeout);};
00728
00735 inline static bool access(rwlock& lock, timeout_t timeout = Timer::inf)
00736 {return lock.access(timeout);};
00737
00742 inline static void release(rwlock& lock)
00743 {lock.release();};
00744 };
00745
00756 class __EXPORT ReusableAllocator : protected Conditional
00757 {
00758 protected:
00759 ReusableObject *freelist;
00760 unsigned waiting;
00761
00765 ReusableAllocator();
00766
00772 inline ReusableObject *next(ReusableObject *object)
00773 {return object->getNext();};
00774
00779 void release(ReusableObject *object);
00780 };
00781
00792 class __EXPORT ConditionalLock : protected ConditionalAccess, public Shared
00793 {
00794 private:
00795 class Context : public LinkedObject
00796 {
00797 public:
00798 inline Context(LinkedObject **root) : LinkedObject(root) {};
00799
00800 pthread_t thread;
00801 unsigned count;
00802 };
00803
00804 LinkedObject *contexts;
00805
00806 __LOCAL void Shlock(void);
00807 __LOCAL void Unlock(void);
00808 __LOCAL void Exclusive(void);
00809 __LOCAL void Share(void);
00810 __LOCAL Context *getContext(void);
00811
00812 public:
00816 ConditionalLock();
00817
00821 ~ConditionalLock();
00822
00826 void modify(void);
00827
00831 void commit(void);
00832
00836 void access(void);
00837
00841 void release(void);
00842
00847 void exclusive(void);
00848
00852 void share(void);
00853
00857 unsigned getReaders(void);
00858
00862 unsigned getWaiters(void);
00863
00868 inline static void modify(ConditionalLock& lock)
00869 {lock.modify();};
00870
00875 inline static void commit(ConditionalLock& lock)
00876 {lock.commit();};
00877
00882 inline static void release(ConditionalLock& lock)
00883 {lock.release();};
00884
00889 inline static void access(ConditionalLock& lock)
00890 {lock.access();};
00891
00896 inline static void exclusive(ConditionalLock& lock)
00897 {lock.exclusive();};
00898
00903 inline static void share(ConditionalLock& lock)
00904 {lock.share();};
00905 };
00906
00919 class __EXPORT barrier : private Conditional
00920 {
00921 private:
00922 unsigned count;
00923 unsigned waits;
00924
00925 public:
00930 barrier(unsigned count);
00931
00935 ~barrier();
00936
00942 void set(unsigned count);
00943
00947 void inc(void);
00948
00953 unsigned operator++(void);
00954
00958 void wait(void);
00959
00966 bool wait(timeout_t timeout);
00967
00972 inline static void wait(barrier& sync)
00973 {sync.wait();};
00974
00981 inline static bool wait(barrier& sync, timeout_t timeout)
00982 {return sync.wait(timeout);};
00983
00984
00990 inline static void set(barrier& sync, unsigned count)
00991 {sync.set(count);};
00992 };
00993
01002 class __EXPORT semaphore : public Shared, private Conditional
01003 {
01004 private:
01005 unsigned count, waits, used;
01006
01007 __LOCAL void Shlock(void);
01008 __LOCAL void Unlock(void);
01009
01010 public:
01014 semaphore(unsigned count = 0);
01015
01020 void wait(void);
01021
01029 bool wait(timeout_t timeout);
01030
01035 unsigned getCount(void);
01036
01041 unsigned getUsed(void);
01042
01047 void set(unsigned count);
01048
01052 void release(void);
01053
01057 inline void operator++(void)
01058 {wait();};
01059
01063 inline void operator--(void)
01064 {release();};
01065
01070 inline static void wait(semaphore& sync)
01071 {sync.wait();};
01072
01079 inline static bool wait(semaphore& sync, timeout_t timeout)
01080 {return sync.wait(timeout);};
01081
01086 inline static void release(semaphore& sync)
01087 {sync.release();};
01088 };
01089
01103 class __EXPORT mutex : public Exclusive
01104 {
01105 private:
01106 pthread_mutex_t mlock;
01107
01108 __LOCAL void Exlock(void);
01109 __LOCAL void Unlock(void);
01110
01111 public:
01119 class __EXPORT gaurd
01120 {
01121 private:
01122 void *object;
01123
01124 public:
01129 gaurd();
01130
01135 gaurd(void *object);
01136
01140 ~gaurd();
01141
01147 void set(void *object);
01148
01152 void release(void);
01153
01159 inline void operator=(void *pointer)
01160 {set(pointer);};
01161 };
01162
01163
01167 mutex();
01168
01172 ~mutex();
01173
01177 inline void acquire(void)
01178 {pthread_mutex_lock(&mlock);};
01179
01183 inline void lock(void)
01184 {pthread_mutex_lock(&mlock);};
01185
01189 inline void unlock(void)
01190 {pthread_mutex_unlock(&mlock);};
01191
01195 inline void release(void)
01196 {pthread_mutex_unlock(&mlock);};
01197
01202 inline static void acquire(mutex& lock)
01203 {pthread_mutex_lock(&lock.mlock);};
01204
01209 inline static void lock(mutex& lock)
01210 {pthread_mutex_lock(&lock.mlock);};
01211
01216 inline static void unlock(mutex& lock)
01217 {pthread_mutex_unlock(&lock.mlock);};
01218
01223 inline static void release(mutex& lock)
01224 {pthread_mutex_unlock(&lock.mlock);};
01225
01230 inline static void acquire(pthread_mutex_t *lock)
01231 {pthread_mutex_lock(lock);};
01232
01237 inline static void lock(pthread_mutex_t *lock)
01238 {pthread_mutex_lock(lock);};
01239
01244 inline static void unlock(pthread_mutex_t *lock)
01245 {pthread_mutex_unlock(lock);};
01246
01251 inline static void release(pthread_mutex_t *lock)
01252 {pthread_mutex_unlock(lock);};
01253
01260 static void indexing(unsigned size);
01261
01267 static void protect(void *pointer);
01268
01273 static void release(void *pointer);
01274 };
01275
01284 class __EXPORT auto_protect
01285 {
01286 private:
01287
01288 inline auto_protect(const auto_pointer &pointer) {};
01289
01290 protected:
01291 void *object;
01292
01293 auto_protect();
01294
01295 public:
01300 auto_protect(void *object);
01301
01306 ~auto_protect();
01307
01311 void release(void);
01312
01317 inline bool operator!() const
01318 {return object == NULL;};
01319
01324 inline operator bool() const
01325 {return object != NULL;};
01326
01333 void operator=(void *object);
01334 };
01335
01347 class __EXPORT LockedPointer
01348 {
01349 private:
01350 friend class locked_release;
01351 pthread_mutex_t mutex;
01352 Object *pointer;
01353
01354 protected:
01358 LockedPointer();
01359
01364 void replace(Object *object);
01365
01370 Object *dup(void);
01371
01376 inline void operator=(Object *object)
01377 {replace(object);};
01378 };
01379
01388 class __EXPORT SharedObject
01389 {
01390 protected:
01391 friend class SharedPointer;
01392
01401 virtual void commit(SharedPointer *pointer);
01402
01403 public:
01407 virtual ~SharedObject();
01408 };
01409
01420 class __EXPORT SharedPointer : protected ConditionalAccess
01421 {
01422 private:
01423 friend class shared_release;
01424 SharedObject *pointer;
01425
01426 protected:
01430 SharedPointer();
01431
01435 ~SharedPointer();
01436
01443 void replace(SharedObject *object);
01444
01451 SharedObject *share(void);
01452 };
01453
01464 class __EXPORT Thread
01465 {
01466 protected:
01467 pthread_t tid;
01468 size_t stack;
01469 int priority;
01470
01476 Thread(size_t stack = 0);
01477
01478 public:
01485 void setPriority(void);
01486
01491 static void yield(void);
01492
01497 static void sleep(timeout_t timeout);
01498
01502 virtual void run(void) = 0;
01503
01507 virtual ~Thread();
01508
01517 virtual void exit(void);
01518
01522 static void init(void);
01523
01529 static void policy(int polid);
01530
01535 static void concurrency(int level);
01536
01543 static bool equal(pthread_t thread1, pthread_t thread2);
01544
01549 #ifdef __PTH__
01550 inline static pthread_t self(void)
01551 {return pth_self();};
01552 #else
01553 inline static pthread_t self(void)
01554 {return pthread_self();};
01555 #endif
01556 };
01557
01568 class __EXPORT JoinableThread : protected Thread
01569 {
01570 private:
01571 #ifdef _MSWINDOWS_
01572 HANDLE joining;
01573 #else
01574 volatile bool running;
01575 #endif
01576
01577 protected:
01582 JoinableThread(size_t size = 0);
01583
01588 virtual ~JoinableThread();
01589
01595 void join(void);
01596
01597 public:
01598 #ifdef _MSWINDOWS_
01599 inline bool isRunning(void)
01600 {return (joining != INVALID_HANDLE_VALUE);};
01601 #else
01602
01606 inline bool isRunning(void)
01607 {return running;};
01608 #endif
01609
01618 void start(int priority = 0);
01619
01624 inline void background(void)
01625 {start(-1);};
01626 };
01627
01635 class __EXPORT DetachedThread : protected Thread
01636 {
01637 protected:
01642 DetachedThread(size_t size = 0);
01643
01649 ~DetachedThread();
01650
01659 void exit(void);
01660
01661 public:
01668 void start(int priority = 0);
01669 };
01670
01681 class __EXPORT queue : protected OrderedIndex, protected Conditional
01682 {
01683 private:
01684 mempager *pager;
01685 LinkedObject *freelist;
01686 size_t used;
01687
01688 class __LOCAL member : public OrderedObject
01689 {
01690 public:
01691 member(queue *q, Object *obj);
01692 Object *object;
01693 };
01694
01695 friend class member;
01696
01697 protected:
01698 size_t limit;
01699
01700 public:
01708 queue(mempager *pager = NULL, size_t number = 0);
01709
01713 ~queue();
01714
01722 bool remove(Object *object);
01723
01732 bool post(Object *object, timeout_t timeout = 0);
01733
01741 Object *fifo(timeout_t timeout = 0);
01742
01750 Object *lifo(timeout_t timeout = 0);
01751
01756 size_t getCount(void);
01757
01764 static bool remove(queue& queue, Object *object)
01765 {return queue.remove(object);};
01766
01774 static bool post(queue& queue, Object *object, timeout_t timeout = 0)
01775 {return queue.post(object, timeout);};
01776
01783 static Object *fifo(queue& queue, timeout_t timeout = 0)
01784 {return queue.fifo(timeout);};
01785
01792 static Object *lifo(queue& queue, timeout_t timeout = 0)
01793 {return queue.lifo(timeout);};
01794
01800 static size_t count(queue& queue)
01801 {return queue.getCount();};
01802 };
01803
01812 class __EXPORT stack : protected Conditional
01813 {
01814 private:
01815 LinkedObject *freelist, *usedlist;
01816 mempager *pager;
01817 size_t used;
01818
01819 class __LOCAL member : public LinkedObject
01820 {
01821 public:
01822 member(stack *s, Object *obj);
01823 Object *object;
01824 };
01825
01826 friend class member;
01827
01828 protected:
01829 size_t limit;
01830
01831 public:
01838 stack(mempager *pager = NULL, size_t number = 0);
01839
01843 ~stack();
01844
01852 bool remove(Object *object);
01853
01862 bool push(Object *object, timeout_t timeout = 0);
01863
01871 Object *pull(timeout_t timeout = 0);
01872
01877 size_t getCount(void);
01878
01885 static inline bool remove(stack& stack, Object *object)
01886 {return stack.remove(object);};
01887
01895 static inline bool push(stack& stack, Object *object, timeout_t timeout = 0)
01896 {return stack.push(object, timeout);};
01897
01904 static inline Object *pull(stack& stack, timeout_t timeout = 0)
01905 {return stack.pull(timeout);};
01906
01912 static inline size_t count(stack& stack)
01913 {return stack.getCount();};
01914 };
01915
01925 class __EXPORT Buffer : protected Conditional
01926 {
01927 private:
01928 size_t size, objsize;
01929 caddr_t buf, head, tail;
01930 unsigned count, limit;
01931
01932 public:
01938 Buffer(size_t size, size_t count);
01939
01943 virtual ~Buffer();
01944
01949 unsigned getSize(void);
01950
01955 unsigned getCount(void);
01956
01962 void *get(timeout_t timeout);
01963
01969 void *get(void);
01970
01976 void put(void *data);
01977
01984 bool put(void *data, timeout_t timeout);
01985
01992 void release(void);
01993
01999 void copy(void *data);
02000
02007 bool copy(void *data, timeout_t timeout);
02008
02013 operator bool();
02014
02019 bool operator!();
02020 };
02021
02030 class __EXPORT locked_release
02031 {
02032 protected:
02033 Object *object;
02038 locked_release();
02039
02045 locked_release(const locked_release &object);
02046
02047 public:
02053 locked_release(LockedPointer &pointer);
02054
02059 ~locked_release();
02060
02064 void release(void);
02065
02071 locked_release &operator=(LockedPointer &pointer);
02072 };
02073
02083 class __EXPORT shared_release
02084 {
02085 protected:
02086 SharedPointer *ptr;
02091 shared_release();
02092
02098 shared_release(const shared_release &object);
02099
02100 public:
02105 shared_release(SharedPointer &pointer);
02106
02112 ~shared_release();
02113
02117 void release(void);
02118
02123 SharedObject *get(void);
02124
02130 shared_release &operator=(SharedPointer &pointer);
02131 };
02132
02140 template<class T>
02141 class queueof : public queue
02142 {
02143 public:
02149 inline queueof(mempager *memory, size_t size = 0) : queue(memory, size) {};
02150
02158 inline bool remove(T *object)
02159 {return queue::remove(object);};
02160
02169 inline bool post(T *object, timeout_t timeout = 0)
02170 {return queue::post(object);};
02171
02179 inline T *fifo(timeout_t timeout = 0)
02180 {return static_cast<T *>(queue::fifo(timeout));};
02181
02189 inline T *lifo(timeout_t timeout = 0)
02190 {return static_cast<T *>(queue::lifo(timeout));};
02191 };
02192
02200 template<class T>
02201 class stackof : public stack
02202 {
02203 public:
02209 inline stackof(mempager *memory, size_t size = 0) : stack(memory, size) {};
02210
02218 inline bool remove(T *object)
02219 {return stack::remove(object);};
02220
02229 inline bool push(T *object, timeout_t timeout = 0)
02230 {return stack::push(object);};
02231
02239 inline T *pull(timeout_t timeout = 0)
02240 {return static_cast<T *>(stack::pull(timeout));};
02241 };
02242
02254 template<class T>
02255 class bufferof : public Buffer
02256 {
02257 public:
02262 inline bufferof(unsigned count) :
02263 Buffer(sizeof(T), count) {};
02264
02270 inline T *get(void)
02271 {return static_cast<T*>(get());};
02272
02278 inline T *get(timeout_t timeout)
02279 {return static_cast<T*>(get(timeout));};
02280
02286 inline void put(T *object)
02287 {put(object);};
02288
02295 inline bool put(T *object, timeout_t timeout)
02296 {return put(object, timeout);};
02297
02303 inline void copy(T *object)
02304 {copy(object);};
02305
02312 inline bool get(T *object, timeout_t timeout)
02313 {return copy(object, timeout);};
02314 };
02315
02323 template<class T>
02324 class shared_pointer : public SharedPointer
02325 {
02326 public:
02330 inline shared_pointer() : SharedPointer() {};
02331
02339 inline const T *dup(void)
02340 {return static_cast<const T*>(SharedPointer::share());};
02341
02348 inline void replace(T *object)
02349 {SharedPointer::replace(object);};
02350
02355 inline void operator=(T *object)
02356 {replace(object);};
02357
02362 inline T *operator*()
02363 {return dup();};
02364 };
02365
02373 template<class T>
02374 class locked_pointer : public LockedPointer
02375 {
02376 public:
02380 inline locked_pointer() : LockedPointer() {};
02381
02387 inline T* dup(void)
02388 {return static_cast<T *>(LockedPointer::dup());};
02389
02394 inline void replace(T *object)
02395 {LockedPointer::replace(object);};
02396
02401 inline void operator=(T *object)
02402 {replace(object);};
02403
02409 inline T *operator*()
02410 {return dup();};
02411 };
02412
02418 template<class T>
02419 class locked_instance : public locked_release
02420 {
02421 public:
02425 inline locked_instance() : locked_release() {};
02426
02431 inline locked_instance(locked_pointer<T> &pointer) : locked_release(pointer) {};
02432
02437 inline T& operator*() const
02438 {return *(static_cast<T *>(object));};
02439
02444 inline T* operator->() const
02445 {return static_cast<T*>(object);};
02446
02451 inline T* get(void) const
02452 {return static_cast<T*>(object);};
02453 };
02454
02460 template<class T>
02461 class shared_instance : public shared_release
02462 {
02463 public:
02467 inline shared_instance() : shared_release() {};
02468
02474 inline shared_instance(shared_pointer<T> &pointer) : shared_release(pointer) {};
02475
02479 inline const T& operator*() const
02480 {return *(static_cast<const T *>(ptr->pointer));};
02481
02486 inline const T* operator->() const
02487 {return static_cast<const T*>(ptr->pointer);};
02488
02493 inline const T* get(void) const
02494 {return static_cast<const T*>(ptr->pointer);};
02495 };
02496
02503 template <class T>
02504 class mutex_pointer : public auto_protect
02505 {
02506 public:
02510 inline mutex_pointer() : auto_protect() {};
02511
02516 inline mutex_pointer(T* object) : auto_protect(object) {};
02517
02522 inline T& operator*() const
02523 {return *(static_cast<T*>(auto_protect::object));};
02524
02529 inline T* operator->() const
02530 {return static_cast<T*>(auto_protect::object);};
02531
02536 inline T* get(void) const
02537 {return static_cast<T*>(auto_protect::object);};
02538 };
02539
02545 inline void start(JoinableThread *thread, int priority = 0)
02546 {thread->start(priority);}
02547
02553 inline void start(DetachedThread *thread, int priority = 0)
02554 {thread->start(priority);}
02555
02559 typedef ConditionalLock condlock_t;
02560
02564 typedef ConditionalAccess accesslock_t;
02565
02569 typedef TimedEvent timedevent_t;
02570
02574 typedef mutex mutex_t;
02575
02580 typedef mutex Mutex;
02581
02585 typedef rwlock rwlock_t;
02586
02590 typedef rexlock rexlock_t;
02591
02595 typedef semaphore semaphore_t;
02596
02600 typedef barrier barrier_t;
02601
02605 typedef stack stack_t;
02606
02610 typedef queue fifo_t;
02611
02616 inline void wait(barrier_t &barrier)
02617 {barrier.wait();}
02618
02624 inline void wait(semaphore_t &semaphore, timeout_t timeout = Timer::inf)
02625 {semaphore.wait(timeout);}
02626
02631 inline void release(semaphore_t &semaphore)
02632 {semaphore.release();}
02633
02638 inline void acquire(mutex_t &mutex)
02639 {mutex.lock();}
02640
02645 inline void release(mutex_t &mutex)
02646 {mutex.release();}
02647
02652 inline void modify(accesslock_t &lock)
02653 {lock.modify();}
02654
02659 inline void access(accesslock_t &lock)
02660 {lock.access();}
02661
02666 inline void release(accesslock_t &lock)
02667 {lock.release();}
02668
02674 inline void commit(accesslock_t &lock)
02675 {lock.commit();}
02676
02681 inline void exclusive(condlock_t &lock)
02682 {lock.exclusive();}
02683
02688 inline void share(condlock_t &lock)
02689 {lock.share();}
02690
02695 inline void modify(condlock_t &lock)
02696 {lock.modify();}
02697
02703 inline void commit(condlock_t &lock)
02704 {lock.commit();}
02705
02710 inline void access(condlock_t &lock)
02711 {lock.access();}
02712
02717 inline void release(condlock_t &lock)
02718 {lock.release();}
02719
02725 inline bool exclusive(rwlock_t &lock, timeout_t timeout = Timer::inf)
02726 {return lock.modify(timeout);}
02727
02733 inline bool share(rwlock_t &lock, timeout_t timeout = Timer::inf)
02734 {return lock.access(timeout);}
02735
02740 inline void release(rwlock_t &lock)
02741 {lock.release();}
02742
02747 inline void lock(rexlock_t &lock)
02748 {lock.lock();}
02749
02754 inline void release(rexlock_t &lock)
02755 {lock.release();}
02756
02762 inline void push(stack_t &stack, Object *object)
02763 {stack.push(object);}
02764
02771 inline Object *pull(stack_t &stack, timeout_t timeout = Timer::inf)
02772 {return stack.pull(timeout);}
02773
02779 inline void remove(stack_t &stack, Object *object)
02780 {stack.remove(object);}
02781
02787 inline void push(fifo_t &fifo, Object *object)
02788 {fifo.post(object);}
02789
02796 inline Object *pull(fifo_t &fifo, timeout_t timeout = Timer::inf)
02797 {return fifo.fifo(timeout);}
02798
02804 inline void remove(fifo_t &fifo, Object *object)
02805 {fifo.remove(object);}
02806
02807 END_NAMESPACE
02808
02809 #define ENTER_EXCLUSIVE \
02810 do { static pthread_mutex_t __sync__ = PTHREAD_MUTEX_INITIALIZER; \
02811 pthread_mutex_lock(&__sync__);
02812
02813 #define LEAVE_EXCLUSIVE \
02814 pthread_mutex_unlock(&__sync__);} while(0);
02815
02816 #endif