00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00041 #ifndef _UCOMMON_THREAD_H_
00042 #define _UCOMMON_THREAD_H_
00043
00044 #ifndef _UCOMMON_ACCESS_H_
00045 #include <ucommon/access.h>
00046 #endif
00047
00048 #ifndef _UCOMMON_TIMERS_H_
00049 #include <ucommon/timers.h>
00050 #endif
00051
00052 #ifndef _UCOMMON_MEMORY_H_
00053 #include <ucommon/memory.h>
00054 #endif
00055
00056 NAMESPACE_UCOMMON
00057
00058 class SharedPointer;
00059
00070 class __EXPORT Conditional
00071 {
00072 private:
00073 friend class ConditionalAccess;
00074
00075 #ifdef _MSWINDOWS_
00076 enum {SIGNAL = 0, BROADCAST = 1};
00077 HANDLE events[2];
00078 unsigned waiting;
00079 CRITICAL_SECTION mlock;
00080 CRITICAL_SECTION mutex;
00081 #else
00082 #ifndef __PTH__
00083 class __LOCAL attribute
00084 {
00085 public:
00086 pthread_condattr_t attr;
00087 attribute();
00088 };
00089
00090 __LOCAL static attribute attr;
00091 #endif
00092
00093 pthread_cond_t cond;
00094 pthread_mutex_t mutex;
00095 #endif
00096
00097 protected:
00098 friend class TimedEvent;
00099
00105 bool wait(timeout_t timeout);
00106
00112 bool wait(struct timespec *timeout);
00113
00114 #ifdef _MSWINDOWS_
00115 inline void lock(void)
00116 {EnterCriticalSection(&mutex);};
00117
00118 inline void unlock(void)
00119 {LeaveCriticalSection(&mutex);};
00120
00121 void wait(void);
00122 void signal(void);
00123 void broadcast(void);
00124
00125 #else
00126
00129 inline void lock(void)
00130 {pthread_mutex_lock(&mutex);};
00131
00135 inline void unlock(void)
00136 {pthread_mutex_unlock(&mutex);};
00137
00141 inline void wait(void)
00142 {pthread_cond_wait(&cond, &mutex);};
00143
00147 inline void signal(void)
00148 {pthread_cond_signal(&cond);};
00149
00153 inline void broadcast(void)
00154 {pthread_cond_broadcast(&cond);};
00155 #endif
00156
00160 Conditional();
00161
00165 ~Conditional();
00166
00167 public:
00168 #if !defined(_MSWINDOWS_) && !defined(__PTH__)
00169
00174 static inline pthread_condattr_t *initializer(void)
00175 {return &attr.attr;};
00176 #endif
00177
00184 static void gettimeout(timeout_t timeout, struct timespec *hires);
00185 };
00186
00194 class __EXPORT ConditionalAccess : private Conditional
00195 {
00196 private:
00197 #ifndef _MSWINDOWS_
00198 pthread_cond_t bcast;
00199 #endif
00200
00201 protected:
00202 unsigned pending, waiting, sharing;
00203
00209 bool waitSignal(timeout_t timeout);
00210
00216 bool waitBroadcast(timeout_t timeout);
00217
00218
00224 bool waitSignal(struct timespec *timeout);
00225
00231 bool waitBroadcast(struct timespec *timeout);
00232
00239 inline static void gettimeout(timeout_t timeout, struct timespec *hires)
00240 {Conditional::gettimeout(timeout, hires);};
00241
00242
00243 #ifdef _MSWINDOWS_
00244 inline void lock(void)
00245 {EnterCriticalSection(&mutex);};
00246
00247 inline void unlock(void)
00248 {LeaveCriticalSection(&mutex);};
00249
00250 void waitSignal(void);
00251 void waitBroadcast(void);
00252
00253 inline void signal(void)
00254 {Conditional::signal();};
00255
00256 inline void broadcast(void)
00257 {Conditional::broadcast();};
00258
00259 #else
00260
00263 inline void lock(void)
00264 {pthread_mutex_lock(&mutex);};
00265
00269 inline void unlock(void)
00270 {pthread_mutex_unlock(&mutex);};
00271
00275 inline void waitSignal(void)
00276 {pthread_cond_wait(&cond, &mutex);};
00277
00281 inline void waitBroadcast(void)
00282 {pthread_cond_wait(&bcast, &mutex);};
00283
00284
00288 inline void signal(void)
00289 {pthread_cond_signal(&cond);};
00290
00294 inline void broadcast(void)
00295 {pthread_cond_broadcast(&bcast);};
00296 #endif
00297 public:
00301 ConditionalAccess();
00302
00306 ~ConditionalAccess();
00307
00311 void access(void);
00312
00316 void modify(void);
00317
00321 void release(void);
00322
00326 void commit(void);
00327
00334 void limit_sharing(unsigned max);
00335 };
00336
00345 class __EXPORT TimedEvent : public Timer
00346 {
00347 private:
00348 #ifdef _MSWINDOWS_
00349 HANDLE event;
00350 #else
00351 pthread_cond_t cond;
00352 bool signalled;
00353 #endif
00354 pthread_mutex_t mutex;
00355
00356 protected:
00361 void lock(void);
00362
00367 void release(void);
00368
00376 bool sync(void);
00377
00378 public:
00382 TimedEvent(void);
00383
00388 TimedEvent(timeout_t timeout);
00389
00394 TimedEvent(time_t timeout);
00395
00399 ~TimedEvent();
00400
00406 void signal(void);
00407
00414 bool wait(timeout_t timeout);
00415
00419 void reset(void);
00420
00425 inline static void signal(TimedEvent& timed)
00426 {timed.signal();};
00427
00432 inline static void reset(TimedEvent& timed)
00433 {timed.reset();};
00434
00441 inline static bool wait(TimedEvent& timed, timeout_t timeout)
00442 {return timed.wait(timeout);};
00443 };
00444
00452 class __EXPORT rexlock : private Conditional, public Exclusive
00453 {
00454 private:
00455 unsigned waiting;
00456 unsigned lockers;
00457 pthread_t locker;
00458
00459 __LOCAL void Exlock(void);
00460 __LOCAL void Unlock(void);
00461
00462 public:
00466 rexlock();
00467
00471 void lock(void);
00472
00476 void release(void);
00477
00482 unsigned getLocking(void);
00483
00488 unsigned getWaiting(void);
00489
00494 inline static void lock(rexlock& rex)
00495 {rex.lock();};
00496
00501 inline static void release(rexlock& rex)
00502 {rex.release();};
00503 };
00504
00517 class __EXPORT rwlock : private ConditionalAccess, public Exclusive, public Shared
00518 {
00519 private:
00520 unsigned writers;
00521 pthread_t writeid;
00522
00523 __LOCAL void Exlock(void);
00524 __LOCAL void Shlock(void);
00525 __LOCAL void Unlock(void);
00526
00527 public:
00535 class __EXPORT gaurd_reader
00536 {
00537 private:
00538 void *object;
00539
00540 public:
00545 gaurd_reader();
00546
00551 gaurd_reader(void *object);
00552
00556 ~gaurd_reader();
00557
00563 void set(void *object);
00564
00568 void release(void);
00569
00575 inline void operator=(void *pointer)
00576 {set(pointer);};
00577 };
00578
00586 class __EXPORT gaurd_writer
00587 {
00588 private:
00589 void *object;
00590
00591 public:
00596 gaurd_writer();
00597
00602 gaurd_writer(void *object);
00603
00607 ~gaurd_writer();
00608
00614 void set(void *object);
00615
00619 void release(void);
00620
00626 inline void operator=(void *pointer)
00627 {set(pointer);};
00628 };
00629
00633 rwlock();
00634
00640 bool modify(timeout_t timeout = Timer::inf);
00641
00647 bool access(timeout_t timeout = Timer::inf);
00648
00655 static void indexing(unsigned size);
00656
00664 static bool writer(void *object, timeout_t timeout = Timer::inf);
00665
00673 static bool reader(void *object, timeout_t timeout = Timer::inf);
00674
00679 static void release(void *object);
00680
00684 void release(void);
00685
00690 unsigned getAccess(void);
00691
00696 unsigned getModify(void);
00697
00702 unsigned getWaiting(void);
00703
00710 inline static bool modify(rwlock& lock, timeout_t timeout = Timer::inf)
00711 {return lock.modify(timeout);};
00712
00719 inline static bool access(rwlock& lock, timeout_t timeout = Timer::inf)
00720 {return lock.access(timeout);};
00721
00726 inline static void release(rwlock& lock)
00727 {lock.release();};
00728 };
00729
00740 class __EXPORT ReusableAllocator : protected Conditional
00741 {
00742 protected:
00743 ReusableObject *freelist;
00744 unsigned waiting;
00745
00749 ReusableAllocator();
00750
00756 inline ReusableObject *next(ReusableObject *object)
00757 {return object->getNext();};
00758
00763 void release(ReusableObject *object);
00764 };
00765
00776 class __EXPORT ConditionalLock : protected ConditionalAccess, public Shared
00777 {
00778 private:
00779 class Context : public LinkedObject
00780 {
00781 public:
00782 inline Context(LinkedObject **root) : LinkedObject(root) {};
00783
00784 pthread_t thread;
00785 unsigned count;
00786 };
00787
00788 LinkedObject *contexts;
00789
00790 __LOCAL void Shlock(void);
00791 __LOCAL void Unlock(void);
00792 __LOCAL void Exclusive(void);
00793 __LOCAL void Share(void);
00794 __LOCAL Context *getContext(void);
00795
00796 public:
00800 ConditionalLock();
00801
00805 ~ConditionalLock();
00806
00810 void modify(void);
00811
00815 void commit(void);
00816
00820 void access(void);
00821
00825 void release(void);
00826
00831 void exclusive(void);
00832
00836 void share(void);
00837
00841 unsigned getReaders(void);
00842
00846 unsigned getWaiters(void);
00847
00852 inline static void modify(ConditionalLock& lock)
00853 {lock.modify();};
00854
00859 inline static void commit(ConditionalLock& lock)
00860 {lock.commit();};
00861
00866 inline static void release(ConditionalLock& lock)
00867 {lock.release();};
00868
00873 inline static void access(ConditionalLock& lock)
00874 {lock.access();};
00875
00880 inline static void exclusive(ConditionalLock& lock)
00881 {lock.exclusive();};
00882
00887 inline static void share(ConditionalLock& lock)
00888 {lock.share();};
00889 };
00890
00903 class __EXPORT barrier : private Conditional
00904 {
00905 private:
00906 unsigned count;
00907 unsigned waits;
00908
00909 public:
00914 barrier(unsigned count);
00915
00919 ~barrier();
00920
00926 void set(unsigned count);
00927
00931 void wait(void);
00932
00939 bool wait(timeout_t timeout);
00940
00945 inline static void wait(barrier& sync)
00946 {sync.wait();};
00947
00954 inline static bool wait(barrier& sync, timeout_t timeout)
00955 {return sync.wait(timeout);};
00956
00957
00963 inline static void set(barrier& sync, unsigned count)
00964 {sync.set(count);};
00965 };
00966
00975 class __EXPORT semaphore : public Shared, private Conditional
00976 {
00977 private:
00978 unsigned count, waits, used;
00979
00980 __LOCAL void Shlock(void);
00981 __LOCAL void Unlock(void);
00982
00983 public:
00987 semaphore(unsigned count = 0);
00988
00993 void wait(void);
00994
01002 bool wait(timeout_t timeout);
01003
01008 unsigned getCount(void);
01009
01014 unsigned getUsed(void);
01015
01020 void set(unsigned count);
01021
01025 void release(void);
01026
01030 inline void operator++(void)
01031 {wait();};
01032
01036 inline void operator--(void)
01037 {release();};
01038
01043 inline static void wait(semaphore& sync)
01044 {sync.wait();};
01045
01052 inline static bool wait(semaphore& sync, timeout_t timeout)
01053 {return sync.wait(timeout);};
01054
01059 inline static void release(semaphore& sync)
01060 {sync.release();};
01061 };
01062
01076 class __EXPORT mutex : public Exclusive
01077 {
01078 private:
01079 pthread_mutex_t mlock;
01080
01081 __LOCAL void Exlock(void);
01082 __LOCAL void Unlock(void);
01083
01084 public:
01092 class __EXPORT gaurd
01093 {
01094 private:
01095 void *object;
01096
01097 public:
01102 gaurd();
01103
01108 gaurd(void *object);
01109
01113 ~gaurd();
01114
01120 void set(void *object);
01121
01125 void release(void);
01126
01132 inline void operator=(void *pointer)
01133 {set(pointer);};
01134 };
01135
01136
01140 mutex();
01141
01145 ~mutex();
01146
01150 inline void acquire(void)
01151 {pthread_mutex_lock(&mlock);};
01152
01156 inline void lock(void)
01157 {pthread_mutex_lock(&mlock);};
01158
01162 inline void unlock(void)
01163 {pthread_mutex_unlock(&mlock);};
01164
01168 inline void release(void)
01169 {pthread_mutex_unlock(&mlock);};
01170
01175 inline static void acquire(mutex& lock)
01176 {pthread_mutex_lock(&lock.mlock);};
01177
01182 inline static void lock(mutex& lock)
01183 {pthread_mutex_lock(&lock.mlock);};
01184
01189 inline static void unlock(mutex& lock)
01190 {pthread_mutex_unlock(&lock.mlock);};
01191
01196 inline static void release(mutex& lock)
01197 {pthread_mutex_unlock(&lock.mlock);};
01198
01203 inline static void acquire(pthread_mutex_t *lock)
01204 {pthread_mutex_lock(lock);};
01205
01210 inline static void lock(pthread_mutex_t *lock)
01211 {pthread_mutex_lock(lock);};
01212
01217 inline static void unlock(pthread_mutex_t *lock)
01218 {pthread_mutex_unlock(lock);};
01219
01224 inline static void release(pthread_mutex_t *lock)
01225 {pthread_mutex_unlock(lock);};
01226
01233 static void indexing(unsigned size);
01234
01240 static void protect(void *pointer);
01241
01246 static void release(void *pointer);
01247 };
01248
01257 class __EXPORT auto_protect
01258 {
01259 private:
01260
01261 inline auto_protect(const auto_pointer &pointer) {};
01262
01263 protected:
01264 void *object;
01265
01266 auto_protect();
01267
01268 public:
01273 auto_protect(void *object);
01274
01279 ~auto_protect();
01280
01284 void release(void);
01285
01290 inline bool operator!() const
01291 {return object == NULL;};
01292
01297 inline operator bool() const
01298 {return object != NULL;};
01299
01306 void operator=(void *object);
01307 };
01308
01320 class __EXPORT LockedPointer
01321 {
01322 private:
01323 friend class locked_release;
01324 pthread_mutex_t mutex;
01325 Object *pointer;
01326
01327 protected:
01331 LockedPointer();
01332
01337 void replace(Object *object);
01338
01343 Object *dup(void);
01344
01349 inline void operator=(Object *object)
01350 {replace(object);};
01351 };
01352
01361 class __EXPORT SharedObject
01362 {
01363 protected:
01364 friend class SharedPointer;
01365
01374 virtual void commit(SharedPointer *pointer);
01375
01376 public:
01380 virtual ~SharedObject();
01381 };
01382
01393 class __EXPORT SharedPointer : protected ConditionalAccess
01394 {
01395 private:
01396 friend class shared_release;
01397 SharedObject *pointer;
01398
01399 protected:
01403 SharedPointer();
01404
01408 ~SharedPointer();
01409
01416 void replace(SharedObject *object);
01417
01424 SharedObject *share(void);
01425 };
01426
01437 class __EXPORT Thread
01438 {
01439 protected:
01440 pthread_t tid;
01441 size_t stack;
01442 int priority;
01443
01449 Thread(size_t stack = 0);
01450
01451 public:
01458 void setPriority(void);
01459
01464 static void yield(void);
01465
01470 static void sleep(timeout_t timeout);
01471
01475 virtual void run(void) = 0;
01476
01480 virtual ~Thread();
01481
01490 virtual void exit(void);
01491
01495 static void init(void);
01496
01502 static void policy(int polid);
01503
01508 static void concurrency(int level);
01509
01516 static bool equal(pthread_t thread1, pthread_t thread2);
01517
01522 #ifdef __PTH__
01523 inline static pthread_t self(void)
01524 {return pth_self();};
01525 #else
01526 inline static pthread_t self(void)
01527 {return pthread_self();};
01528 #endif
01529 };
01530
01541 class __EXPORT JoinableThread : protected Thread
01542 {
01543 private:
01544 #ifdef _MSWINDOWS_
01545 HANDLE joining;
01546 #else
01547 volatile bool running;
01548 #endif
01549
01550 protected:
01555 JoinableThread(size_t size = 0);
01556
01561 virtual ~JoinableThread();
01562
01568 void join(void);
01569
01570 public:
01571 #ifdef _MSWINDOWS_
01572 inline bool isRunning(void)
01573 {return (joining != INVALID_HANDLE_VALUE);};
01574 #else
01575
01579 inline bool isRunning(void)
01580 {return running;};
01581 #endif
01582
01591 void start(int priority = 0);
01592
01597 inline void background(void)
01598 {start(-1);};
01599 };
01600
01608 class __EXPORT DetachedThread : protected Thread
01609 {
01610 protected:
01615 DetachedThread(size_t size = 0);
01616
01622 ~DetachedThread();
01623
01632 void exit(void);
01633
01634 public:
01641 void start(int priority = 0);
01642 };
01643
01654 class __EXPORT queue : protected OrderedIndex, protected Conditional
01655 {
01656 private:
01657 mempager *pager;
01658 LinkedObject *freelist;
01659 size_t used;
01660
01661 class __LOCAL member : public OrderedObject
01662 {
01663 public:
01664 member(queue *q, Object *obj);
01665 Object *object;
01666 };
01667
01668 friend class member;
01669
01670 protected:
01671 size_t limit;
01672
01673 public:
01681 queue(mempager *pager = NULL, size_t number = 0);
01682
01686 ~queue();
01687
01695 bool remove(Object *object);
01696
01705 bool post(Object *object, timeout_t timeout = 0);
01706
01714 Object *fifo(timeout_t timeout = 0);
01715
01723 Object *lifo(timeout_t timeout = 0);
01724
01729 size_t getCount(void);
01730
01737 static bool remove(queue& queue, Object *object)
01738 {return queue.remove(object);};
01739
01747 static bool post(queue& queue, Object *object, timeout_t timeout = 0)
01748 {return queue.post(object, timeout);};
01749
01756 static Object *fifo(queue& queue, timeout_t timeout = 0)
01757 {return queue.fifo(timeout);};
01758
01765 static Object *lifo(queue& queue, timeout_t timeout = 0)
01766 {return queue.lifo(timeout);};
01767
01773 static size_t count(queue& queue)
01774 {return queue.getCount();};
01775 };
01776
01785 class __EXPORT stack : protected Conditional
01786 {
01787 private:
01788 LinkedObject *freelist, *usedlist;
01789 mempager *pager;
01790 size_t used;
01791
01792 class __LOCAL member : public LinkedObject
01793 {
01794 public:
01795 member(stack *s, Object *obj);
01796 Object *object;
01797 };
01798
01799 friend class member;
01800
01801 protected:
01802 size_t limit;
01803
01804 public:
01811 stack(mempager *pager = NULL, size_t number = 0);
01812
01816 ~stack();
01817
01825 bool remove(Object *object);
01826
01835 bool push(Object *object, timeout_t timeout = 0);
01836
01844 Object *pull(timeout_t timeout = 0);
01845
01850 size_t getCount(void);
01851
01858 static inline bool remove(stack& stack, Object *object)
01859 {return stack.remove(object);};
01860
01868 static inline bool push(stack& stack, Object *object, timeout_t timeout = 0)
01869 {return stack.push(object, timeout);};
01870
01877 static inline Object *pull(stack& stack, timeout_t timeout = 0)
01878 {return stack.pull(timeout);};
01879
01885 static inline size_t count(stack& stack)
01886 {return stack.getCount();};
01887 };
01888
01898 class __EXPORT Buffer : protected Conditional
01899 {
01900 private:
01901 size_t size, objsize;
01902 caddr_t buf, head, tail;
01903 unsigned count, limit;
01904
01905 public:
01911 Buffer(size_t size, size_t count);
01912
01916 virtual ~Buffer();
01917
01922 unsigned getSize(void);
01923
01928 unsigned getCount(void);
01929
01935 void *get(timeout_t timeout);
01936
01942 void *get(void);
01943
01949 void put(void *data);
01950
01957 bool put(void *data, timeout_t timeout);
01958
01965 void release(void);
01966
01972 void copy(void *data);
01973
01980 bool copy(void *data, timeout_t timeout);
01981
01986 operator bool();
01987
01992 bool operator!();
01993 };
01994
02003 class __EXPORT locked_release
02004 {
02005 protected:
02006 Object *object;
02011 locked_release();
02012
02018 locked_release(const locked_release &object);
02019
02020 public:
02026 locked_release(LockedPointer &pointer);
02027
02032 ~locked_release();
02033
02037 void release(void);
02038
02044 locked_release &operator=(LockedPointer &pointer);
02045 };
02046
02056 class __EXPORT shared_release
02057 {
02058 protected:
02059 SharedPointer *ptr;
02064 shared_release();
02065
02071 shared_release(const shared_release &object);
02072
02073 public:
02078 shared_release(SharedPointer &pointer);
02079
02085 ~shared_release();
02086
02090 void release(void);
02091
02096 SharedObject *get(void);
02097
02103 shared_release &operator=(SharedPointer &pointer);
02104 };
02105
02113 template<class T, mempager *P = NULL>
02114 class queueof : public queue
02115 {
02116 public:
02121 inline queueof(size_t size = 0) : queue(P, size) {};
02122
02130 inline bool remove(T *object)
02131 {return queue::remove(object);};
02132
02141 inline bool post(T *object, timeout_t timeout = 0)
02142 {return queue::post(object);};
02143
02151 inline T *fifo(timeout_t timeout = 0)
02152 {return static_cast<T *>(queue::fifo(timeout));};
02153
02161 inline T *lifo(timeout_t timeout = 0)
02162 {return static_cast<T *>(queue::lifo(timeout));};
02163 };
02164
02172 template<class T, mempager *P = NULL>
02173 class stackof : public stack
02174 {
02175 public:
02180 inline stackof(size_t size = 0) : stack(P, size) {};
02181
02189 inline bool remove(T *object)
02190 {return stack::remove(object);};
02191
02200 inline bool push(T *object, timeout_t timeout = 0)
02201 {return stack::push(object);};
02202
02210 inline T *pull(timeout_t timeout = 0)
02211 {return static_cast<T *>(stack::pull(timeout));};
02212 };
02213
02225 template<class T>
02226 class bufferof : public Buffer
02227 {
02228 public:
02233 inline bufferof(unsigned count) :
02234 Buffer(sizeof(T), count) {};
02235
02241 inline T *get(void)
02242 {return static_cast<T*>(get());};
02243
02249 inline T *get(timeout_t timeout)
02250 {return static_cast<T*>(get(timeout));};
02251
02257 inline void put(T *object)
02258 {put(object);};
02259
02266 inline bool put(T *object, timeout_t timeout)
02267 {return put(object, timeout);};
02268
02274 inline void copy(T *object)
02275 {copy(object);};
02276
02283 inline bool get(T *object, timeout_t timeout)
02284 {return copy(object, timeout);};
02285 };
02286
02294 template<class T>
02295 class shared_pointer : public SharedPointer
02296 {
02297 public:
02301 inline shared_pointer() : SharedPointer() {};
02302
02310 inline const T *dup(void)
02311 {return static_cast<const T*>(SharedPointer::share());};
02312
02319 inline void replace(T *object)
02320 {SharedPointer::replace(object);};
02321
02326 inline void operator=(T *object)
02327 {replace(object);};
02328
02333 inline T *operator*()
02334 {return dup();};
02335 };
02336
02344 template<class T>
02345 class locked_pointer : public LockedPointer
02346 {
02347 public:
02351 inline locked_pointer() : LockedPointer() {};
02352
02358 inline T* dup(void)
02359 {return static_cast<T *>(LockedPointer::dup());};
02360
02365 inline void replace(T *object)
02366 {LockedPointer::replace(object);};
02367
02372 inline void operator=(T *object)
02373 {replace(object);};
02374
02380 inline T *operator*()
02381 {return dup();};
02382 };
02383
02389 template<class T>
02390 class locked_instance : public locked_release
02391 {
02392 public:
02396 inline locked_instance() : locked_release() {};
02397
02402 inline locked_instance(locked_pointer<T> &pointer) : locked_release(pointer) {};
02403
02408 inline T& operator*() const
02409 {return *(static_cast<T *>(object));};
02410
02415 inline T* operator->() const
02416 {return static_cast<T*>(object);};
02417
02422 inline T* get(void) const
02423 {return static_cast<T*>(object);};
02424 };
02425
02431 template<class T>
02432 class shared_instance : public shared_release
02433 {
02434 public:
02438 inline shared_instance() : shared_release() {};
02439
02445 inline shared_instance(shared_pointer<T> &pointer) : shared_release(pointer) {};
02446
02450 inline const T& operator*() const
02451 {return *(static_cast<const T *>(ptr->pointer));};
02452
02457 inline const T* operator->() const
02458 {return static_cast<const T*>(ptr->pointer);};
02459
02464 inline const T* get(void) const
02465 {return static_cast<const T*>(ptr->pointer);};
02466 };
02467
02474 template <class T>
02475 class mutex_pointer : public auto_protect
02476 {
02477 public:
02481 inline mutex_pointer() : auto_protect() {};
02482
02487 inline mutex_pointer(T* object) : auto_protect(object) {};
02488
02493 inline T& operator*() const
02494 {return *(static_cast<T*>(auto_protect::object));};
02495
02500 inline T* operator->() const
02501 {return static_cast<T*>(auto_protect::object);};
02502
02507 inline T* get(void) const
02508 {return static_cast<T*>(auto_protect::object);};
02509 };
02510
02516 inline void start(JoinableThread *thread, int priority = 0)
02517 {thread->start(priority);}
02518
02524 inline void start(DetachedThread *thread, int priority = 0)
02525 {thread->start(priority);}
02526
02530 typedef ConditionalLock condlock_t;
02531
02535 typedef ConditionalAccess accesslock_t;
02536
02540 typedef TimedEvent timedevent_t;
02541
02545 typedef mutex mutex_t;
02546
02551 typedef mutex Mutex;
02552
02556 typedef rwlock rwlock_t;
02557
02561 typedef rexlock rexlock_t;
02562
02566 typedef semaphore semaphore_t;
02567
02571 typedef barrier barrier_t;
02572
02576 typedef stack stack_t;
02577
02581 typedef queue fifo_t;
02582
02587 inline void wait(barrier_t &barrier)
02588 {barrier.wait();}
02589
02595 inline void wait(semaphore_t &semaphore, timeout_t timeout = Timer::inf)
02596 {semaphore.wait(timeout);}
02597
02602 inline void release(semaphore_t &semaphore)
02603 {semaphore.release();}
02604
02609 inline void acquire(mutex_t &mutex)
02610 {mutex.lock();}
02611
02616 inline void release(mutex_t &mutex)
02617 {mutex.release();}
02618
02623 inline void modify(accesslock_t &lock)
02624 {lock.modify();}
02625
02630 inline void access(accesslock_t &lock)
02631 {lock.access();}
02632
02637 inline void release(accesslock_t &lock)
02638 {lock.release();}
02639
02645 inline void commit(accesslock_t &lock)
02646 {lock.commit();}
02647
02652 inline void exclusive(condlock_t &lock)
02653 {lock.exclusive();}
02654
02659 inline void share(condlock_t &lock)
02660 {lock.share();}
02661
02666 inline void modify(condlock_t &lock)
02667 {lock.modify();}
02668
02674 inline void commit(condlock_t &lock)
02675 {lock.commit();}
02676
02681 inline void access(condlock_t &lock)
02682 {lock.access();}
02683
02688 inline void release(condlock_t &lock)
02689 {lock.release();}
02690
02696 inline bool exclusive(rwlock_t &lock, timeout_t timeout = Timer::inf)
02697 {return lock.modify(timeout);}
02698
02704 inline bool share(rwlock_t &lock, timeout_t timeout = Timer::inf)
02705 {return lock.access(timeout);}
02706
02711 inline void release(rwlock_t &lock)
02712 {lock.release();}
02713
02718 inline void lock(rexlock_t &lock)
02719 {lock.lock();}
02720
02725 inline void release(rexlock_t &lock)
02726 {lock.release();}
02727
02733 inline void push(stack_t &stack, Object *object)
02734 {stack.push(object);}
02735
02742 inline Object *pull(stack_t &stack, timeout_t timeout = Timer::inf)
02743 {return stack.pull(timeout);}
02744
02750 inline void remove(stack_t &stack, Object *object)
02751 {stack.remove(object);}
02752
02758 inline void push(fifo_t &fifo, Object *object)
02759 {fifo.post(object);}
02760
02767 inline Object *pull(fifo_t &fifo, timeout_t timeout = Timer::inf)
02768 {return fifo.fifo(timeout);}
02769
02775 inline void remove(fifo_t &fifo, Object *object)
02776 {fifo.remove(object);}
02777
02778 END_NAMESPACE
02779
02780 #define ENTER_EXCLUSIVE \
02781 do { static pthread_mutex_t __sync__ = PTHREAD_MUTEX_INITIALIZER; \
02782 pthread_mutex_lock(&__sync__);
02783
02784 #define LEAVE_EXCLUSIVE \
02785 pthread_mutex_unlock(&__sync__);} while(0);
02786
02787 #endif