#ifndef THREADS_H
#define THREADS_H
/////////////////////////////////////////////////////////////////////
//  threads.h     -   class supporting creation of threads         //
//  ver 2.0                                                        //
//  Language:         Visual C++, ver 6.0, SP 5                    //
//  Platform:         Dell Dimension 8100, Win 2000 Pro, SP 2      //
//  Application:      CSE691/791 - SWM&A Demonstration             //
//  Author:           Jim Fawcett, CST 2-187, Syracuse Univ        //
//                    (315) 443-3948, jfawcett@twcny.rr.com        //
//                                                                 //
/////////////////////////////////////////////////////////////////////
/*
    Module Operations
    =================
    The class thread encapsulates creation of Win32 threads.  To
    construct a thread object, you will first need to create a class
    derived from the processing class, declared in this header file,
    and pass it to the thread constructor.

    Each derived processing class must provide a public run() function
    that defines the operations that the thread is expected to carry
    out.  The test stub in the accompanying implementation file shows
    how to define classes derived from processing.

    Public Interface
    ================
    class myProc : public processing { ... }
    myProc proc;              // create a processing object
    thread t(proc);           // create a thread object
    t.start();                // create running Win32 thread
    t.restart();              // create another running Win32 thread
    t.wait();                 // wait for thread to complete
    t.sleep(50);              // number of milliseconds to sleep
    t.canSuspend(false);      // set false just before thread acquires lock
    t.canSuspend(true);       // set true just after thread releases lock
    t.suspend();              // suspend thread operation
    t.resume();               // resume thread operation
    HANDLE th = t.handle();   // return Win32 thread handle

//

///////////////////////////////////////////////////////////////////////
//  Build Process                                                    //
///////////////////////////////////////////////////////////////////////
//  Required Files:                                                  //
//    threads.h, threads.cpp, lockingPtr.h, lockingPtr.cpp,          //
//    sysUtils.h, sysUtils.cpp                                       //
//                                                                   //
//  Compiler Command:                                                //
//    cl /GX /DTEST_THREADS threads.cpp lockingPtr.cpp sysUtils.cpp  //
//                                                                   //
///////////////////////////////////////////////////////////////////////
/*
    Maintenance History
    ===================
    ver 3.0 : 12 Feb 02
      - pulled thread
    ver 2.1 : 18 Nov 01
      - added setPriority() and alive() member functions
    ver 2.0 : 10 Nov 2001
      - added procWithQ class, providing queuing services for its thread
    ver 1,2 : 05 Nov 01
      - made processing class abstract
      - provided fixes to the manual page
    ver 1.1 : 28 Oct 01
      - added missing file names to Build Process comments
    ver 1.0 : 26 Oct 01
      - first release

*/

//

#include <process.h>
#include <windows.h>

/////////////////////////////////////////////////////////////////////
//  thread processing interface declaration

class processing {

  public:
    virtual ~processing() {}
    virtual void run()=0;
};

/////////////////////////////////////////////////////////////////////
//  thread class declaration

class thread {

  public:
    enum priority { low, normal, high };
    thread(processing &proc);
    virtual ~thread();
    void start();
    void restart();
    void wait();
    void canSuspend(bool b=true);   // set false if thread holds a lock
    bool suspend();                 // otherwise thread may deadlock
    void resume();
    void sleep(int MilliSec);
    void setPriority(priority pr);
    bool alive();
    HANDLE handle();

  protected:
    processing &_proc;
    HANDLE th;
    unsigned int threadID;
    static unsigned int __stdcall threadProc(void *pSelf);
    bool _canSuspend;
    bool _alive;
};

//

//----< constructor >------------------------------------------------
//
//  only self terminate if created on heap - will delete this;
//
inline thread::thread(processing &proc) : _proc(proc) { }

//----< return thread handle >---------------------------------------

inline HANDLE thread::handle() { return th; }

//----< increment suspend count >------------------------------------
//
//  puts thread to sleep if not already asleep
//
inline bool thread::suspend() { 
  
  if(_canSuspend) {
    ::SuspendThread(th);
  }
  return _canSuspend;
}

//----< decrement suspend count >------------------------------------
//
//  if count is zero, make thread schedualable
//
inline void thread::resume() { ::ResumeThread(th); }

//----< put thread to sleep for t milliseconds >---------------------

inline void thread::sleep(int t) { ::Sleep(t); }

//----< is thread locked? >------------------------------------------

inline void thread::canSuspend(bool b) { _canSuspend = b; }

#endif