home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 November / VPR9611B.ISO / vabasic / ntclnt.exe / DISK8 / data.8 / datab / INCLUDE / NOMT.HH < prev    next >
Text File  |  1996-07-29  |  6KB  |  181 lines
  1. //==========================================================================//
  2. //     $Source: /rcs/crcs/general/nomt.hh,v $
  3. //     Checked in by: $Author: alaind $
  4. //     $Date: 1996/04/17 17:50:55 $
  5. //     $Revision: 1.3 $
  6. //--------------------------------------------------------------------------//
  7. //                                            //
  8. //         Copyright (c) 1995, Visual Edge Software Ltd.                //
  9. //                                        //
  10. //     All rights reserved.  This notice is  intended  as  a  precaution    //
  11. //     against    inadvertent publication, and shall not be deemed to con-    //
  12. //     stitute an acknowledgment that publication has  occurred     nor  to    //
  13. //     imply  any  waiver  of confidentiality.    The year included in the    //
  14. //     notice is the year of the creation of the work.                //
  15. //                                        //
  16. //----------------------------------------------------------------------------
  17. // DESCRIPTION:                                                             
  18. //
  19. //  VeThread is a class which manage threads in a multithread environment.   
  20. // A Thread have a state and a priority.                                    
  21. // Create a thread with the constructor, just initialize some properties.   
  22. // The Start method create the real system thread and keep a pointer on it. 
  23. // A thread can also suspend is execution and Resume it.                    
  24. //
  25. //  VeThreadEvent manage events on threads. An event is used to synchronize 
  26. // the threads. An event have two state: signaled and unsignaled.
  27. // When the event is nsignaled, all the thread blocked on this event,
  28. // will wait until the event be signaled. The event is signaled by an other 
  29. // thread when a specific condition is satisfied.
  30. //
  31. //  VeLock is a class that is used to synchronize threads who shared the same
  32. // data. It is done by locking a code section, and this allow only one thread
  33. // to execute the code in this section. As long the lock is own by a thread
  34. // all others threads who want to access the same code section will be waiting
  35. // 
  36. // VeLock can be overlapped. If in the same code section a VeLock is locked 
  37. // many times (overlapped locks)a, while all the lock acquired are not 
  38. // released, the VeLock will still locked.
  39. // If a thread ends, all the locks locked by this thread will be unlocked.
  40. //
  41. //  VeAutoLock is a class that assures a locked VeLock object that it will be
  42. // unlocked. This is done by using the destructor which do the unlock 
  43. // operation.
  44. //
  45. //  VeRefCnt is a thread-safe reference counting class. The increment and 
  46. // decrement of the object are atomic, because they use a mecanism for 
  47. // synchronizing access to a variable that is shared by multiple threads.
  48. //
  49. //  Note: This file is for non multithread support plateform.
  50. //      It should be included only by vthread.hh
  51. //==========================================================================//
  52.  
  53. #ifndef NOMT_HH
  54. #define NOMT_HH
  55.  
  56. //=========================================================================
  57. // VeThread - A thread class
  58. //-------------------------------------------------------------------------
  59. VCLASS VeThread : public VeDllBasedClass
  60. {
  61.     public:
  62.     VOPERDECL VeThread();
  63.     VOPERDECL ~VeThread();
  64.  
  65.     VMETHODDECL(status_t) Start( VTThreadFunction startRoutine,
  66.                      void *arg,
  67.                      bool_t suspended,
  68.                      long stackSize=0);
  69.     VMETHODDECL(status_t) Stop();
  70.     VMETHODDECL(status_t) PutPriority(VTThreadPriority newPrio);
  71.     VMETHODDECL(VTThreadPriority) Priority();
  72.     VMETHODDECL(VTThreadState) State();
  73.     VMETHODDECL(status_t) Suspend();
  74.     VMETHODDECL(status_t) Resume();
  75. };
  76.  
  77. //=========================================================================
  78. // VeThreadEvent - A event thread class
  79. //-------------------------------------------------------------------------
  80. VCLASS VeThreadEvent : public VeDllBasedClass
  81. {
  82.     public:
  83.     VOPERDECL VeThreadEvent();
  84.     VOPERDECL ~VeThreadEvent();
  85.  
  86.     VMETHODDECL(status_t) Wait();
  87.     VMETHODDECL(status_t) Trigger();
  88. };
  89.  
  90. //=========================================================================
  91. // VeLock - A thread locking class
  92. //-------------------------------------------------------------------------
  93. VCLASS VeLock : public VeDllBasedClass
  94. {
  95.     public:
  96.     VINLINEDECL(status_t) Acquire();
  97.     VINLINEDECL(status_t) Release();
  98. };
  99.  
  100. //=========================================================================
  101. // VeAutoLock - A thread Auto-locking class
  102. //-------------------------------------------------------------------------
  103. VCLASS VeAutoLock : public VeDllBasedClass
  104. {
  105.     public:
  106.     VINLINEOPERDECL VeAutoLock(VeLock& );
  107.     VINLINEOPERDECL VeAutoLock(VeLock* );
  108. };
  109.  
  110. //=========================================================================
  111. // VeRefCount - A thread-safe reference counting class
  112. //-------------------------------------------------------------------------
  113. VCLASS VeRefCount : public VeDllBasedClass
  114. {    
  115.     public: 
  116.     VINLINEOPERDECL VeRefCount();
  117.  
  118.     VINLINEDECL(void) operator++();
  119.     VINLINEDECL(void) operator++(int);
  120.     VINLINEDECL(bool_t) operator--();
  121.     VINLINEDECL(void) operator--(int);
  122.     VINLINEDECL(bool_t) IsReferenced();
  123.     VINLINEDECL(void) Initialize(long value);
  124.     VINLINEDECL(long) Value();
  125.                 
  126.     private:
  127.     long itsValue;
  128. };
  129.  
  130. //-------------------------------------------------------------------------
  131. // inline methods
  132. //-------------------------------------------------------------------------
  133. VINLINEDEF(status_t) VeLock::Acquire()
  134. { return OKStatus; }
  135.  
  136. VINLINEDEF(status_t) VeLock::Release()
  137. { return OKStatus; }
  138.  
  139. VINLINEOPERDEF VeAutoLock::VeAutoLock(VeLock& )
  140. {}
  141. VINLINEOPERDEF VeAutoLock::VeAutoLock(VeLock* )
  142. {}
  143.  
  144. VINLINEOPERDEF VeRefCount::VeRefCount()
  145. { itsValue = 0; }
  146.  
  147. VINLINEDEF(void) VeRefCount::operator++()
  148. { ++itsValue; }
  149.  
  150. VINLINEDEF(void) VeRefCount::operator++(int)
  151. { itsValue++; }
  152.  
  153. VINLINEDEF(bool_t) VeRefCount::operator--()
  154. { 
  155.     --itsValue; 
  156.     if (itsValue > 0) return TRUE;
  157.     else return FALSE;
  158. }
  159.  
  160. VINLINEDEF(void) VeRefCount::operator--(int)
  161. { itsValue--; }
  162.  
  163. VINLINEDEF(bool_t) VeRefCount::IsReferenced()
  164. {
  165.     if (itsValue > 0) return TRUE;
  166.     else return FALSE;
  167. }
  168.  
  169. VINLINEDEF(void) VeRefCount::Initialize(long value)
  170. {
  171.     itsValue = value;
  172. }
  173.  
  174. VINLINEDEF(long) VeRefCount::Value()
  175. {
  176.     return itsValue;
  177. }
  178.  
  179. #endif    // NOMT_HH
  180.  
  181.