Tanl Linguistic Pipeline

search/ixe/Common/Lock.h

/*
**      IXE C++ Library
**      Common/Lock.h
** ----------------------------------------------------------------------
**      Copyright (c) 2002  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE 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 General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_Lock_H
#define IXE_Lock_H

// Settings
#include "platform.h"

// standard
#ifdef _WIN32
# include <windows.h>
#else
# include <pthread.h>
# include <cerrno>
#endif

namespace IXE {

#ifdef _WIN32

#define TRESULT         unsigned int __stdcall
#define CriticalSection CRITICAL_SECTION

struct Condition
{
                Condition() : _c(CreateEvent(NULL, FALSE, FALSE, NULL)) { }
                Condition(Condition const&) {
                  _c = CreateEvent(NULL, FALSE, FALSE, NULL); }
                ~Condition() { CloseHandle(_c); }
  inline void   notify() { SetEvent(_c); }
  bool          wait() {
    WaitForSingleObject(_c, INFINITE);
    return true;
  }

  HANDLE        _c;
};

typedef Condition SimpleCondition;

#define ConditionWait(condition, lock) { \
                LeaveCriticalSection(lock); \
                WaitForSingleObject((condition)._c, INFINITE); \
                EnterCriticalSection(lock); }

#define ConditionWaitInterval(condition, lock, msec, nsec, result) { \
                LeaveCriticalSection(lock); \
                result = WaitForSingleObject((condition)._c, msec); \
                EnterCriticalSection(lock); }

#else // !_WIN32

#define TRESULT         void*
#define WAIT_TIMEOUT    ETIMEDOUT

struct Condition
{
                        Condition() { ::pthread_cond_init(&_c, 0); }
                        Condition(Condition const&) {
                          ::pthread_cond_init(&_c, 0); }
                        ~Condition() { ::pthread_cond_destroy(&_c); }
  inline void           notify() { ::pthread_cond_signal(&_c); }

  ::pthread_cond_t      _c;
};

struct SimpleCondition
{
                        SimpleCondition() {
                          ::pthread_mutex_init(&_c, 0);
                          ::pthread_mutex_lock(&_c);
                        }
                        SimpleCondition(SimpleCondition const&) {
                          ::pthread_mutex_init(&_c, 0);
                          ::pthread_mutex_lock(&_c);
                        }
                        ~SimpleCondition() {
                          ::pthread_mutex_unlock(&_c);
                          ::pthread_mutex_destroy(&_c);
                        }
  inline void           notify() { ::pthread_mutex_unlock(&_c); }
  bool                  wait() {
    ::pthread_mutex_lock(&_c);
    return true;
  }

  ::pthread_mutex_t     _c;
};

#define ConditionWait(condition, lock) \
                ::pthread_cond_wait(&(condition._c), lock)

#define ConditionWaitInterval(condition, lock, msec, nsec, result) { \
                struct timespec future; \
                future.tv_sec = ::time(0) + (msec) / 1000; \
                future.tv_nsec = nsec; \
                result = ::pthread_cond_timedwait(&(condition._c), lock, &future); }

// Translations
#define CriticalSection         ::pthread_mutex_t
#define InitializeCriticalSection(x)    ::pthread_mutex_init(x, 0)
#define DeleteCriticalSection   ::pthread_mutex_destroy
#define EnterCriticalSection    ::pthread_mutex_lock
#define LeaveCriticalSection    ::pthread_mutex_unlock
#define ExitThread              ::pthread_exit
#define TerminateThread(x, y)   ::pthread_cancel(x)
#define GetCurrentThread        ::pthread_self

#endif // _WIN32

struct Lock
{
  Lock() { InitializeCriticalSection(&_lock); }
  Lock(Lock const&) { InitializeCriticalSection(&_lock); }

  ~Lock() { DeleteCriticalSection(&_lock); }

  void In() { EnterCriticalSection(&_lock); }

  void Out() { LeaveCriticalSection(&_lock); }

  CriticalSection       _lock;
};

template <typename T>
class Locked : public Lock
{
public:

  Locked() { }

  Locked(T value) :
    value(value)
  { }

  T                     value;

  inline operator       T() const { return value; }
  inline operator       T*() const { return &value; }

  T& operator           *() { return value; }
  T* operator           ->() { return &value; }
};


// Use this if you need to release lock within a conditional branch:
#define Locking(m, stat)        EnterCriticalSection(&(m)._lock); \
                                stat; \
                                LeaveCriticalSection(&(m)._lock);

class LockUp
{
public:
  CriticalSection&      mutex;

public:
  LockUp(CriticalSection& mutex) :
    mutex(mutex)
  {
    EnterCriticalSection(&mutex);
  }

  LockUp(Lock& lock) :
    mutex(lock._lock)
  {
    EnterCriticalSection(&mutex);
  }

  ~LockUp() { LeaveCriticalSection(&mutex); }
};

} // namespace IXE

#endif //       IXE_Lock_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.