Merge branch '181-commenting' into develop

Author: HerbertKoelman

include/pthread/condition_variable.hpp

@@ -232,7 +232,7 @@ namespace pthread {
          * @throw condition_variable_exception if conditional variable failed to be destroyed (pthread_cond_destroy != 0)
          * @see pthread_cond_destroy
          */
-        ~condition_variable() ;
+        virtual ~condition_variable() ;
 
     private:
 

include/pthread/lock_guard.hpp

@@ -15,71 +15,74 @@
 
 #include "pthread/mutex.hpp"
 
-
 namespace pthread {
 
-  /** \addtogroup concurrency
-   *
-   * @{
-   */
-
-  //class condition_variable ;
-
-  /**
-   This class was designed to encapsulate a mutex and automatically control the lock attribute.
-
-   The lock_guard lock the associated mutex once we instanciate the class and the lock is automatically unlocked
-   once the object is destroyed. This allow us to correlate the lock with the scope of the object.
-
-   @author herbert koelman
-   */
-  template<class MutexType>
-  class lock_guard {
-
-    friend class condition_variable;
-
-  public:
-    /**
-     * The constructor is forced to only accept a mutex object or any object of a subclass.
+    /** \addtogroup concurrency
      *
-     * The mutex is locked up upon completion.
-     *
-     * @param m reference to a valid pthread::mutex
-     */
-    explicit lock_guard(MutexType &m){ //: _mutex(&m) {
-      _mutex = &m ;
-      _mutex->lock();
-    }
-
-    /** The destructor release the guarded mutex.
+     * @{
      */
-    ~lock_guard() {
-      _mutex->unlock();
-    }
 
     /**
-     * Cannot be copied.
-     */
-    lock_guard( const lock_guard &) = delete;
-
-    /** @return a const reference to the guarded mutex
+     * This class was designed to encapsulate a mutex and automatically control the lock attribute.
      *
-     * @deprecated condition_variable is now a friend class
-     */
-    MutexType *internal_mutex() {
-      return _mutex ;
-    }
-
-    /**
-     Desabling the = operator.
+     * The lock_guard lock the associated mutex once we instanciate the class and the lock is automatically unlocked
+     * once the object is destroyed. This allow us to correlate the lock with the scope of the object.
+     *
+     * > *WARN* this is a wrapper and therefore doesn't deal with allocating/deallocating the mutex it is guarding.
+     *
+     * @author herbert koelman
+     * @tparam MutexType a kind of mutex
      */
-    void operator=(lock_guard &) = delete;
-
-  private:
-    MutexType *_mutex;
-  };
-
-  /** @} */
+    template<class MutexType>
+    class lock_guard {
+
+        friend class condition_variable;
+
+    public:
+        /**
+         * The constructor is forced to only accept a mutex object or any object of a subclass.
+         *
+         * > *WARN* The mutex is locked up upon completion.
+         *
+         * @param mutex reference to a valid mutex type.
+         * @see mutex#lock
+         */
+        explicit lock_guard(MutexType &mutex) { //: _mutex(&m) {
+            _mutex = &mutex;
+            _mutex->lock();
+        }
+
+        /** The destructor release the guarded mutex.
+         *
+         * @see mutex#unlock
+         */
+        ~lock_guard() {
+            _mutex->unlock();
+        }
+
+        /** @return a const reference to the guarded mutex
+         *
+         * @deprecated condition_variable is now a friend class
+         * @see condition_variable
+         */
+        MutexType *internal_mutex() {
+            return _mutex;
+        }
+
+        /**Cannot be copied.
+         */
+        lock_guard(const lock_guard &) = delete;
+
+        /**
+         * Desabling the = operator.
+         */
+        void operator=(lock_guard &) = delete;
+
+    private:
+        MutexType *_mutex;
+    };
+
+    /** @} */
 } // namespace pthread
 
 #endif /* pthread_lock_guard_H */