MSThreads.hh

Go to the documentation of this file.

/*
 * MSThreads.hh
 *
 * Copyright 2002, LifeLine Networks BV (www.lifeline.nl). All rights reserved.
 * Copyright 2002, Bastiaan Bakker. All rights reserved.
 *
 * See the COPYING file for the terms of usage and distribution.
 */
 
#ifndef _LOG4CPP_THREADING_MSTHREADS_HH
#define _LOG4CPP_THREADING_MSTHREADS_HH
 
#include <string>
 
// deal with ERROR #define
// N.B. This #includes windows.h with NOGDI and WIN32_LEAN_AND_MEAN #defined.
//      If this is not what the user wants, #include windows.h before this file.
#ifndef _WINDOWS_
#  ifndef NOGDI
#    define NOGDI  // this will circumvent the ERROR #define in windows.h
#    define LOG4CPP_UNDEFINE_NOGDI
#  endif
 
#  ifndef WIN32_LEAN_AND_MEAN
#    define WIN32_LEAN_AND_MEAN
#    define LOG4CPP_UNDEFINE_WIN32_LEAN_AND_MEAN
#  endif
 
#  include <windows.h>
 
#  ifdef LOG4CPP_UNDEFINE_NOGDI
#    undef NOGDI
#  endif
 
#  ifdef LOG4CPP_UNDEFINE_WIN32_LEAN_AND_MEAN
#    undef WIN32_LEAN_AND_MEAN
#  endif
 
#endif // done dealing with ERROR #define
 
namespace log4cpp {
    namespace threading {
        std::string getThreadId();
        
        class LOG4CPP_EXPORT MSMutex {
            public:
            MSMutex() { InitializeCriticalSection(&_criticalSection); }
            ~MSMutex() { DeleteCriticalSection(&_criticalSection); }
            inline LPCRITICAL_SECTION getCriticalSection() {
                return &_criticalSection;
            }
 
            private:
            MSMutex(const MSMutex& other);
            CRITICAL_SECTION _criticalSection;
        };

        typedef MSMutex Mutex;

        class MSScopedLock {
            public:
            MSScopedLock(MSMutex& mutex) {
                _criticalSection = mutex.getCriticalSection();
                EnterCriticalSection(_criticalSection);
            }
 
            ~MSScopedLock() { LeaveCriticalSection(_criticalSection); }
 
            private:
            MSScopedLock(const MSScopedLock& other);
            LPCRITICAL_SECTION _criticalSection;
        };

        typedef MSScopedLock ScopedLock;

        template<typename T> class ThreadLocalDataHolder {
            public:
            inline ThreadLocalDataHolder() :
                _key(TlsAlloc()) {};
 
            inline ~ThreadLocalDataHolder() { TlsFree(_key); };
            
            inline T* get() const {
                return (T*)TlsGetValue(_key);
            };

            inline T* operator->() const { return get(); };

            inline T& operator*() const { return *get(); };

            inline T* release() {
                T* result = (T*)TlsGetValue(_key);
                TlsSetValue(_key, NULL);
                return result;
            };

            inline void reset(T* p = NULL) {
                T* thing = (T*)TlsGetValue(_key);
                delete thing;
                TlsSetValue(_key, p);
            };
 
            private:            
            DWORD _key;            
        };
    }
}
#endif