monitor.h

Go to the documentation of this file.

#ifndef _DLR_THREAD_MONITOR_H_
#define _DLR_THREAD_MONITOR_H_

#include <vector>
#include <boost/thread.hpp>
#include <dlrCommon/referenceCount.h>

namespace dlr {

  namespace thread {

    // Forward declarations.
    class Monitor;
    class Condition;

    
    class Token {
      friend class Monitor;
      friend class Condition;
      
    public:
      Token();
      Token(const Token& other);
      ~Token();
      operator bool();

    private:
      Token(boost::timed_mutex& mutex);
      Token(boost::timed_mutex& mutex, double timeout);
      boost::timed_mutex::scoped_lock& getLock();
      boost::timed_mutex::scoped_timed_lock& getTimedLock();
      bool isTimed();
      Token& operator=(const Token& other);

      bool m_isTimed;
      boost::timed_mutex::scoped_lock* m_lockPtr;
      boost::timed_mutex::scoped_timed_lock* m_timedLockPtr;

      // We use ReferenceCount directly, rather than through a
      // pointer, because Token objects are never expected to be
      // shared between threads, so thread isn't an issue.
      ReferenceCount m_referenceCount;
    };

    
    class Condition {
      friend class Monitor;
    public:
      Condition(const Condition& other);
      ~Condition();
      Condition& operator=(const Condition& other);

    private:
      Condition(boost::condition* conditionPtr);
      void signalOne();
      void signalAll();
      void wait(Token& token);
      bool wait(Token& token, double timeout);

      boost::condition* m_conditionPtr;
    };

    

    class Monitor
    {
    public:

      Monitor();


      Monitor(const Monitor& other);


      virtual
      ~Monitor();


      Monitor&
      operator=(const Monitor& other);


      void
      makeCopyable(bool copyableFlag=true) {m_isCopyable = copyableFlag;}

    protected:

      void
      copyOther(const Monitor& other);

      
      Condition
      createCondition(bool doInitialize = true);


      Token
      getToken() {return Token(*m_tokenMutexPtr);}

      
      Token
      getToken(double timeout) {return Token(*m_tokenMutexPtr, timeout);}


      void
      releaseResources();

      
      void
      signalOne(Condition& condition) {condition.signalOne();}

      
      void
      signalAll(Condition& condition) {condition.signalAll();}

      
      void
      wait(Condition& condition, Token& token) {condition.wait(token);}
        

      bool
      wait(Condition& condition, Token& token, double timeout) {
        return condition.wait(token, timeout);
      }


    private:

      // We need a mutex in order to implement the virtual token.
      boost::timed_mutex* m_tokenMutexPtr;

      // This vector lets us manage deletion of condition objects
      // explicitly, rather than relying on the Condition class to do
      // so.  This is important because the Condition class destructor
      // is not always called in a protected section of code.
      std::vector<boost::condition*>* m_boostConditionVectorPtr;
      
      // This bool indicates whether or not copying should be allowed.
      bool m_isCopyable;
      
      // Note that thread-safety requires us to use a pointer here.
      size_t* m_referenceCountPtr;
    };

  } // namespace thread

} // namespace dlr

#endif /* #ifndef _DLR_THREAD_MONITOR_H_ */

---