src/Thread/Guard.hpp

   1 /* Copyright_License {
   2
   3   XCSoar Glide Computer - http://www.xcsoar.org/
   4   Copyright (C) 2000-2013 The XCSoar Project
   5   A detailed list of copyright holders can be found in the file "AUTHORS".
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License
   9   as published by the Free Software Foundation; either version 2
  10   of the License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 }
  21  */
  22
  23 #ifndef XCSOAR_THREAD_GUARD_HPP
  24 #define XCSOAR_THREAD_GUARD_HPP
  25
  26 #include "Poco/RWLock.h"
  27
  28 /**
  29  * This class protects its value with a mutex.  A user may get a lease
  30  * on the value, and the Lease objects locks the mutex during the
  31  * access.
  32  */
  33 template<typename T>
  34 class Guard {
  35 protected:
  36   T &value;
  37   mutable Poco::RWLock mutex;
  38
  39 public:
  40   /**
  41    * A read-only lease on the guarded value.
  42    */
  43   class Lease {
  44     const Guard &guard;
  45
  46   public:
  47     explicit Lease(const Guard &_guard):guard(_guard) {
  48       guard.mutex.readLock();
  49     }
  50
  51     ~Lease() {
  52       guard.mutex.unlock();
  53     }
  54
  55     operator const T&() const {
  56       return guard.value;
  57     }
  58
  59     const T *operator->() const {
  60       return &guard.value;
  61     }
  62   };
  63
  64   /**
  65    * A writable lease on the guarded value.
  66    */
  67   class ExclusiveLease {
  68     Guard &guard;
  69
  70   public:
  71     explicit ExclusiveLease(Guard &_guard):guard(_guard) {
  72       guard.mutex.writeLock();
  73     }
  74
  75     ~ExclusiveLease() {
  76       guard.mutex.unlock();
  77     }
  78
  79     operator const T&() const {
  80       return guard.value;
  81     }
  82
  83     operator T&() {
  84       return guard.value;
  85     }
  86
  87     const T *operator->() const {
  88       return &guard.value;
  89     }
  90
  91     T *operator->() {
  92       return &guard.value;
  93     }
  94   };
  95
  96   /**
  97    * An unprotected writable lease on the value.  This is only allowed
  98    * when the other threads which might access the value are suspended
  99    * (e.g. during startup).
 100    */
 101   class UnprotectedLease {
 102     T &value;
 103
 104   public:
 105     explicit UnprotectedLease(Guard &_guard)
 106       :value(_guard.value) {}
 107
 108     operator const T&() const {
 109       return value;
 110     }
 111
 112     operator T&() {
 113       return value;
 114     }
 115
 116     const T *operator->() const {
 117       return &value;
 118     }
 119
 120     T *operator->() {
 121       return &value;
 122     }
 123   };
 124
 125 public:
 126   explicit Guard(T &_value):value(_value) {}
 127 };
 128
 129 #endif