C:/rwlock/system.cpp

Go to the documentation of this file.

#include "system.hh"

    CriticalSection::CriticalSection() : implData((void*)new CRITICAL_SECTION)
        {
            assert(implData);
                InitializeCriticalSection( *((CRITICAL_SECTION **)&implData) );
        }

    CriticalSection::~CriticalSection()
        {
                DeleteCriticalSection( *((CRITICAL_SECTION **)&implData) );
        }

        void CriticalSection::enter()
        {
                EnterCriticalSection( *((CRITICAL_SECTION **)&implData) );
        }

        void CriticalSection::leave()
        {
                LeaveCriticalSection( *((CRITICAL_SECTION **)&implData) );
        }


    LIFOCriticalSection::LIFOCriticalSection(void) : 
        implData((void*)CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 ))
    {
//          *((HANDLE *)&implData) = 
//                  CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
            assert(implData);
        leave();
    }

    LIFOCriticalSection::~LIFOCriticalSection(void)
    {
            CloseHandle( *((HANDLE *)&implData) );
    }

    void LIFOCriticalSection::enter()
    {
            DWORD                       numberOfBytesTransferred;
            DWORD                       completionKey;
            LPOVERLAPPED        lpOverlapped;

            GetQueuedCompletionStatus(
                    *((HANDLE *)&implData), 
                    &numberOfBytesTransferred, 
                    &completionKey, 
                    &lpOverlapped, 
                    INFINITE ); 
    }

    void LIFOCriticalSection::leave()
    {
            PostQueuedCompletionStatus(
                    *((HANDLE *)&implData),
                    0, 
                    0, 
                    0 );
    }


    LIFOSemaphore::LIFOSemaphore(unsigned long initCount) :
        implData((void*)CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0))
    {
//          *((HANDLE *)&implData) = 
//                  CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
            assert(implData);
        if( initCount > 0 ) release( initCount );
    }

    LIFOSemaphore::~LIFOSemaphore(void)
    {
            CloseHandle( *((HANDLE *)&implData) );
    }

    void LIFOSemaphore::wait( unsigned long timeout)
    {
            DWORD                       numberOfBytesTransferred;
            DWORD                       completionKey;
            LPOVERLAPPED        lpOverlapped;

            GetQueuedCompletionStatus(
                    *((HANDLE *)&implData), 
                    &numberOfBytesTransferred, 
                    &completionKey, 
                    &lpOverlapped, 
                    timeout ); 
    }

    void LIFOSemaphore::release(unsigned long relCount)
    {
            while( relCount-- > 0 )
            {
                    PostQueuedCompletionStatus(
                            *((HANDLE *)&implData),
                            0, 
                            0, 
                            0 );
            }
    }

//
// System class implementation
//
    CriticalSection     *System::systemCS = createCriticalSection();

    void System::vdebugPrint(const char *format, va_list args)
    {
        char buffer[1024];
        _vsnprintf( buffer, sizeof(buffer)-4, format, args );
        buffer[sizeof(buffer)-2] = '\0';
        strcat(buffer, "\n");
        OutputDebugString((LPCTSTR)buffer);
    }

    void System::debugPrint(const char *format, ...)
    {
        if(format)
        {
                va_list args;
                va_start(args, format);
            vdebugPrint(format, args);
            va_end(args);
        }
        else
        {
            assert(format);
        }
    }

    SOCKET System::accept( SOCKET s, struct sockaddr *addr, int *addrlen )
    {
            return( ::accept( s, addr, addrlen ) );
    }

    long System::getLastOSErrorCode(void)
    {
            return(GetLastError());
    }

    unsigned long System::getOSTimeSeconds(void)
    {
            return(time(NULL));
    }

    void System::yieldThread()
    {
            Sleep(0);
    }

    void                        System::sleep( unsigned long sleepTimeMillisec )
    {
            Sleep(sleepTimeMillisec);
    }

    void                        System::displayErrorMessage( const char *title, const char *message )
    {
            MessageBox( NULL, 
                                    message,
                                    title,
                                    MB_OK |
                                    MB_SETFOREGROUND |
                                    //MB_DEFAULT_DESKTOP_ONLY or MB_SERVICE_NOTIFICATION
                                    MB_ICONERROR );
    }

    int System::initializeSockets()
    {
            WSADATA wsdat;
            return( WSAStartup( MAKEWORD( 1, 0 ), &wsdat ) );
    }

    void System::cleanupSockets()
    {
            WSACleanup();
    }

    int System::closeSocket(SOCKET s)
    {
            return( closesocket(s) );
    }

    void        System::atomicIncrement( volatile unsigned long &v, CriticalSection* )
    {
            InterlockedIncrement( (long *)&v );
    }

    void        System::atomicDecrement( volatile unsigned long &v, CriticalSection* )
    {
            InterlockedDecrement( (long *)&v );
    }

---