include/vrvCore/DtSharedSettings.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2012 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#ifndef WIN32_LEAN_AND_MEAN
#define UNDEF_WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <boost/thread/shared_mutex.hpp>

#ifdef UNDEF_WIN32_LEAN_AND_MEAN
#undef UNDEF_WIN32_LEAN_AND_MEAN
#undef WIN32_LEAN_AND_MEAN
#endif

#include <vrvCore/DtReadSettingsLock.h>
#include <vrvCore/DtWriteSettingsLock.h>

namespace makVrv
{

   class DtSettingsBackup;

   class DT_DLL_VRVCORE DtSharedSettings : public DtVirtualBaseClass
   {
   public:

      DtSharedSettings( const DtSharedSettingsManager& manager );

      virtual ~DtSharedSettings();

      inline boost::shared_mutex& mutex() { return myMutex; }


      // Forward declarations.
      class SignalSafety;
      friend class SignalSafety;

      class DT_DLL_VRVCORE SafetyKey
      {
      public:

         friend class DtSharedSettings;
         friend class SignalSafety;

         ~SafetyKey();

#if _WIN32  //Windows allows the copy ctor to be private
      private:
#endif

         SafetyKey( const SafetyKey& );

      private:

         SafetyKey();

         SafetyKey& operator = ( const SafetyKey& );

      protected:

         SafetyKey( DtSharedSettings* ptr );

         DtSharedSettings* myPtr;

      };

      //The signal safety class ensures that the manager for getting a
      //Signaler is safe, as this requires unlocking the write lock, calling
      //the signal, then re-locking the write lock when the function returns
      class DT_DLL_VRVCORE SignalSafety : public boost::noncopyable
      {
      public:

         SignalSafety( const SafetyKey& key );

         ~SignalSafety();

         inline const DtSharedSettingsManager& manager() const
         {
            return mySettings.myManager;
         }

      protected:

         DtSharedSettings& mySettings;

      };


      SafetyKey safeToEmitSignals()
      {
         return SafetyKey(this);
      }

      inline void setCurrentWriteLock(
         boost::unique_lock<boost::shared_mutex>* currentWriteLock)
      {
         myCurrentWriteLock = currentWriteLock;
      }

      virtual const DtSettingsBackup* settingsBackup() const;

      virtual DtSettingsBackup* settingsBackup();

      virtual void backup();

   private:

      const DtSharedSettingsManager& myManager;
      boost::shared_mutex myMutex;

      //Current write lock used.
      boost::unique_lock<boost::shared_mutex>* myCurrentWriteLock;

   };

}