threadSafe.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/



#ifndef threadSafe_H_
#define threadSafe_H_
#include "lgrUtil.h"

#include <vlutil/vlMutex.h>
#include <vlutil/vlScopedLock.h>

namespace MAKLogger
{


   class DT_DLL_LGRUTIL DtScopedSequenceLock
   {
   public:
      typedef void (*LockFunction)(void*);

      DtScopedSequenceLock(const DtScopedSequenceLock& orig);

      virtual ~DtScopedSequenceLock();

   protected:

      DtScopedSequenceLock(void* object,LockFunction lockCB,LockFunction unlockCB);

      LockFunction myLockCallback;

      LockFunction myUnlockCallback;

      void* myObject;
   };



   template <typename T>
   class DtThreadSafe
   {
#ifndef __solaris__
   protected:
#else
   public:
#endif
      class LockedProxy;
      class ConstLockedProxy;
      friend class SequenceLockImpl;
   public:

      DtThreadSafe(const T& value);

      operator T() const;

      LockedProxy operator->();

      ConstLockedProxy operator->() const;

      DtThreadSafe<T>& operator =(const DtThreadSafe<T>& orig);

      DtThreadSafe<T>& operator =(const T& orig);

      DtScopedSequenceLock sequenceLock();

#ifndef __solaris__
   protected:
#else
   public:
#endif

      class LockedProxy
      {
      public:
         LockedProxy(T& value,DtMutex& mutex);
         LockedProxy(const LockedProxy& orig);
         ~LockedProxy();

         T* operator->();

      protected:
         T* myValue;
         DtMutex& myMutex;
         DtScopedLock myLock;
      };

      class ConstLockedProxy
      {
      public:
         ConstLockedProxy(const T& value,DtMutex& mutex);
         ConstLockedProxy(const ConstLockedProxy& orig);
         ~ConstLockedProxy();

         const  T* operator->();

      protected:
         const T*  myValue;
         DtMutex& myMutex;
         DtScopedLock myLock;
      };


      class SequenceLockImpl : public DtScopedSequenceLock
      {
      public:
         SequenceLockImpl(DtThreadSafe* object);

         virtual ~SequenceLockImpl();

         static void lock(void* object);

         static void unlock(void* object);
      };

      void lockObject();

      void unlockObject();

      T myValue;
      DtScopedLock* myExternalLock;

      DtMutex myLockMutex;

      mutable DtMutex myMutex;
   };

#define threadSafe_inl_
#include "threadSafe.inl"
#undef threadSafe_inl_

}

#endif