From 3a0b0356ac2314d6e83ec9b52cddcfb15bf0da8a Mon Sep 17 00:00:00 2001
From: Kargatum <dowlandtop@yandex.com>
Date: Sat, 12 Sep 2020 03:50:48 +0700
Subject: refactor(Core/Common): restyle common lib with astyle (#3461)

---
 src/common/Threading/ThreadingModel.h | 148 +++++++++++++++++-----------------
 1 file changed, 74 insertions(+), 74 deletions(-)

(limited to 'src/common/Threading/ThreadingModel.h')

diff --git a/src/common/Threading/ThreadingModel.h b/src/common/Threading/ThreadingModel.h
index 793580a87e..c2b0560698 100644
--- a/src/common/Threading/ThreadingModel.h
+++ b/src/common/Threading/ThreadingModel.h
@@ -19,120 +19,120 @@ namespace acore
     template<typename MUTEX>
     class GeneralLock
     {
-        public:
+    public:
 
-            GeneralLock(MUTEX& m)
-                : i_mutex(m)
-            {
-                i_mutex.lock();
-            }
+        GeneralLock(MUTEX& m)
+            : i_mutex(m)
+        {
+            i_mutex.lock();
+        }
 
-            ~GeneralLock()
-            {
-                i_mutex.unlock();
-            }
+        ~GeneralLock()
+        {
+            i_mutex.unlock();
+        }
 
-        private:
+    private:
 
-            GeneralLock(const GeneralLock&);
-            GeneralLock& operator=(const GeneralLock&);
-            MUTEX& i_mutex;
+        GeneralLock(const GeneralLock&);
+        GeneralLock& operator=(const GeneralLock&);
+        MUTEX& i_mutex;
     };
 
     template<class T>
     class SingleThreaded
     {
-        public:
+    public:
 
-            struct Lock                                     // empty object
+        struct Lock                                     // empty object
+        {
+            Lock()
+            {
+            }
+            Lock(const T&)
             {
-                Lock()
-                {
-                }
-                Lock(const T&)
-                {
-                }
-
-                Lock(const SingleThreaded<T>&)              // for single threaded we ignore this
-                {
-                }
-            };
+            }
+
+            Lock(const SingleThreaded<T>&)              // for single threaded we ignore this
+            {
+            }
+        };
     };
 
     template<class T, class MUTEX>
     class ObjectLevelLockable
     {
-        public:
+    public:
 
-            ObjectLevelLockable()
-                : i_mtx()
-            {
-            }
+        ObjectLevelLockable()
+            : i_mtx()
+        {
+        }
 
-            friend class Lock;
+        friend class Lock;
 
-            class Lock
-            {
-                public:
+        class Lock
+        {
+        public:
 
-                    Lock(ObjectLevelLockable<T, MUTEX>& host)
-                        : i_lock(host.i_mtx)
-                    {
-                    }
+            Lock(ObjectLevelLockable<T, MUTEX>& host)
+                : i_lock(host.i_mtx)
+            {
+            }
 
-                private:
+        private:
 
-                    GeneralLock<MUTEX> i_lock;
-            };
+            GeneralLock<MUTEX> i_lock;
+        };
 
-        private:
+    private:
 
-            // prevent the compiler creating a copy construct
-            ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
-            ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
+        // prevent the compiler creating a copy construct
+        ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
+        ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
 
-            MUTEX i_mtx;
+        MUTEX i_mtx;
     };
 
     template<class T, class MUTEX>
     class ClassLevelLockable
     {
+    public:
+
+        ClassLevelLockable()
+        {
+        }
+
+        friend class Lock;
+
+        class Lock
+        {
         public:
 
-            ClassLevelLockable()
+            Lock(const T& /*host*/)
             {
+                ClassLevelLockable<T, MUTEX>::si_mtx.lock();
             }
 
-            friend class Lock;
-
-            class Lock
+            Lock(const ClassLevelLockable<T, MUTEX>&)
             {
-                public:
-
-                    Lock(const T& /*host*/)
-                    {
-                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
-                    }
-
-                    Lock(const ClassLevelLockable<T, MUTEX>&)
-                    {
-                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
-                    }
+                ClassLevelLockable<T, MUTEX>::si_mtx.lock();
+            }
 
-                    Lock()
-                    {
-                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
-                    }
+            Lock()
+            {
+                ClassLevelLockable<T, MUTEX>::si_mtx.lock();
+            }
 
-                    ~Lock()
-                    {
-                        ClassLevelLockable<T, MUTEX>::si_mtx.unlock();
-                    }
-            };
+            ~Lock()
+            {
+                ClassLevelLockable<T, MUTEX>::si_mtx.unlock();
+            }
+        };
 
-        private:
+    private:
 
-            static MUTEX si_mtx;
+        static MUTEX si_mtx;
     };
 }
 
-- 
cgit v1.2.3