wefts_os_windows.h

Go to the documentation of this file.

/*
   wefts_os_widnows.h
   MS-Windows specific header file

   $Id: wefts_os_windows.h,v 1.15 2004/03/28 21:45:40 jonnymind Exp $
---------------------------------------
   Begin      : 2003-10-15 16.50
   Author     : Giancarlo Niccolai

   Last modified because:
   
*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/

#ifndef WT_OS_WINDOWS_H
#define WT_OS_WINDOWS_H

/* To allow compilation of TryEnterCriticalSection */
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400
#endif

#ifdef _MSC_VER
#pragma warning ( disable:4355 )
#endif

#include <wefts_cleanup.h>
#include <wefts_os_base.h>
#include <wefts_error.h>


#ifdef __extern_c
extern "C" {
#endif

#include <windows.h>

#ifdef __extern_c
}
#endif

namespace Wefts {

extern DWORD s_tlsThreadObj;

extern void (* s_cleanerPointer)(void *);

class OSMutexWindows: public OSMutexBase 
{
   bool m_canTryLock;
protected:
   CRITICAL_SECTION  m_sect;

   friend class OSConditionWindows;
public:
   OSMutexWindows() throw( InitError );
   
   ~OSMutexWindows() 
   { 
      DeleteCriticalSection( &m_sect );
   }

   virtual inline void lock() { EnterCriticalSection( &m_sect ); }

   virtual inline bool trylock() { 
      if( m_canTryLock )
         return TryEnterCriticalSection( &m_sect ) == TRUE; 
      else
         return false;
   }

   virtual inline void unlock() { LeaveCriticalSection( &m_sect ); }
};

#if 0
class OSMutexWindows: public OSMutexBase {
protected:
   CRITICAL_SECTION  m_sema;

   friend class OSConditionWindows;
public:
   OSMutexWindows() throw( InitError )
      : OSMutexBase()
   {
      InitializeCriticalSection(&m_sema);
      //if ( m_sema == NULL ) throw InitError( GetLastError() );
   }

   ~OSMutexWindows() 
   { 
      DeleteCriticalSection( &m_sema );
   }

   virtual inline void lock() { EnterCriticalSection( &m_sema); }

   virtual inline bool trylock() { 
      OSVERSIONINFO osVer;
      osVer.dwOSVersionInfoSize = sizeof( osVer );

      if( GetVersionEx( &osVer ) && 
            ( osVer.dwPlatformId == VER_PLATFORM_WIN32_NT || osVer.dwMajorVersion >= 5 )
         return TryEnterCriticalSection( &m_sema); 
      else
         return false;
   }

   virtual inline void unlock() { LeaveCriticalSection(&m_sema); }
};
#endif

class OSConditionWindows: public OSConditionBase {
private:
   HANDLE semBlockLock;
   HANDLE semBlockQueue;
   CRITICAL_SECTION mtxUnblockLock;
   int nWaitersGone;
   int nWaitersBlocked;
   int nWaitersToUnblock;

public:
   OSConditionWindows() throw( InitError );
   ~OSConditionWindows(); 

   void signal();
   void signalOne();
   
   bool wait( OSMutexBase &mtx, CleanupItem &guard ); 

   bool timedWait( OSMutexBase &mtx, long seconds, long nanoseconds,
         CleanupItem &guard  );
};

class OSThreadWindows: public OSThreadBase {
private:
   DWORD m_thid;
   
   HANDLE m_hth;
   
   bool m_valid;

   HANDLE m_evtCancel;

   bool m_wasCanceled;
      
   bool m_canCancel;
   
   void (*m_rawCleanup)(void *);
   
   void *m_rawCleanData;
   
   friend class OSConditionWindows;
   friend class OSFileFuncWin;
   friend bool OSSleep( long nSeconds, long nNanoseconds );
public:
   OSThreadWindows();
   OSThreadWindows( bool val ): OSThreadBase( val ) {  setCurrent(); }
   ~OSThreadWindows();

   virtual bool priority( OSPriority prio_class, int boost = 0);
   
   bool start( void *(*func)(void *), void *data );
   bool stop();
   void *join() throw( NotJoinableError );
   
   int enableCancel();
   
   int disableCancel();
      
   inline bool setCancelState( int state ) 
   {
      m_canCancel = (state != 0);
      return true;
   }
   
   virtual void *osRun( void * (*func)(void *), void *data, void (*cleanup)(void *) );
   
   void testCancel();
   
   inline void setCancelDeferred() {};
   
   inline void detach() {}
   
   void exit( void *data );
   
   inline bool same() const {
      return (m_valid && m_thid == GetCurrentThreadId());
   }

   bool equal( const OSThreadBase &th ) const {
      const OSThreadWindows *other =static_cast<const OSThreadWindows *>( &th );
      return ( m_valid && other->m_valid && other->m_thid == m_thid );
   }

   virtual bool setCurrent();
   virtual void invalidate();
};

#include <stdio.h>

class OSSpecificDataWindows: public OSSpecificDataBase
{
private:
   DWORD  m_data;

public:
   OSSpecificDataWindows() throw( InitError );

   ~OSSpecificDataWindows() 
   { 
      if (  m_data != TLS_OUT_OF_INDEXES )
         TlsFree( m_data ); 
   }

   void *data() const { return TlsGetValue( m_data ); }
   void data(const void *dt) { 
      void *dt1 = const_cast<void *>(dt);
      TlsSetValue( m_data, dt1); 
   }
};

typedef OSSpecificDataWindows OSSpecificData;
typedef OSThreadWindows OSThread;
typedef OSConditionWindows OSCondition;
typedef OSMutexWindows OSMutex;

} // namespace

#endif

---