esynch.h

Go to the documentation of this file.

/*
* Copyright (c) 2009-2019 Brian Waters
* Copyright (c) 2019 Sprint
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
 
#ifndef __esynch_h_included
#define __esynch_h_included
 
 
#include <semaphore.h>
 
#include "ebase.h"
#include "estring.h"
#include "eerror.h"
 
#define MAX_SEMIDS 64
#define MAX_NOTIFYIDS 64
 
 
DECLARE_ERROR_ADVANCED2(EMutexError_UnableToInitialize);
DECLARE_ERROR_ADVANCED2(EMutexError_UnableToLock);
DECLARE_ERROR_ADVANCED2(EMutexError_UnableToUnLock);
DECLARE_ERROR(EMutexError_UnableToAllocateMutex);
DECLARE_ERROR(EMutexError_AlreadyInitialized);
DECLARE_ERROR(EMutexError_MutexUninitialized);
 
 
DECLARE_ERROR_ADVANCED(ESemaphoreError_UnableToInitialize);
DECLARE_ERROR_ADVANCED(ESemaphoreError_UnableToDecrement);
DECLARE_ERROR_ADVANCED(ESemaphoreError_UnableToIncrement);
 
DECLARE_ERROR(ESemaphoreError_UnableToAllocateSemaphore);
DECLARE_ERROR(ESemaphoreError_AlreadyAllocated);
DECLARE_ERROR(ESemaphoreError_NotInitialized);
DECLARE_ERROR(ESemaphoreError_AlreadyInitialized);
DECLARE_ERROR(ESemaphoreError_MaxNotifyIdsExceeded);
 
// Common Mutex Classes
 
// class EMutexPrivate;
// class EMutexPublic;
// class EMutexLock;
 
class EMutexData
{
   friend class EMutexPrivate;
   friend class EMutexPublic;
   friend class EMutexLock;
 
public:
   ~EMutexData()
   {
   }
 
   Void init(Bool shared);
   Void destroy();
 
   Bool initialized()
   {
      return m_initialized;
   }
 
#if defined(NATIVE_IPC)
   pthread_mutex_t &mutex()
   {
      return m_mutex;
   }
#else
   Long &mutex()
   {
      return m_lock;
   }
#endif
 
protected:
   EMutexData()
   {
      m_initialized = False;
   }
   Bool enter(Bool wait = True);
   Void leave();
 
private:
   Bool m_initialized;
#if defined(NATIVE_IPC)
   pthread_mutex_t m_mutex;
#else
   Long m_lock;
#endif
};
 
class EMutexLock
{
public:
   EMutexLock(EMutexData &mtx, Bool acquire = True)
      : m_acquire(acquire), m_mtx(mtx)
   {
      if (m_acquire)
         m_mtx.enter();
   }
   ~EMutexLock()
   {
      if (m_acquire)
         m_mtx.leave();
   }
 
   Bool acquire(Bool wait = True)
   {
      if (!m_acquire)
         m_acquire = m_mtx.enter(wait);
      return m_acquire;
   }
 
private:
   Bool m_acquire;
   EMutexData &m_mtx;
 
   EMutexLock();
   EMutexLock &operator=(const EMutexLock &other);
};
 
// Private Mutex Classes
 
class EMutexPrivate : public EMutexData
{
public:
   EMutexPrivate(Bool bInit = True)
       : EMutexData()
   {
      if (bInit)
         init();
   }
   ~EMutexPrivate()
   {
      destroy();
   }
 
   Void *operator new(size_t, Void *where) { return where; }
 
   Void init() { EMutexData::init(False); }
};
 
// Public Mutex Classes
 
class EMutexDataPublic : public EMutexData
{
   friend class ESynchObjects;
 
public:
   ~EMutexDataPublic() {}
 
   Int &mutexId() { return m_mutexId; }
 
protected:
   EMutexDataPublic() {}
   Int &nextIndex() { return m_nextIndex; }
 
private:
   Int m_nextIndex;
   Int m_mutexId;
};
 
class EMutexPublic
{
public:
   EMutexPublic(Bool bInit = True)
   {
      m_mutexid = 0;
      if (bInit)
         init();
   }
   ~EMutexPublic()
   {
      destroy();
   }
 
   Void init();
   Void destroy();
 
   Void attach(Int mutexid);
   Void detach();
 
   Int mutexId() { return m_mutexid; }
 
   operator EMutexDataPublic &();
 
private:
   Int m_mutexid;
};
 
// Common Semaphore Classes
 
class ESemaphoreData
{
public:
   ESemaphoreData()
      : m_initialized(False),
        m_shared(False),
        m_initCount(0),
        m_currCount(0)
   {
   }
   ESemaphoreData(Long initcnt, Bool shared)
      : m_initialized(False),
        m_shared(shared),
        m_initCount(initcnt),
        m_currCount(0)
   {
   }
   ~ESemaphoreData()
   {
      destroy();
   }
 
   Void init();
   Void destroy();
 
   Bool Decrement(Bool wait = True);
   Bool Increment();
 
   Bool initialized() { return m_initialized; }
   Bool &shared() { return m_shared; }
   Long &initialCount() { return m_initCount; }
   Long currCount() { return m_currCount; }
 
private:
   Bool m_initialized;
   Bool m_shared;
   Long m_initCount;
   Long m_currCount;
   sem_t m_sem;
};
 
class ESemaphoreBase
{
public:
   ESemaphoreBase() {}
   ~ESemaphoreBase() {}
 
   virtual Void init(Long initcnt) = 0;
   virtual Void destroy() = 0;
 
   Bool Decrement(Bool wait = True) { return getData().Decrement(wait); }
   Bool Increment() { return getData().Increment(); }
 
   Bool initialized() { return getData().initialized(); }
   Bool &shared() { return getData().shared(); }
   Long &initialCount() { return getData().initialCount(); }
   Long currCount() { return getData().currCount(); }
 
   operator ESemaphoreData&() { return getData(); }
 
protected:
   virtual ESemaphoreData &getData() = 0;
};
 
// Private Semaphore Classes
 
class ESemaphorePrivate : public ESemaphoreBase
{
public:
   ESemaphorePrivate(Long initcnt=0, Bool bInit = True)
      : m_data(initcnt, False)
   {
      if (bInit)
         init(initcnt);
   }
   ~ESemaphorePrivate()
   {
      destroy();
   }
 
   Void init(Long initcnt) { m_data.initialCount() = initcnt; m_data.init(); }
   Void destroy() { m_data.destroy(); }
 
protected:
   ESemaphoreData &getData() { return m_data; }
 
private:
   ESemaphoreData m_data;
};
 
// Public Semaphore Classes
 
class ESemaphoreDataPublic : public ESemaphoreData
{
   friend class ESemaphorePublic;
   friend class ESynchObjects;
public:
   ESemaphoreDataPublic(Long initcnt=0)
      : ESemaphoreData(initcnt, True)
   {
   }
   ~ESemaphoreDataPublic()
   {
   }
 
   Int &semIndex() { return m_semIndex; }
 
protected:
   Int &nextIndex() { return m_nextIndex; }
 
private:
   Int m_nextIndex;
   Int m_semIndex;
};
 
class ESemaphorePublic : public ESemaphoreBase
{
   friend class ESynchObjects;
public:
   ESemaphorePublic()
      : m_semid(0)
   {
   }
   ESemaphorePublic(Long initcnt, Bool bInit = True)
      : m_semid(0)
   {
      if (bInit)
         init(initcnt);
   }
   ~ESemaphorePublic()
   {
      destroy();
   }
 
   Void init(Long initialCount);
   Void destroy();
 
   Int &semIndex();
 
   Void attach(Int semid);
   Void detach();
 
protected:
   Int &nextIndex();
   ESemaphoreData &getData();
 
private:
   Int m_semid;
};
 
// Private Read/Write Lock Classes
 
DECLARE_ERROR_ADVANCED2(ERWLockError_LockAttrInitFailed);
DECLARE_ERROR_ADVANCED2(ERWLockError_LockInitFailed);
 
class ERDLock;
class EWRLock;
 
class ERWLock
{
   friend ERDLock;
   friend EWRLock;
 
public:
   ERWLock();
   ~ERWLock();
 
protected:
   enum ReadWrite
   {
      Read,
      Write
   };
 
   Bool enter( ReadWrite rw, Bool wait );
   Void leave();
 
private:
   pthread_rwlock_t m_rwlock;
};
 
class ERDLock
{
public:
   ERDLock( ERWLock & rwlock, Bool acq = true )
      : m_rwlock( rwlock ),
        m_locked( false )
   {
      if (acq)
         acquire();
   }
   ~ERDLock()
   {
      if (m_locked)
         m_rwlock.leave();
   }
 
   Bool acquire( Bool wait = true )
   {
      return m_locked = m_rwlock.enter( ERWLock::Read, wait );
   }
   Bool isLocked() { return m_locked; }
 
private:
   ERDLock();
 
   ERWLock &m_rwlock;
   Bool m_locked;
};
 
class EWRLock
{
public:
   EWRLock( ERWLock & rwlock, Bool acq = true )
      : m_rwlock( rwlock ),
        m_locked( false )
   {
      if (acq)
         acquire();
   }
   ~EWRLock()
   {
      if (m_locked)
         m_rwlock.leave();
   }
 
   Bool acquire( Bool wait = true )
   {
      return m_locked = m_rwlock.enter( ERWLock::Write, wait );
   }
   Bool isLocked() { return m_locked; }
 
private:
   EWRLock();
 
   ERWLock &m_rwlock;
   Bool m_locked;
};
 
 
class EEvent
{
public:
   EEvent( bool state = false );
   ~EEvent();
 
   Void reset();
   Void set();
   Bool wait( int ms = -1 );
   Bool isSet() { return wait(0); }
 
private:
   void closepipe();
 
   int m_pipefd[2];
   char m_buf[1];
};
 
 
#endif // #define __esynch_h_included