1 files changed, 201 insertions, 201 deletions

diff --git a/src/common/src/std_mutex.h b/src/common/src/std_mutex.h
index ce46a2f5..26eb58b6 100644
--- a/src/common/src/std_mutex.h
+++ b/src/common/src/std_mutex.h
@@ -2,7 +2,7 @@
 #ifndef MUTEX_H_
 #define MUTEX_H_
 
-#define GCC_VER(x,y,z)	((x) * 10000 + (y) * 100 + (z))
+#define GCC_VER(x,y,z)    ((x) * 10000 + (y) * 100 + (z))
 #define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 
 #ifndef __has_include
@@ -46,72 +46,72 @@ namespace std
 class recursive_mutex
 {
 #ifdef _WIN32
-	typedef CRITICAL_SECTION native_type;
+    typedef CRITICAL_SECTION native_type;
 #else
-	typedef pthread_mutex_t native_type;
+    typedef pthread_mutex_t native_type;
 #endif
 
 public:
-	typedef native_type* native_handle_type;
+    typedef native_type* native_handle_type;
 
-	recursive_mutex(const recursive_mutex&) /*= delete*/;
-	recursive_mutex& operator=(const recursive_mutex&) /*= delete*/;
+    recursive_mutex(const recursive_mutex&) /*= delete*/;
+    recursive_mutex& operator=(const recursive_mutex&) /*= delete*/;
 
-	recursive_mutex()
-	{
+    recursive_mutex()
+    {
 #ifdef _WIN32
-		InitializeCriticalSection(&m_handle);
+        InitializeCriticalSection(&m_handle);
 #else
-		pthread_mutexattr_t attr;
-		pthread_mutexattr_init(&attr);
-		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-		pthread_mutex_init(&m_handle, &attr);
+        pthread_mutexattr_t attr;
+        pthread_mutexattr_init(&attr);
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+        pthread_mutex_init(&m_handle, &attr);
 #endif
-	}
+    }
 
-	~recursive_mutex()
-	{
+    ~recursive_mutex()
+    {
 #ifdef _WIN32
-		DeleteCriticalSection(&m_handle);
+        DeleteCriticalSection(&m_handle);
 #else
-		pthread_mutex_destroy(&m_handle);
+        pthread_mutex_destroy(&m_handle);
 #endif
-	}
+    }
 
-	void lock()
-	{
+    void lock()
+    {
 #ifdef _WIN32
-		EnterCriticalSection(&m_handle);
+        EnterCriticalSection(&m_handle);
 #else
-		pthread_mutex_lock(&m_handle);
+        pthread_mutex_lock(&m_handle);
 #endif
-	}
+    }
 
-	void unlock()
-	{
+    void unlock()
+    {
 #ifdef _WIN32
-		LeaveCriticalSection(&m_handle);
+        LeaveCriticalSection(&m_handle);
 #else
-		pthread_mutex_unlock(&m_handle);
+        pthread_mutex_unlock(&m_handle);
 #endif
-	}
+    }
 
-	bool try_lock()
-	{
+    bool try_lock()
+    {
 #ifdef _WIN32
-		return (0 != TryEnterCriticalSection(&m_handle));
+        return (0 != TryEnterCriticalSection(&m_handle));
 #else
-		return !pthread_mutex_trylock(&m_handle);
-#endif	
-	}
+        return !pthread_mutex_trylock(&m_handle);
+#endif    
+    }
 
-	native_handle_type native_handle()
-	{
-		return &m_handle;
-	}
+    native_handle_type native_handle()
+    {
+        return &m_handle;
+    }
 
 private:
-	native_type m_handle;
+    native_type m_handle;
 };
 
 #if !defined(_WIN32) || defined(USE_SRWLOCKS)
@@ -119,74 +119,74 @@ private:
 class mutex
 {
 #ifdef _WIN32
-	typedef SRWLOCK native_type;
+    typedef SRWLOCK native_type;
 #else
-	typedef pthread_mutex_t native_type;
+    typedef pthread_mutex_t native_type;
 #endif
 
 public:
-	typedef native_type* native_handle_type;
+    typedef native_type* native_handle_type;
 
-	mutex(const mutex&) /*= delete*/;
-	mutex& operator=(const mutex&) /*= delete*/;
+    mutex(const mutex&) /*= delete*/;
+    mutex& operator=(const mutex&) /*= delete*/;
 
-	mutex()
-	{
+    mutex()
+    {
 #ifdef _WIN32
-		InitializeSRWLock(&m_handle);
+        InitializeSRWLock(&m_handle);
 #else
-		pthread_mutex_init(&m_handle, NULL);
+        pthread_mutex_init(&m_handle, NULL);
 #endif
-	}
+    }
 
-	~mutex()
-	{
+    ~mutex()
+    {
 #ifdef _WIN32
 #else
-		pthread_mutex_destroy(&m_handle);
+        pthread_mutex_destroy(&m_handle);
 #endif
-	}
+    }
 
-	void lock()
-	{
+    void lock()
+    {
 #ifdef _WIN32
-		AcquireSRWLockExclusive(&m_handle);
+        AcquireSRWLockExclusive(&m_handle);
 #else
-		pthread_mutex_lock(&m_handle);
+        pthread_mutex_lock(&m_handle);
 #endif
-	}
+    }
 
-	void unlock()
-	{
+    void unlock()
+    {
 #ifdef _WIN32
-		ReleaseSRWLockExclusive(&m_handle);
+        ReleaseSRWLockExclusive(&m_handle);
 #else
-		pthread_mutex_unlock(&m_handle);
+        pthread_mutex_unlock(&m_handle);
 #endif
-	}
+    }
 
-	bool try_lock()
-	{
+    bool try_lock()
+    {
 #ifdef _WIN32
-		// XXX TryAcquireSRWLockExclusive requires Windows 7!
-		// return (0 != TryAcquireSRWLockExclusive(&m_handle));
-		return false;
+        // XXX TryAcquireSRWLockExclusive requires Windows 7!
+        // return (0 != TryAcquireSRWLockExclusive(&m_handle));
+        return false;
 #else
-		return !pthread_mutex_trylock(&m_handle);
+        return !pthread_mutex_trylock(&m_handle);
 #endif
-	}
+    }
 
-	native_handle_type native_handle()
-	{
-		return &m_handle;
-	}
+    native_handle_type native_handle()
+    {
+        return &m_handle;
+    }
 
 private:
-	native_type m_handle;
+    native_type m_handle;
 };
 
 #else
-typedef recursive_mutex mutex;	// just use CriticalSections
+typedef recursive_mutex mutex;    // just use CriticalSections
 
 #endif
 
@@ -198,165 +198,165 @@ template <class Mutex>
 class lock_guard
 {
 public:
-	typedef Mutex mutex_type;
+    typedef Mutex mutex_type;
 
-	explicit lock_guard(mutex_type& m)
-		: pm(m)
-	{
-		m.lock();
-	}
+    explicit lock_guard(mutex_type& m)
+        : pm(m)
+    {
+        m.lock();
+    }
 
-	lock_guard(mutex_type& m, adopt_lock_t)
-		: pm(m)
-	{
-	}
+    lock_guard(mutex_type& m, adopt_lock_t)
+        : pm(m)
+    {
+    }
 
-	~lock_guard()
-	{
-		pm.unlock();
-	}
+    ~lock_guard()
+    {
+        pm.unlock();
+    }
 
-	lock_guard(lock_guard const&) /*= delete*/;
-	lock_guard& operator=(lock_guard const&) /*= delete*/;
+    lock_guard(lock_guard const&) /*= delete*/;
+    lock_guard& operator=(lock_guard const&) /*= delete*/;
 
 private:
-	mutex_type& pm;
+    mutex_type& pm;
 };
 
 template <class Mutex>
 class unique_lock
 {
 public:
-	typedef Mutex mutex_type;
+    typedef Mutex mutex_type;
 
-	unique_lock()
-		: pm(NULL), owns(false)
-	{}
+    unique_lock()
+        : pm(NULL), owns(false)
+    {}
 
-	/*explicit*/ unique_lock(mutex_type& m)
-		: pm(&m), owns(true)
-	{
-		m.lock();
-	}
+    /*explicit*/ unique_lock(mutex_type& m)
+        : pm(&m), owns(true)
+    {
+        m.lock();
+    }
 
-	unique_lock(mutex_type& m, defer_lock_t)
-		: pm(&m), owns(false)
-	{}
+    unique_lock(mutex_type& m, defer_lock_t)
+        : pm(&m), owns(false)
+    {}
 
-	unique_lock(mutex_type& m, try_to_lock_t)
-		: pm(&m), owns(m.try_lock())
-	{}
+    unique_lock(mutex_type& m, try_to_lock_t)
+        : pm(&m), owns(m.try_lock())
+    {}
 
-	unique_lock(mutex_type& m, adopt_lock_t)
-		: pm(&m), owns(true)
-	{}
+    unique_lock(mutex_type& m, adopt_lock_t)
+        : pm(&m), owns(true)
+    {}
 
-	//template <class Clock, class Duration>
-	//unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
+    //template <class Clock, class Duration>
+    //unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 
-	//template <class Rep, class Period>
-	//unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
+    //template <class Rep, class Period>
+    //unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 
-	~unique_lock()
-	{
-		if (owns_lock())
-			mutex()->unlock();
-	}
+    ~unique_lock()
+    {
+        if (owns_lock())
+            mutex()->unlock();
+    }
 
 #ifdef USE_RVALUE_REFERENCES
-	unique_lock& operator=(const unique_lock&) /*= delete*/;
+    unique_lock& operator=(const unique_lock&) /*= delete*/;
 
-	unique_lock& operator=(unique_lock&& other)
-	{
+    unique_lock& operator=(unique_lock&& other)
+    {
 #else
-	unique_lock& operator=(const unique_lock& u)
-	{
-		// ugly const_cast to get around lack of rvalue references
-		unique_lock& other = const_cast<unique_lock&>(u);
+    unique_lock& operator=(const unique_lock& u)
+    {
+        // ugly const_cast to get around lack of rvalue references
+        unique_lock& other = const_cast<unique_lock&>(u);
 #endif
-		swap(other);
-		return *this;
-	}
-	
+        swap(other);
+        return *this;
+    }
+    
 #ifdef USE_RVALUE_REFERENCES
-	unique_lock(const unique_lock&) /*= delete*/;
-	
-	unique_lock(unique_lock&& other)
-		: pm(NULL), owns(false)
-	{
+    unique_lock(const unique_lock&) /*= delete*/;
+    
+    unique_lock(unique_lock&& other)
+        : pm(NULL), owns(false)
+    {
 #else
-	unique_lock(const unique_lock& u)
-		: pm(NULL), owns(false)
-	{
-		// ugly const_cast to get around lack of rvalue references
-		unique_lock& other = const_cast<unique_lock&>(u);	
+    unique_lock(const unique_lock& u)
+        : pm(NULL), owns(false)
+    {
+        // ugly const_cast to get around lack of rvalue references
+        unique_lock& other = const_cast<unique_lock&>(u);    
 #endif
-		swap(other);
-	}
-
-	void lock()
-	{
-		mutex()->lock();
-		owns = true;
-	}
-
-	bool try_lock()
-	{
-		owns = mutex()->try_lock();
-		return owns;
-	}
-
-	//template <class Rep, class Period>
-	//bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
-	//template <class Clock, class Duration>
-	//bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-	
-	void unlock()
-	{
-		mutex()->unlock();
-		owns = false;
-	}
-
-	void swap(unique_lock& u)
-	{
-		std::swap(pm, u.pm);
-		std::swap(owns, u.owns);
-	}
-
-	mutex_type* release()
-	{
-		auto const ret = mutex();
-
-		pm = NULL;
-		owns = false;
-
-		return ret;
-	}
-
-	bool owns_lock() const
-	{
-		return owns;
-	}
-
-	//explicit operator bool () const
-	//{
-	//	return owns_lock();
-	//}
-
-	mutex_type* mutex() const
-	{
-		return pm;
-	}
+        swap(other);
+    }
+
+    void lock()
+    {
+        mutex()->lock();
+        owns = true;
+    }
+
+    bool try_lock()
+    {
+        owns = mutex()->try_lock();
+        return owns;
+    }
+
+    //template <class Rep, class Period>
+    //bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+    //template <class Clock, class Duration>
+    //bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+    
+    void unlock()
+    {
+        mutex()->unlock();
+        owns = false;
+    }
+
+    void swap(unique_lock& u)
+    {
+        std::swap(pm, u.pm);
+        std::swap(owns, u.owns);
+    }
+
+    mutex_type* release()
+    {
+        auto const ret = mutex();
+
+        pm = NULL;
+        owns = false;
+
+        return ret;
+    }
+
+    bool owns_lock() const
+    {
+        return owns;
+    }
+
+    //explicit operator bool () const
+    //{
+    //    return owns_lock();
+    //}
+
+    mutex_type* mutex() const
+    {
+        return pm;
+    }
 
 private:
-	mutex_type* pm;
-	bool owns;
+    mutex_type* pm;
+    bool owns;
 };
 
 template <class Mutex>
 void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)
 {
-	x.swap(y);
+    x.swap(y);
 }
 
 }