home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

threading.h

Go to the documentation of this file.

/*
 * Copyright © 2001-2002 Sofus Mortensen, Mikael Lindgren
 *
 * This material is provided "as is", with absolutely no warranty 
 * expressed or implied. Any use is at your own risk. Permission to 
 * use or copy this software for any purpose is hereby granted without 
 * fee, provided the above notices are retained on all copies. 
 * Permission to modify the code and to distribute modified code is 
 * granted, provided the above notices are retained, and a notice that 
 * the code was modified is included with the above copyright notice. 
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#ifndef COMET_THREADING_H
#define COMET_THREADING_H

#include <comet/config.h>
#include <comet/handle.h>

#include <comet/error.h>

namespace comet {

class critical_section {
public:
        critical_section()  { 
                ::InitializeCriticalSection(&cs_); 
        }
        
        ~critical_section() { 
                ::DeleteCriticalSection(&cs_); 
        }
        
        void enter() const { 
                ::EnterCriticalSection(&cs_); 
        }
        
        void leave() const { 
                ::LeaveCriticalSection(&cs_); 
        }
        
private:
        critical_section(const critical_section&);
        critical_section& operator=(const critical_section&);

        mutable CRITICAL_SECTION cs_;
};

class auto_cs {
public:
        explicit auto_cs(const critical_section& cs) : cs_(cs) {
                cs_.enter();
        }
        
        ~auto_cs() {
                cs_.leave();
        }
        
private:
        auto_cs& operator=(const auto_cs&);
        auto_cs(const auto_cs&);

        const critical_section& cs_;
};

template <typename T> class locking_ptr {
public:
        locking_ptr(volatile T& obj, critical_section& cs)      : 
          pointer_(const_cast<T*>(&obj)), 
          cs_(cs)
        {    
                  cs_.enter();
        }

        ~locking_ptr()
        {    
                cs_.leave();  
        }

        T& operator*()
        {    
                return *pointer_;    
        }

        T* operator->()
        {   
                return pointer_;   
        }

private:
        T* pointer_;
        critical_section& cs_;

        locking_ptr(const locking_ptr&);
        locking_ptr& operator=(const locking_ptr&);
};

class thread
{
private:
        DWORD id_;
        auto_handle     handle_;

        // declare non-copyable
        thread(const& thread);
        thread& operator=(const& thread);
public:
        thread() : id_(0)
        {}

        const auto_handle& start()
        {
                handle_ = auto_attach(::CreateThread(0, 0, &thread::start_proc, this, 0, &id_));
                return handle_;
        }

        const auto_handle& handle() const
        {
                return handle_;
        }

        void exit(DWORD exit_code)
        {
                ::ExitThread(exit_code);
        }

        void suspend()
        {
                ::SuspendThread(handle_);
        }

        void resume()
        {
                ::ResumeThread(handle_);
        }

        bool running()
        {
                DWORD code;
                return handle_ && 
                                        ::GetExitCodeThread(handle_, &code) && 
                                        code == STILL_ACTIVE;
        }

        bool wait(DWORD timeout = INFINITE)
        {
                return ::WaitForSingleObject(handle_, timeout) == WAIT_OBJECT_0;
        }

private:
        static DWORD _stdcall start_proc(void* param)
        {
                return static_cast<thread*>(param)->thread_main();
        }

        virtual DWORD thread_main() = 0;
};

class event
{
private:
        auto_handle     handle_;

        // declare non-copyable
        event(const& event);
        event& operator=(const& event);
public:
        explicit event(bool initial_state = false)
        {
                handle_ = auto_attach(::CreateEvent(0, false, initial_state, 0));
        }

        explicit event(const TCHAR* name, bool initial_state = false)
        {
                handle_ = auto_attach(::CreateEvent(0, false, initial_state, name));
        }

        void set()
        {
                if (0 == ::SetEvent(handle_))
                {
                        DWORD err = GetLastError();
                        raise_exception(HRESULT_FROM_WIN32(err));
                }
        }

        void reset()
        {
                if (0==::ResetEvent(handle_) )
                {
                        DWORD err = GetLastError();
                        raise_exception(HRESULT_FROM_WIN32(err));
                }
        }       
        
        bool wait(DWORD timeout = INFINITE)
        {
                return ::WaitForSingleObject(handle_, timeout) == WAIT_OBJECT_0;
        }

        bool is_set()
        {
                return ::WaitForSingleObject(handle_, 0) == WAIT_OBJECT_0;
        }

        operator HANDLE() const 
        { return handle_; }
};

}

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.