JSemaphore_Win32.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

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

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/

namespace cmlabs {

#ifdef WIN32

void printLastError() {

        void* lpMsgBuf;
        FormatMessage( 
            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
            FORMAT_MESSAGE_FROM_SYSTEM | 
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            GetLastError(),
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
            (LPTSTR) &lpMsgBuf,
            0,
            NULL 
        );
        printf("LastError: %s", (char*) lpMsgBuf);
}


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

JSemaphore::JSemaphore(JString semName) {
        // Create a semaphore with initial and max. counts of 10.

        count=0;
        name = semName;

        hSemaphore = CreateSemaphore( 
            NULL,                       // no security attributes
            0,                          // initial count
            10,                         // maximum count
            NULL);                      // unnamed semaphore

        if (hSemaphore == NULL) 
        {
                // Check for error.
        }

}

JSemaphore::~JSemaphore() {
        CloseHandle(hSemaphore);
}


bool JSemaphore::wait(long ms) {

        DWORD dwWaitResult; 
 
        // Try to enter the semaphore gate.

        if (ms < 0)
                ms = INFINITE;

        try {
                dwWaitResult = WaitForSingleObject( 
                        hSemaphore,             // handle to semaphore
                        ms);                    // time-out interval
        }
        catch(...) {
                dwWaitResult = 999;
        }

        if (dwWaitResult == WAIT_OBJECT_0) { 
                // The semaphore object was signaled
                count--;
                return true;
        }

        if (dwWaitResult != WAIT_TIMEOUT)
                printLastError();

        // case WAIT_TIMEOUT: 
        return false;
}


bool JSemaphore::post() {
        // Increment the count of the semaphore.
        try {
                if (!ReleaseSemaphore( 
                                hSemaphore,  // handle to semaphore
                                1,           // increase count by one
                                NULL) )    // not interested in previous count
                {
                        // Deal with the error.
                        return false;
                }
        }
        catch(...) {
        }
        count++;
        return true;
}


bool JSemaphore::tryWait() {
        return wait(0);
}



JSingleSemaphore::JSingleSemaphore() {
        // Create a semaphore with initial and max. counts of 10.

        hSemaphore = CreateSemaphore( 
            NULL,                       // no security attributes
            0,                          // initial count
            1,                          // maximum count
            NULL);                      // unnamed semaphore

        if (hSemaphore == NULL) 
        {
                // Check for error.
        }

}

JSingleSemaphore::~JSingleSemaphore() {
        CloseHandle(hSemaphore);
}


bool JSingleSemaphore::wait(long ms) {

        DWORD dwWaitResult; 
 
        // Try to enter the semaphore gate.

        if (ms < 0)
                ms = INFINITE;

        try {
                dwWaitResult = WaitForSingleObject( 
                        hSemaphore,             // handle to semaphore
                        ms);                    // time-out interval
        }
        catch(...) {
                dwWaitResult = 999;
        }

        if (dwWaitResult == WAIT_OBJECT_0) { 
                // The semaphore object was signaled
                return true;
        }

        if (dwWaitResult != WAIT_TIMEOUT)
                printLastError();

        // case WAIT_TIMEOUT: 
        return false;
}


bool JSingleSemaphore::postToAll() {
        // Increment the count of the semaphore.
        try {
                if (!ReleaseSemaphore( 
                                hSemaphore,  // handle to semaphore
                                1,           // increase count by one
                                NULL) )    // not interested in previous count
                {
                        // Deal with the error.
                        return false;
                }
        }
        catch(...) {
        }
        return true;
}


bool JSingleSemaphore::tryWait() {
        return wait(0);
}




JMutex::JMutex() {
        mutex = CreateMutex (NULL, FALSE, NULL); 
}

JMutex::~JMutex() {
        CloseHandle(mutex);
}

bool JMutex::EnterMutex(long ms) const {
        return enterMutex(ms);
}

bool JMutex::enterMutex(long ms) const {

    DWORD dwWaitResult; 
        long w;

        if (ms < 0)
                w = 100000;
        else
                w = ms;

        try {
                // Request ownership of mutex.
                dwWaitResult = WaitForSingleObject( 
                        mutex,   // handle to mutex
                        w);   // time-out interval
        }
        catch(...) {
                dwWaitResult = 999;
        }

        if (dwWaitResult == WAIT_OBJECT_0)
                return true;
        else
                return false;

}

bool JMutex::LeaveMutex() const {
        return leaveMutex();
}

bool JMutex::leaveMutex() const {
        try {
                ReleaseMutex(mutex);
        }
        catch(...) {
                return false;
        }
        return true;
}



#endif

} // namespace cmlabs

---