sync.hpp

Go to the documentation of this file.

/*
  SYNC.hpp  -  generic helper for object based locking and synchronisation

  Copyright (C)         Lumiera.org
    2008,               Christian Thaeter <ct@pipapo.org>
                        Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LIB_SYNC_H
#define LIB_SYNC_H

#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"

#include <mutex>
#include <condition_variable>
#include <chrono>


namespace lib {
  
  namespace sync {
    
    /* ========== policies to define required degree of locking functionality ============== */
    
    template<class MTX>
    struct Condition
      : MTX
      ,  std::condition_variable_any
      {
        
        template<class PRED>
        void
        wait (PRED&& predicate)
          {
            condVar().wait (mutex(), std::forward<PRED> (predicate));
          }
        
        template<class REPR, class PERI, class PRED>
        bool
        wait_for (std::chrono::duration<REPR, PERI> const& timeout, PRED&& predicate)
          {
            return condVar().wait_for (mutex(), timeout, std::forward<PRED> (predicate));
          }
        
        MTX&
        mutex()
          {
            return static_cast<MTX&> (*this);
          }
        std::condition_variable_any&
        condVar()
          {
            return static_cast<std::condition_variable_any&> (*this);
          }
      };
    
    struct NoLocking
      {
        void lock()            { /* boo */ }
        void unlock() noexcept { /* hoo */ }
      };
    
    
    
    /* ========== Object Monitor ============== */
    
    template<class IMPL>
    class Monitor
      : IMPL
      , util::NonCopyable
      {
      public:
        
        void lock()                { IMPL::lock(); }
        void unlock()     noexcept { IMPL::unlock(); }
        
        void notify_one() noexcept { IMPL::notify_one(); }
        void notify_all() noexcept { IMPL::notify_all(); }
        
        template<class PRED>
        void
        wait (PRED&& predicate)
          {
            IMPL::wait (std::forward<PRED>(predicate));
          }
        
        template<class DUR, class PRED>
        bool
        wait_for (DUR const& timeout, PRED&& predicate)
          {
            return IMPL::wait_for (timeout, std::forward<PRED> (predicate));
          }
      };
    
    using NonrecursiveLock_NoWait   = std::mutex;
    using    RecursiveLock_NoWait   = std::recursive_mutex;
    using NonrecursiveLock_Waitable = Condition<std::mutex>;
    using    RecursiveLock_Waitable = Condition<std::recursive_mutex>;
    
    
  } // namespace sync (helpers and building blocks)
  
  
  
  
  
  /* Interface to be used by client code:
   * Inherit from class Sync with a suitable Policy.
   * Then use the embedded Lock class.
   */
  
  /* =======  Policy classes  ======= */
  
  using sync::NonrecursiveLock_NoWait;
  using sync::NonrecursiveLock_Waitable;
  using sync::RecursiveLock_NoWait;
  using sync::RecursiveLock_Waitable;
  
  
  /*********************************************************************/
  template<class CONF = NonrecursiveLock_NoWait>
  class Sync
    {
      using Monitor = sync::Monitor<CONF>;
      mutable Monitor objectMonitor_;
      
    public:
      static Monitor&
      getMonitor(Sync const* forThis)
        {
          REQUIRE (forThis);
          return forThis->objectMonitor_;
        }
      
      
      /*****************************************/
      class Lock
        : util::NonCopyable
        {
          Monitor& mon_;
          
        public:
          template<class X>
          Lock(X* it) : mon_{getMonitor(it)}{ mon_.lock(); }
         ~Lock()                            { mon_.unlock(); }
          
          void notify_one()                 { mon_.notify_one(); }
          void notify_all()                 { mon_.notify_all(); }
          
          template<class PRED>
          void
          wait (PRED&& predicate)
            {
              mon_.wait (std::forward<PRED>(predicate));
            }
          
          template<class DUR, class PRED>
          bool
          wait_for (DUR const& timeout, PRED&& predicate)
            {
              return mon_.wait_for (timeout, std::forward<PRED> (predicate));
            }
          
          template<class X, class PRED>
          Lock(X* it, PRED&& predicate)
            : mon_(getMonitor(it))
            {
              mon_.lock();
              try {
                  mon_.wait (std::forward<PRED>(predicate));
                }
              catch(...)
                {
                  mon_.unlock();
                  throw;
                }
            }
          
        protected:
          Lock(Monitor& m)
            : mon_{m}
            {
              mon_.lock();
            }
          
          Monitor& accessMonitor() { return mon_; }
        };
    };
  
  
} // namespace lumiera
#endif