vlThreadSafe.h

Go to the documentation of this file.

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

#include "vlMachineTypes.h"

#include "vlMutex.h"
#include "vlScopedLock.h"

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

   


class DT_DLL_VLUTIL 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:

   // Preferred Constructor to ensure that the value is defined.
   explicit DtThreadSafe(const T& value);
   
   // Fallback Constructor, there is a good chance that T does not have a valid default value on
   // some systems (ie do not assume zero).
   explicit DtThreadSafe();

   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 vlThreadSafe_inl_
#include "vlThreadSafe.inl"
#undef vlThreadSafe_inl_

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif