sync_wrapper.hpp

#ifndef SYNC_WRAPPER_H_BY_DAVID_MAISONAVE_HEADER_GUARD_
#define SYNC_WRAPPER_H_BY_DAVID_MAISONAVE_HEADER_GUARD_

#include <stdlib.h>

#ifdef _WIN32
template<class T>
class mutex_wrapper : public T
{
        HANDLE m_hndl;
        inline void lock(){WaitForSingleObject(m_hndl, INFINITE);}
        inline void unlock(){ReleaseMutex(m_hndl);}
        mutex_wrapper& operator=(const mutex_wrapper&);
public:
        inline mutex_wrapper():m_hndl(CreateMutex(NULL, FALSE, NULL)){}
        template<class T1> mutex_wrapper(T1& t1):T(t1), m_hndl(CreateMutex(NULL, FALSE, NULL)){}
        template<class T1, class T2> mutex_wrapper(T1& t1, T2& t2):T(t1, t2), m_hndl(CreateMutex(NULL, FALSE, NULL)){}
        template<class T1, class T2, class T3> mutex_wrapper(T1& t1, T2& t2, T3& t3):T(t1, t2, t3), m_hndl(CreateMutex(NULL, FALSE, NULL)){}
        inline ~mutex_wrapper()
        {
                ReleaseMutex(m_hndl);
                CloseHandle(m_hndl);
        }
        inline friend void intrusive_ptr_lock(mutex_wrapper<T> *p){p->lock();}
        inline friend void intrusive_ptr_unlock(mutex_wrapper<T> *p){p->unlock();}
};

template<class T>
class critical_sect_wrapper : public T
{
        CRITICAL_SECTION m_cs;
        inline void lock(){EnterCriticalSection(&m_cs);}
        inline void unlock(){LeaveCriticalSection(&m_cs);}
        critical_sect_wrapper& operator=(const critical_sect_wrapper&);
public:
        inline critical_sect_wrapper(){InitializeCriticalSection(&m_cs);}
        template<class T1> critical_sect_wrapper(T1& t1):T(t1){InitializeCriticalSection(&m_cs);}
        template<class T1, class T2> critical_sect_wrapper(T1& t1, T2& t2):T(t1, t2){InitializeCriticalSection(&m_cs);}
        template<class T1, class T2, class T3> critical_sect_wrapper(T1& t1, T2& t2, T3& t3):T(t1, t2, t3){InitializeCriticalSection(&m_cs);}
        inline ~critical_sect_wrapper(){DeleteCriticalSection(&m_cs);}
        inline friend void intrusive_ptr_lock(critical_sect_wrapper *p){p->lock();}
        inline friend void intrusive_ptr_unlock(critical_sect_wrapper *p){p->unlock();}
};

template<class T>
class fast_mutex_wrapper : public T
{
        LONG volatile  locker;
        void lock()
        {
                // check if another thread already locked
                while (InterlockedIncrement(&locker) > 1)
                {
                        InterlockedDecrement(&locker);
                        Sleep(rand()%3);   // sleep 0 to 2 milliseconds before next attempt
                }
        }      
        inline void unlock(){assert (locker > 0);InterlockedDecrement(&locker);}
        fast_mutex_wrapper& operator=(const fast_mutex_wrapper&);
public:
        inline fast_mutex_wrapper():locker(0){}
        template<class T1> fast_mutex_wrapper(T1& t1):T(t1), locker(0){}
        template<class T1, class T2> fast_mutex_wrapper(T1& t1, T2& t2):T(t1, t2), locker(0){}
        template<class T1, class T2, class T3> fast_mutex_wrapper(T1& t1, T2& t2, T3& t3):T(t1, t2, t3), locker(0){}
        inline friend void intrusive_ptr_lock(fast_mutex_wrapper *p){p->lock();}
        inline friend void intrusive_ptr_unlock(fast_mutex_wrapper *p){p->unlock();}
};

#else
#ifdef __POSIX__
template<class T>
class mutex_wrapper : public T
{
        pthread_mutex_t m_mutex;
        inline void lock(){pthread_mutex_lock(&m_mutex);}
        inline void unlock(){pthread_mutex_unlock(&m_mutex);}
        mutex_wrapper& operator=(const mutex_wrapper&);
public:
        inline mutex_wrapper():m_mutex(PTHREAD_MUTEX_INITIALIZER){}
        template<class T1> mutex_wrapper(T1& t1):T(t1), m_mutex(PTHREAD_MUTEX_INITIALIZER){}
        template<class T1, class T2> mutex_wrapper(T1& t1, T2& t2):T(t1, t2), m_mutex(PTHREAD_MUTEX_INITIALIZER){}
        template<class T1, class T2, class T3> mutex_wrapper(T1& t1, T2& t2, T3& t3):T(t1, t2, t3), m_mutex(PTHREAD_MUTEX_INITIALIZER){}
        inline ~mutex_wrapper(){pthread_mutex_destroy(&m_mutex);}
        inline friend void intrusive_ptr_lock(mutex_wrapper *p){p->lock();}
        inline friend void intrusive_ptr_unlock(mutex_wrapper *p){p->unlock();}
};
#endif //__POSIX__
#endif //_WIN32

template <typename TT> void unlock_function_for_scope_lock(TT *  ptr) {
        if (!ptr) return;
        ptr->unlock();
} 

class scope_lock
{
        typedef void (*unlock_fct_Type ) (void *);
        unlock_fct_Type m_unlock_fct;
        void *m_type;
public:
        template<class T> scope_lock(T& smrtPtr, bool LockIt = true):m_type((void*)&smrtPtr)
        {
                if (LockIt) smrtPtr.lock();
                void ( *tmp ) (T *) = unlock_function_for_scope_lock<T>;
                m_unlock_fct = (unlock_fct_Type)tmp;
        }
        ~scope_lock()
        {
                m_unlock_fct(m_type);
        }
};


#endif //SYNC_WRAPPER_H_BY_DAVID_MAISONAVE_HEADER_GUARD_

---