#ifndef _HIK_EVENT_H_

#define _HIK_EVENT_H_  

#ifdef _MSC_VER

#include <Windows.h>

#define hik_event_handle HANDLE

#else

#include <pthread.h>

typedef struct

{

    bool state;

    bool manual_reset;

    pthread_mutex_t mutex;

    pthread_cond_t cond;

}event_t;

#define event_handle event_t*

#endif  

//返回值：NULL 出错

event_handle event_create(bool manual_reset, bool init_state);  

//返回值：0 等到事件，-1出错

int event_wait(event_handle hevent);  

//返回值：0 等到事件，1 超时，-1出错

int event_timedwait(event_handle hevent, long milliseconds);  

//返回值：0 成功，-1出错

int event_set(event_handle hevent);  

//返回值：0 成功，-1出错

int event_reset(event_handle hevent);  

//返回值：无

void event_destroy(event_handle hevent);  

#endif  

////////////

<pre class="cpp" name="code">#include "event.h"

#ifdef __linux

#include <sys/time.h>

#include <errno.h>

#endif

#include <iostream>

event_handle event_create(bool manual_reset, bool init_state)

{

#ifdef _MSC_VER

    HANDLE hevent = CreateEvent(NULL, manual_reset, init_state, NULL);

#else

    event_handle hevent = new(std::nothrow) event_t;

    if (hevent == NULL)

    {

        return NULL;

    }

    hevent->state = init_state;

    hevent->manual_reset = manual_reset;

    if (pthread_mutex_init(&hevent->mutex, NULL))

    {

        delete hevent;

        return NULL;

    }

    if (pthread_cond_init(&hevent->cond, NULL))

    {

        pthread_mutex_destroy(&hevent->mutex);

        delete hevent;

        return NULL;

    }

#endif

    return hevent;

}

int event_wait(event_handle hevent)

{

#ifdef _MSC_VER

    DWORD ret = WaitForSingleObject(hevent, INFINITE);

    if (ret == WAIT_OBJECT_0)

    {

        return ;

    }

    return -;

#else

    if (pthread_mutex_lock(&hevent->mutex))

    {

        return -;

    }

    while (!hevent->state)

    {

        if (pthread_cond_wait(&hevent->cond, &hevent->mutex))

        {

            pthread_mutex_unlock(&hevent->mutex);

            return -;

        }

    }

    if (!hevent->manual_reset)

    {

        hevent->state = false;

    }

    if (pthread_mutex_unlock(&hevent->mutex))

    {

        return -;

    }

    return ;

#endif

}

int event_timedwait(event_handle hevent, long milliseconds)

{

#ifdef _MSC_VER

    DWORD ret = WaitForSingleObject(hevent, milliseconds);

    if (ret == WAIT_OBJECT_0)

    {

        return ;

    }

    if (ret == WAIT_TIMEOUT)

    {

        return ;

    }

    return -;

#else  

    int rc = ;

    struct timespec abstime;

    struct timeval tv;

    gettimeofday(&tv, NULL);

    abstime.tv_sec  = tv.tv_sec + milliseconds / ;

    abstime.tv_nsec = tv.tv_usec* + (milliseconds % )*;

    if (abstime.tv_nsec >= )

    {

        abstime.tv_nsec -= ;

        abstime.tv_sec++;

    }     

    if (pthread_mutex_lock(&hevent->mutex) != )

    {

        return -;

    }

    while (!hevent->state)

    {

        if (rc = pthread_cond_timedwait(&hevent->cond, &hevent->mutex, &abstime))

        {

            if (rc == ETIMEDOUT) break;

            pthread_mutex_unlock(&hevent->mutex);

            return -;

        }

    }

    if (rc ==  && !hevent->manual_reset)

    {

        hevent->state = false;

    }

    if (pthread_mutex_unlock(&hevent->mutex) != )

    {

        return -;

    }

    if (rc == ETIMEDOUT)

    {

        //timeout return 1

        return ;

    }

    //wait event success return 0

    return ;

#endif

}

int event_set(event_handle hevent)

{

#ifdef _MSC_VER

    return !SetEvent(hevent);

#else

    if (pthread_mutex_lock(&hevent->mutex) != )

    {

        return -;

    }  

    hevent->state = true;  

    if (hevent->manual_reset)

    {

        if(pthread_cond_broadcast(&hevent->cond))

        {

            return -;

        }

    }

    else

    {

        if(pthread_cond_signal(&hevent->cond))

        {

            return -;

        }

    }  

    if (pthread_mutex_unlock(&hevent->mutex) != )

    {

        return -;

    }  

    return ;

#endif

}

int event_reset(event_handle hevent)

{

#ifdef _MSC_VER

    //ResetEvent 返回非零表示成功

    if (ResetEvent(hevent))

    {

        return ;

    }

    return -;

#else

    if (pthread_mutex_lock(&hevent->mutex) != )

    {

        return -;

    }  

    hevent->state = false;  

    if (pthread_mutex_unlock(&hevent->mutex) != )

    {

        return -;

    }

    return ;

#endif

}

void event_destroy(event_handle hevent)

{

#ifdef _MSC_VER

    CloseHandle(hevent);

#else

    pthread_cond_destroy(&hevent->cond);

    pthread_mutex_destroy(&hevent->mutex);

    delete hevent;

#endif

}