1 files changed, 50 insertions, 50 deletions

diff --git a/boost/interprocess/sync/interprocess_upgradable_mutex.hpp b/boost/interprocess/sync/interprocess_upgradable_mutex.hpp
index 048407f4b3..8d5a452626 100644
--- a/boost/interprocess/sync/interprocess_upgradable_mutex.hpp
+++ b/boost/interprocess/sync/interprocess_upgradable_mutex.hpp
@@ -30,7 +30,7 @@
 namespace boost {
 namespace interprocess {
 
-//!Wraps a interprocess_upgradable_mutex that can be placed in shared memory and can be 
+//!Wraps a interprocess_upgradable_mutex that can be placed in shared memory and can be
 //!shared between processes. Allows timed lock tries
 class interprocess_upgradable_mutex
 {
@@ -67,13 +67,13 @@ class interprocess_upgradable_mutex
 
    //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
    //!   waiting if necessary until no other thread has exclusive, sharable or
-   //!   upgradable ownership of the mutex or abs_time is reached. 
-   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!   upgradable ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
    //!Throws: interprocess_exception on error.
    bool timed_lock(const boost::posix_time::ptime &abs_time);
 
-   //!Precondition: The thread must have exclusive ownership of the mutex. 
-   //!Effects: The calling thread releases the exclusive ownership of the mutex. 
+   //!Precondition: The thread must have exclusive ownership of the mutex.
+   //!Effects: The calling thread releases the exclusive ownership of the mutex.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock();
 
@@ -87,21 +87,21 @@ class interprocess_upgradable_mutex
 
    //!Effects: The calling thread tries to acquire sharable ownership of the mutex
    //!   without waiting. If no other thread has exclusive ownership
-   //!   of the mutex this succeeds. 
+   //!   of the mutex this succeeds.
    //!Returns: If it can acquire sharable ownership immediately returns true. If it
-   //!   has to wait, returns false. 
+   //!   has to wait, returns false.
    //!Throws: interprocess_exception on error.
    bool try_lock_sharable();
 
    //!Effects: The calling thread tries to acquire sharable ownership of the mutex
    //!   waiting if necessary until no other thread has exclusive
-   //!   ownership of the mutex or abs_time is reached. 
-   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. 
+   //!   ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false.
    //!Throws: interprocess_exception on error.
    bool timed_lock_sharable(const boost::posix_time::ptime &abs_time);
 
-   //!Precondition: The thread must have sharable ownership of the mutex. 
-   //!Effects: The calling thread releases the sharable ownership of the mutex. 
+   //!Precondition: The thread must have sharable ownership of the mutex.
+   //!Effects: The calling thread releases the sharable ownership of the mutex.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_sharable();
 
@@ -115,7 +115,7 @@ class interprocess_upgradable_mutex
 
    //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
    //!   without waiting. If no other thread has exclusive or upgradable ownership
-   //!   of the mutex this succeeds. 
+   //!   of the mutex this succeeds.
    //!Returns: If it can acquire upgradable ownership immediately returns true.
    //!   If it has to wait, returns false.
    //!Throws: interprocess_exception on error.
@@ -124,74 +124,74 @@ class interprocess_upgradable_mutex
    //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
    //!   waiting if necessary until no other thread has exclusive or upgradable
    //!   ownership of the mutex or abs_time is reached.
-   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false.
    //!Throws: interprocess_exception on error.
    bool timed_lock_upgradable(const boost::posix_time::ptime &abs_time);
 
-   //!Precondition: The thread must have upgradable ownership of the mutex. 
-   //!Effects: The calling thread releases the upgradable ownership of the mutex. 
+   //!Precondition: The thread must have upgradable ownership of the mutex.
+   //!Effects: The calling thread releases the upgradable ownership of the mutex.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_upgradable();
 
    //Demotions
 
-   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Precondition: The thread must have exclusive ownership of the mutex.
    //!Effects: The thread atomically releases exclusive ownership and acquires
-   //!   upgradable ownership. This operation is non-blocking. 
+   //!   upgradable ownership. This operation is non-blocking.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_and_lock_upgradable();
 
-   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Precondition: The thread must have exclusive ownership of the mutex.
    //!Effects: The thread atomically releases exclusive ownership and acquires
-   //!   sharable ownership. This operation is non-blocking. 
+   //!   sharable ownership. This operation is non-blocking.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_and_lock_sharable();
 
-   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Precondition: The thread must have upgradable ownership of the mutex.
    //!Effects: The thread atomically releases upgradable ownership and acquires
-   //!   sharable ownership. This operation is non-blocking. 
+   //!   sharable ownership. This operation is non-blocking.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_upgradable_and_lock_sharable();
 
    //Promotions
 
-   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Precondition: The thread must have upgradable ownership of the mutex.
    //!Effects: The thread atomically releases upgradable ownership and acquires
    //!   exclusive ownership. This operation will block until all threads with
-   //!   sharable ownership release their sharable lock. 
+   //!   sharable ownership release their sharable lock.
    //!Throws: An exception derived from interprocess_exception on error.
    void unlock_upgradable_and_lock();
 
-   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Precondition: The thread must have upgradable ownership of the mutex.
    //!Effects: The thread atomically releases upgradable ownership and tries to
    //!   acquire exclusive ownership. This operation will fail if there are threads
-   //!   with sharable ownership, but it will maintain upgradable ownership. 
+   //!   with sharable ownership, but it will maintain upgradable ownership.
    //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
    //!Throws: An exception derived from interprocess_exception on error.
    bool try_unlock_upgradable_and_lock();
 
-   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Precondition: The thread must have upgradable ownership of the mutex.
    //!Effects: The thread atomically releases upgradable ownership and tries to acquire
    //!   exclusive ownership, waiting if necessary until abs_time. This operation will
    //!   fail if there are threads with sharable ownership or timeout reaches, but it
-   //!   will maintain upgradable ownership. 
-   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!   will maintain upgradable ownership.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
    //!Throws: An exception derived from interprocess_exception on error. */
    bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &abs_time);
 
-   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Precondition: The thread must have sharable ownership of the mutex.
    //!Effects: The thread atomically releases sharable ownership and tries to acquire
    //!   exclusive ownership. This operation will fail if there are threads with sharable
    //!   or upgradable ownership, but it will maintain sharable ownership.
-   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
    //!Throws: An exception derived from interprocess_exception on error.
    bool try_unlock_sharable_and_lock();
 
-   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Precondition: The thread must have sharable ownership of the mutex.
    //!Effects: The thread atomically releases sharable ownership and tries to acquire
    //!   upgradable ownership. This operation will fail if there are threads with sharable
-   //!   or upgradable ownership, but it will maintain sharable ownership. 
-   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!   or upgradable ownership, but it will maintain sharable ownership.
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false.
    //!Throws: An exception derived from interprocess_exception on error.
    bool try_unlock_sharable_and_lock_upgradable();
 
@@ -249,7 +249,7 @@ class interprocess_upgradable_mutex
          if(mp_ctrl){
             //Recover upgradable lock
             mp_ctrl->upgradable_in = 1;
-            ++mp_ctrl->num_upr_shar;   
+            ++mp_ctrl->num_upr_shar;  
             //Execute the second half of exclusive locking
             mp_ctrl->exclusive_in = 0;
          }
@@ -260,7 +260,7 @@ class interprocess_upgradable_mutex
    template<int Dummy>
    struct base_constants_t
    {
-      static const unsigned max_readers 
+      static const unsigned max_readers
          = ~(unsigned(3) << (sizeof(unsigned)*CHAR_BIT-2));
    };
    typedef base_constants_t<0> constants;
@@ -309,10 +309,10 @@ inline bool interprocess_upgradable_mutex::try_lock()
 {
    scoped_lock_t lock(m_mut, try_to_lock);
 
-   //If we can't lock or any has there is any exclusive, upgradable 
+   //If we can't lock or any has there is any exclusive, upgradable
    //or sharable mark return false;
-   if(!lock.owns() 
-      || this->m_ctrl.exclusive_in 
+   if(!lock.owns()
+      || this->m_ctrl.exclusive_in
       || this->m_ctrl.num_upr_shar){
       return false;
    }
@@ -387,9 +387,9 @@ inline bool interprocess_upgradable_mutex::try_lock_upgradable()
    //The upgradable lock must fail
    //if an exclusive or upgradable lock has been acquired
    //or there are too many sharable locks
-   if(!lock.owns() 
-      || this->m_ctrl.exclusive_in 
-      || this->m_ctrl.upgradable_in 
+   if(!lock.owns()
+      || this->m_ctrl.exclusive_in
+      || this->m_ctrl.upgradable_in
       || this->m_ctrl.num_upr_shar == constants::max_readers){
       return false;
    }
@@ -414,11 +414,11 @@ inline bool interprocess_upgradable_mutex::timed_lock_upgradable
    //The upgradable lock must block in the first gate
    //if an exclusive or upgradable lock has been acquired
    //or there are too many sharable locks
-   while(this->m_ctrl.exclusive_in 
+   while(this->m_ctrl.exclusive_in
          || this->m_ctrl.upgradable_in
          || this->m_ctrl.num_upr_shar == constants::max_readers){
       if(!this->m_first_gate.timed_wait(lock, abs_time)){
-         return!(this->m_ctrl.exclusive_in 
+         return!(this->m_ctrl.exclusive_in
                || this->m_ctrl.upgradable_in
                || this->m_ctrl.num_upr_shar == constants::max_readers);
       }
@@ -561,7 +561,7 @@ inline void interprocess_upgradable_mutex::unlock_upgradable_and_lock()
    //Simulate unlock_upgradable() without
    //notifying sharables.
    this->m_ctrl.upgradable_in = 0;
-   --this->m_ctrl.num_upr_shar;   
+   --this->m_ctrl.num_upr_shar;  
    //Execute the second half of exclusive locking
    this->m_ctrl.exclusive_in = 1;
 
@@ -584,7 +584,7 @@ inline bool interprocess_upgradable_mutex::try_unlock_upgradable_and_lock()
    }
    //Now unlock upgradable and mark exclusive
    this->m_ctrl.upgradable_in = 0;
-   --this->m_ctrl.num_upr_shar;   
+   --this->m_ctrl.num_upr_shar;  
    this->m_ctrl.exclusive_in = 1;
    return true;
 }
@@ -598,7 +598,7 @@ inline bool interprocess_upgradable_mutex::timed_unlock_upgradable_and_lock
    //Simulate unlock_upgradable() without
    //notifying sharables.
    this->m_ctrl.upgradable_in = 0;
-   --this->m_ctrl.num_upr_shar;   
+   --this->m_ctrl.num_upr_shar;  
    //Execute the second half of exclusive locking
    this->m_ctrl.exclusive_in = 1;
 
@@ -618,10 +618,10 @@ inline bool interprocess_upgradable_mutex::try_unlock_sharable_and_lock()
 {
    scoped_lock_t lock(m_mut, try_to_lock);
 
-   //If we can't lock or any has there is any exclusive, upgradable 
+   //If we can't lock or any has there is any exclusive, upgradable
    //or sharable mark return false;
-   if(!lock.owns() 
-      || this->m_ctrl.exclusive_in 
+   if(!lock.owns()
+      || this->m_ctrl.exclusive_in
       || this->m_ctrl.upgradable_in
       || this->m_ctrl.num_upr_shar != 1){
       return false;
@@ -638,7 +638,7 @@ inline bool interprocess_upgradable_mutex::try_unlock_sharable_and_lock_upgradab
    //The upgradable lock must fail
    //if an exclusive or upgradable lock has been acquired
    if(!lock.owns()
-      || this->m_ctrl.exclusive_in 
+      || this->m_ctrl.exclusive_in
       || this->m_ctrl.upgradable_in){
       return false;
    }