event.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "event.h"
#include "exception.h"
#ifndef WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#endif

// CL_Event Construction:

#ifdef WIN32

CL_Event::CL_Event(bool manual_reset, bool initial_state)
: handle(INVALID_HANDLE_VALUE), type(type_native), socket_handler(0)
{
        handle = CreateEvent(
                0,
                manual_reset ? TRUE : FALSE,
                initial_state ? TRUE : FALSE,
                0);
        if (handle == INVALID_HANDLE_VALUE)
                throw CL_Exception(TEXT("Unable to create event!"));
}

CL_Event::CL_Event(CL_SocketEventHandler *socket_handler, EventType type)
: type(type), socket_handler(socket_handler)
{
        if (type == type_native)
                throw CL_Exception(TEXT("Invalid type parameter"));
}

CL_Event::~CL_Event()
{
        if (handle != INVALID_HANDLE_VALUE)
                CloseHandle(handle);
        handle = INVALID_HANDLE_VALUE;
}

#else

CL_Event::CL_Event(bool manual_reset, bool initial_state)
: manual_reset(manual_reset), state(initial_state), type(type_native), socket_handler(0)
{
        int result = socketpair(AF_UNIX, SOCK_DGRAM, PF_UNIX, wait_sockets);
        if (result == -1)
                throw CL_Exception(TEXT("Could not create event waiting socket pair!"));
}

CL_Event::CL_Event(CL_SocketEventHandler *socket_handler, EventType type)
: manual_reset(true), state(false), type(type), socket_handler(socket_handler)
{
        if (type == type_native)
                throw CL_Exception(TEXT("Invalid type parameter"));
}

CL_Event::~CL_Event()
{
        if (type == type_native)
        {
                close(wait_sockets[0]);
                close(wait_sockets[1]);
        }
}

#endif


// CL_Event Attributes:

// CL_Event Operations:

bool CL_Event::wait(int timeout) const
{
#ifdef WIN32
        switch (type)
        {
        case type_native:
                {
                        DWORD result = WaitForSingleObject(handle, (timeout == -1) ? INFINITE : timeout);
                        return (result != WAIT_TIMEOUT);
                }

        case type_socket_read:
        case type_socket_write:
        case type_socket_exception:
                {
                        timeval tv;
                        tv.tv_sec = timeout / 1000;
                        tv.tv_usec = (timeout % 1000) * 1000;

                        fd_set fds;
                        FD_ZERO(&fds);
                        FD_SET(socket_handler->socket_handle, &fds);
                
                        int result = select((int) socket_handler->socket_handle+1,
                                (type == type_socket_read) ? &fds : 0,
                                (type == type_socket_write) ? &fds : 0,
                                (type == type_socket_exception) ? &fds : 0,
                                (timeout == -1) ? 0 : &tv);
                        if (result == -1) // Error occoured
                        {
                                throw CL_Exception(TEXT("Event wait failed!"));
                        }
                        else if (result == 0) // Timed out
                        {
                                return false;
                        }
                        else // Got a message
                        {
                                return true;
                        }
                }
                return false;

        default:
                throw CL_Exception(TEXT("Unknown event type"));
                return false;
        }
#else
        // Placing the timeval struct here allows linux systems to more
        // correctly resume a select if it was awaken by a manual reset
        // event. On non-linux unixes (those that do not update timeval),
        // the timeout precision will be more inaccurate for manual reset
        // events with multiple listeners.
        //   -- mbn 4 nov 2004
        timeval tv;
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;

        while (true)
        {
                fd_set fds;
                FD_ZERO(&fds);
                if (type == type_native)
                        FD_SET(wait_sockets[1], &fds);
                else
                        FD_SET(socket_handler->socket_handle, &fds);
                
                int result = select(
                        (type == type_native) ? wait_sockets[1]+1 : socket_handler->socket_handle+1,
                        (type == type_native || type == type_socket_read) ? &fds : 0,
                        (type == type_socket_write) ? &fds : 0,
                        (type == type_socket_exception) ? &fds : 0,
                        (timeout == -1) ? 0 : &tv);
                if (result == -1) // Error occoured
                {
                        throw CL_Exception(TEXT("Event wait failed!"));
                }
                else if (result == 0) // Timed out
                {
                        return false;
                }
                else // Got a message
                {
                        if (!manual_reset || type != type_native)
                        {
                                return true;
                        }
                        else
                        {
                                // For automatic reset, check if we are first
                                // thread:
                                CL_MutexSection mutex_lock(&mutex);
                                if (state == true)
                                {
                                        char msg = 0;
                                        recv(wait_sockets[1], &msg, sizeof(char), 0);
                                        state = false;
                                        return true;
                                }

                                // Someone beat us to it, go back and wait.
                        }
                }
        }

        return false;
#endif
}

int CL_Event::wait(int count, CL_Event const * const * events, int timeout, bool wait_all)
{
#ifdef WIN32
        if (count == 0)
        {
                WaitForMultipleObjects(0, 0, FALSE, (timeout == -1) ? INFINITE : timeout);
                return -1;
        }

        std::vector<HANDLE> handles;
        for (int i=0; i<count; i++)
                handles.push_back(events[i]->handle);
                
        DWORD result = WaitForMultipleObjects(
                count,
                &handles[0],
                wait_all ? TRUE : FALSE,
                (timeout == -1) ? INFINITE : timeout);
        
        if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + count)
                return result - WAIT_OBJECT_0;
        else if (result >= WAIT_ABANDONED_0 && result < WAIT_ABANDONED_0 + count)
                return result - WAIT_ABANDONED_0;
        else
                return -1;
#else
        if (wait_all == true)
                throw CL_Exception(TEXT("wait_all not implemented yet for unix target"));

        // Placing the timeval struct here allows linux systems to more
        // correctly resume a select if it was awaken by a manual reset
        // event. On non-linux unixes (those that do not update timeval),
        // the timeout precision will be more inaccurate for manual reset
        // events with multiple listeners.
        //   -- mbn 4 nov 2004
        timeval tv;
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;

        while (true)
        {       
                bool reads = false;
                bool writes = false;
                bool exceptions = false;
                int highest_fd = -1;
                fd_set rfds, wfds, efds;
                FD_ZERO(&rfds);
                FD_ZERO(&wfds);
                FD_ZERO(&efds);
                for (int i=0; i<count; i++)
                {
                        switch (events[i]->type)
                        {
                        case type_native:
                                FD_SET(events[i]->wait_sockets[1], &rfds);
                                if (events[i]->wait_sockets[1] > highest_fd)
                                        highest_fd = events[i]->wait_sockets[1];
                                reads = true;
                                break;
                        case type_socket_read:
                                FD_SET(events[i]->socket_handler->socket_handle, &rfds);
                                if (events[i]->socket_handler->socket_handle > highest_fd)
                                        highest_fd = events[i]->socket_handler->socket_handle;
                                reads = true;
                                break;
                        case type_socket_write:
                                FD_SET(events[i]->socket_handler->socket_handle, &wfds);
                                if (events[i]->socket_handler->socket_handle > highest_fd)
                                        highest_fd = events[i]->socket_handler->socket_handle;
                                writes = true;
                                break;
                        case type_socket_exception:
                                FD_SET(events[i]->socket_handler->socket_handle, &efds);
                                if (events[i]->socket_handler->socket_handle > highest_fd)
                                        highest_fd = events[i]->socket_handler->socket_handle;
                                exceptions = true;
                                break;
                        }
                }

                int result = select(
                        highest_fd+1,
                        reads ? &rfds : 0,
                        writes ? &wfds : 0,
                        exceptions ? &efds : 0,
                        (timeout == -1) ? 0 : &tv);
                if (result == -1) // Error occoured
                {
                        throw CL_Exception(TEXT("Event wait failed!"));
                }
                else if (result == 0) // Timed out
                {
                        return -1;
                }
                else // Got a message
                {
                        // find the flagged sockets
                        for (int i=0; i<count; i++)
                        {
                                switch (events[i]->type)
                                {
                                case type_native:
                                        if (FD_ISSET(events[i]->wait_sockets[1], &rfds))
                                        {
                                                if (!events[i]->manual_reset)
                                                {
                                                        return i;
                                                }
                                                else
                                                {
                                                        // For automatic reset, check if we are first
                                                        // thread:
                                                        CL_MutexSection mutex_lock(&events[i]->mutex);
                                                        if (events[i]->state == true)
                                                        {
                                                                char msg = 0;
                                                                recv(events[i]->wait_sockets[1], &msg, sizeof(char), 0);
                                                                events[i]->state = false;
                                                                return i;
                                                        }

                                                        // Someone beat us to it, go back and wait.
                                                }
                                        }
                                        break;
                                case type_socket_read:
                                        if (FD_ISSET(events[i]->socket_handler->socket_handle, &rfds))
                                                return i;
                                        break;
                                case type_socket_write:
                                        if (FD_ISSET(events[i]->socket_handler->socket_handle, &wfds))
                                                return i;
                                        break;
                                case type_socket_exception:
                                        if (FD_ISSET(events[i]->socket_handler->socket_handle, &efds))
                                                return i;
                                        break;
                                }
                        }
                }
        }
        
        return -1;
#endif
}

int CL_Event::wait(const std::vector<CL_Event *> &events, int timeout, bool wait_all)
{
        if (events.size() > 0)
                return wait((int) events.size(), &events[0], timeout, wait_all);
        else
                return wait(0, 0, timeout, wait_all);
}

void CL_Event::set()
{
        if (type != type_native)
                throw CL_Exception(TEXT("Changing state on socket events unsupported"));

#ifdef WIN32
        BOOL result = SetEvent(handle);
        if (result == FALSE)
                throw CL_Exception(TEXT("Unable to set event to signalled state!"));
#else
        CL_MutexSection mutex_lock(&mutex);
        if (state == false)
        {
                state = true;
                char msg = 1;
                send(wait_sockets[0], &msg, sizeof(char), 0);
        }
#endif
}

void CL_Event::reset()
{
        if (type != type_native)
                throw CL_Exception(TEXT("Changing state on socket events unsupported"));

#ifdef WIN32
        BOOL result = ResetEvent(handle);
        if (result == FALSE)
                throw CL_Exception(TEXT("Unable to reset event!"));
#else
        CL_MutexSection mutex_lock(&mutex);
        if (state == true)
        {
                char msg = 0;
                recv(wait_sockets[1], &msg, sizeof(char), 0);
                state = false;
        }
#endif
}

// CL_Event Implementation:

CL_Event::CL_Event(const CL_Event &copy)
{
        throw CL_Exception(TEXT("Event class copy construction not supported"));
}
        
CL_Event &CL_Event::operator =(const CL_Event &copy)
{
        throw CL_Exception(TEXT("Event class copy construction not supported"));
        return *this;
}

---