1 files changed, 138 insertions, 138 deletions
diff --git a/src/libjin/threads/thread.h b/src/libjin/threads/thread.h
index 2b7ee35..6319e38 100644
--- a/src/libjin/threads/thread.h
+++ b/src/libjin/threads/thread.h
@@ -6,160 +6,160 @@
 #include <string>
 #include <map>
 #if jin_thread == jin_thread_sdl 
-    #include "SDL2/SDL_thread.h"
+	#include "SDL2/SDL_thread.h"
 #elif jin_thread == jin_thread_cpp 
-    #include <thread>
-    #include <mutex>
-    #include <condition_variable>
+	#include <thread>
+	#include <mutex>
+	#include <condition_variable>
 #endif
 
 namespace JinEngine
 {
-    namespace Threads
-    {
-        /**
-         * 互斥锁（英语：英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源
-         * 比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。临界区域
-         * 指的是一块对公共资源进行访问的代码，并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并
-         * 不一定会应用互斥锁。需要此机制的资源的例子有：旗标、队列、计数器、中断处理程序等用于在多条并行运行的代码间
-         * 传递数据、同步状态等的资源。维护这些资源的同步、一致和完整是很困难的，因为一条线程可能在任何一个时刻被暂停
-         * 休眠）或者恢复（唤醒）。
-         */
-        class Mutex;
-        class Conditional;
+	namespace Threads
+	{
+		/**
+		 * 互斥锁（英语：英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源
+		 * 比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。临界区域
+		 * 指的是一块对公共资源进行访问的代码，并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并
+		 * 不一定会应用互斥锁。需要此机制的资源的例子有：旗标、队列、计数器、中断处理程序等用于在多条并行运行的代码间
+		 * 传递数据、同步状态等的资源。维护这些资源的同步、一致和完整是很困难的，因为一条线程可能在任何一个时刻被暂停
+		 * 休眠）或者恢复（唤醒）。
+		 */
+		class Mutex;
+		class Conditional;
 
-        //
-        // Thread::demand    Receive a message from a thread. Wait for the message to exist before returning.    
-        // Thread::getName  Get the name of a thread.    
-        // Thread::kill        Forcefully terminate the thread.    
-        // Thread::peek        Receive a message from a thread, but leave it in the message box.    
-        // Thread::receive  Receive a message from a thread.    
-        // Thread::send        Send a message.    
-        // Thread::set        Set a value.    
-        // Thread::start    Starts the thread.    
-        // Thread::wait        Wait for a thread to finish.
-        //
-        class Thread
-        {
-        public:
-            struct Variant
-            {
-                enum Type
-                {
-                    NONE = 0,
-                    INTERGER, 
-                    BOOLEAN, 
-                    CHARACTER, 
-                    CSTRING, 
-                    POINTER, 
-                    REAL,
-                };
-                Type type;
-                union 
-                {
-                    int integer;
-                    bool boolean;
-                    char character;
-                    const char* cstring;
-                    void* pointer;
-                    float real;
-                };
-                Variant() :type(NONE) {};
-                Variant(const Variant& v){ memcpy(this, &v, sizeof(v)); }
-                Variant(int i) : integer(i), type(INTERGER) {};
-                Variant(float f) : real(f), type(REAL) {};
-                Variant(bool b) : boolean(b), type(BOOLEAN) {};
-                Variant(char c) : character(c), type(CHARACTER) {};
-                Variant(const char* s) : cstring(s), type(CSTRING) {};
-                Variant(void* p) : pointer(p), type(POINTER) {};
-            };
+		//
+		// Thread::demand	Receive a message from a thread. Wait for the message to exist before returning.	
+		// Thread::getName  Get the name of a thread.	
+		// Thread::kill		Forcefully terminate the thread.	
+		// Thread::peek		Receive a message from a thread, but leave it in the message box.	
+		// Thread::receive  Receive a message from a thread.	
+		// Thread::send		Send a message.	
+		// Thread::set		Set a value.	
+		// Thread::start	Starts the thread.	
+		// Thread::wait		Wait for a thread to finish.
+		//
+		class Thread
+		{
+		public:
+			struct Variant
+			{
+				enum Type
+				{
+					NONE = 0,
+					INTERGER, 
+					BOOLEAN, 
+					CHARACTER, 
+					CSTRING, 
+					POINTER, 
+					REAL,
+				};
+				Type type;
+				union 
+				{
+					int integer;
+					bool boolean;
+					char character;
+					const char* cstring;
+					void* pointer;
+					float real;
+				};
+				Variant() :type(NONE) {};
+				Variant(const Variant& v){ memcpy(this, &v, sizeof(v)); }
+				Variant(int i) : integer(i), type(INTERGER) {};
+				Variant(float f) : real(f), type(REAL) {};
+				Variant(bool b) : boolean(b), type(BOOLEAN) {};
+				Variant(char c) : character(c), type(CHARACTER) {};
+				Variant(const char* s) : cstring(s), type(CSTRING) {};
+				Variant(void* p) : pointer(p), type(POINTER) {};
+			};
 
-        private:
-            class ThreadData
-            {
-            public:
-                static const int SLOT_ERROR = -1;
-                static const int SLOT_WARN = -2;
-                static const int SLOT_INFO = -3;
-                static const int SLOT_DEBUG = -4;
+		private:
+			class ThreadData
+			{
+			public:
+				static const int SLOT_ERROR = -1;
+				static const int SLOT_WARN = -2;
+				static const int SLOT_INFO = -3;
+				static const int SLOT_DEBUG = -4;
 
-                ThreadData(Mutex*, Conditional*);
-                ~ThreadData();
-                bool exist(int slot);
-                void set(int slot, Variant value);
-                Variant get(int slot);
-                void remove(int slot);
+				ThreadData(Mutex*, Conditional*);
+				~ThreadData();
+				bool exist(int slot);
+				void set(int slot, Variant value);
+				Variant get(int slot);
+				void remove(int slot);
 
-                Conditional* condition;
-                Mutex* mutex;
+				Conditional* condition;
+				Mutex* mutex;
 
-            private:
-                std::map<int, Variant> share; // threads shared value
+			private:
+				std::map<int, Variant> share; // threads shared value
 
-            };
+			};
 
-        public:
-            typedef int(*ThreadRunner)(void* obj);
+		public:
+			typedef int(*ThreadRunner)(void* obj);
 
-            Thread(const std::string name, ThreadRunner threadfuncs);
-            ~Thread();
-            bool start(void* p);
-            void wait();
-            void send(int slot, const Variant& value);
-            bool receive(int slot);
-            Variant fetch(int slot);
-            Variant demand(int slot);
-            void remove(int slot);
-            const char* getName();
-            bool isRunning();
-            void lock();
-            void unlock();
+			Thread(const std::string name, ThreadRunner threadfuncs);
+			~Thread();
+			bool start(void* p);
+			void wait();
+			void send(int slot, const Variant& value);
+			bool receive(int slot);
+			Variant fetch(int slot);
+			Variant demand(int slot);
+			void remove(int slot);
+			const char* getName();
+			bool isRunning();
+			void lock();
+			void unlock();
 
-        protected:
-        #if jin_thread == jin_thread_sdl 
-            SDL_Thread* handle;         // SDL thread
-        #elif jin_thread == jin_thread_cpp 
-            std::thread* handle;        // cpp thread
-        #endif
-            Mutex* mutex;               // mutex variable
-            Conditional* condition;     // condition variable
-            ThreadRunner threadRunner; // thread function 
-            ThreadData* common;         // threads common data
-            const std::string name;     // thread name, for debugging purposes 
-            /**
-             * https://stackoverflow.com/questions/149932/naming-conventions-for-threads
-             *
-             * Use short names because they don't make the lines in a log file too long.
-             * 
-             * Create names where the important part is at the beginning. Log viewers in a 
-             * graphical user interface tend to have tables with columns, and the thread 
-             * column is usually small or will be made small by you to read everything else.
-             * 
-             * Do not use the word "thread" in the thread name because it is obvious.
-             * 
-             * Make the thread names easily grep-able. Avoid similar sounding thread names
-             * 
-             * If you have several threads of the same nature, enumerate them with IDs that 
-             * are unique to one execution of the application or one log file, whichever fits 
-             * your logging habits.
-             * 
-             * Avoid generalizations like "WorkerThread" (how do you name the next 5 worker 
-             * threads?), "GUIThread" (which GUI? is it for one window? for everything?) or 
-             * "Calculation" (what does it calculate?).
-             * 
-             * If you have a test group that uses thread names to grep your application's log 
-             * files, do not rename your threads after some time. Your testers will hate you for 
-             * doing so. Thread names in well-tested applications should be there to stay.
-             * 
-             * When you have threads that service a network connection, try to include the target 
-             * network address in the thread name (e.g. channel_123.212.123.3). Don't forget about 
-             * enumeration though if there are multiple connections to the same host.
-             */
-            bool running;               // running
+		protected:
+		#if jin_thread == jin_thread_sdl 
+			SDL_Thread* handle;		 // SDL thread
+		#elif jin_thread == jin_thread_cpp 
+			std::thread* handle;		// cpp thread
+		#endif
+			Mutex* mutex;			   // mutex variable
+			Conditional* condition;	 // condition variable
+			ThreadRunner threadRunner; // thread function 
+			ThreadData* common;		 // threads common data
+			const std::string name;	 // thread name, for debugging purposes 
+			/**
+			 * https://stackoverflow.com/questions/149932/naming-conventions-for-threads
+			 *
+			 * Use short names because they don't make the lines in a log file too long.
+			 * 
+			 * Create names where the important part is at the beginning. Log viewers in a 
+			 * graphical user interface tend to have tables with columns, and the thread 
+			 * column is usually small or will be made small by you to read everything else.
+			 * 
+			 * Do not use the word "thread" in the thread name because it is obvious.
+			 * 
+			 * Make the thread names easily grep-able. Avoid similar sounding thread names
+			 * 
+			 * If you have several threads of the same nature, enumerate them with IDs that 
+			 * are unique to one execution of the application or one log file, whichever fits 
+			 * your logging habits.
+			 * 
+			 * Avoid generalizations like "WorkerThread" (how do you name the next 5 worker 
+			 * threads?), "GUIThread" (which GUI? is it for one window? for everything?) or 
+			 * "Calculation" (what does it calculate?).
+			 * 
+			 * If you have a test group that uses thread names to grep your application's log 
+			 * files, do not rename your threads after some time. Your testers will hate you for 
+			 * doing so. Thread names in well-tested applications should be there to stay.
+			 * 
+			 * When you have threads that service a network connection, try to include the target 
+			 * network address in the thread name (e.g. channel_123.212.123.3). Don't forget about 
+			 * enumeration though if there are multiple connections to the same host.
+			 */
+			bool running;			   // running
 
-        };
+		};
 
-    } // namespace Threads
+	} // namespace Threads
 } // namespace JinEngine
 
 #endif // defined(jin_thread)