*update

1 files changed, 77 insertions, 52 deletions

diff --git a/src/libjin/Thread/Thread.h b/src/libjin/Thread/Thread.h
index 4996705..aeb0d9e 100644
--- a/src/libjin/Thread/Thread.h
+++ b/src/libjin/Thread/Thread.h
@@ -17,54 +17,48 @@ namespace jin
 {
 namespace thread
 {
-    /*
-    * ��������Ӣ�Ӣ�Mutual exclusion����д Mutex����һ�����ڶ��̱߳���У���ֹ�����߳�ͬʱ��ͬһ������Դ
-    * ����ȫ�ֱ��������ж�д�Ļ��ơ���Ŀ��ͨ����������Ƭ��һ��һ�����ٽ�����critical section����ɡ��ٽ�����
-    * ָ����һ��Թ�����Դ���з��ʵĴ��룬����һ�ֻ��ƻ����㷨��һ�����򡢽��̡��߳̿���ӵ�ж���ٽ����򣬵��Dz�
-    * ��һ����Ӧ�û���������Ҫ�˻��Ƶ���Դ�������У���ꡢ���С����������жϴ�������������ڶ����������еĴ����
-    * �������ݡ�ͬ��״̬�ȵ���Դ��ά����Щ��Դ��ͬ����һ�º������Ǻ����ѵģ���Ϊһ���߳̿������κ�һ��ʱ�̱���ͣ
-    * ���ߣ����߻ָ������ѣ���
-    */
+    /**
+     * ��������Ӣ�Ӣ�Mutual exclusion����д Mutex����һ�����ڶ��̱߳���У���ֹ�����߳�ͬʱ��ͬһ������Դ
+     * ����ȫ�ֱ��������ж�д�Ļ��ơ���Ŀ��ͨ����������Ƭ��һ��һ�����ٽ�����critical section����ɡ��ٽ�����
+     * ָ����һ��Թ�����Դ���з��ʵĴ��룬����һ�ֻ��ƻ����㷨��һ�����򡢽��̡��߳̿���ӵ�ж���ٽ����򣬵��Dz�
+     * ��һ����Ӧ�û���������Ҫ�˻��Ƶ���Դ�������У���ꡢ���С����������жϴ�������������ڶ����������еĴ����
+     * �������ݡ�ͬ��״̬�ȵ���Դ��ά����Щ��Դ��ͬ����һ�º������Ǻ����ѵģ���Ϊһ���߳̿������κ�һ��ʱ�̱���ͣ
+     * ���ߣ����߻ָ������ѣ���
+     */
     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.	
-    */
+    /**
+     * 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:
-        union Value
+        
+        union Variant
         {
-            enum
-            {
-                INTEGER, 
-                REAL, 
-                BOOL, 
-                STRING,
-                POINTER
-            } type;
-
             int integer;
-            float real;
             bool boolean;
+            char character;
             const char* cstring;
             void* pointer;
+            float real;
 
-            Value() {};
-            Value(int i) : integer(i), type(INTEGER){};
-            Value(float r) : real(r), type(REAL) {};
-            Value(bool b) : boolean(b), type(BOOL) {};
-            Value(const char* cstr) : cstring(cstr), type(STRING) {};
-            Value(void* p) : pointer(p), type(POINTER) {};
+            Variant() {};
+            Variant(int i) : integer(i) {};
+            Variant(float f) : real(f) {};
+            Variant(bool b) : boolean(b) {};
+            Variant(char c) : character(c) {};
+            Variant(const char* s) : cstring(s) {};
+            Variant(void* p) : pointer(p) {};
         };
 
     private:
@@ -73,36 +67,36 @@ namespace thread
         public:
             ThreadData(Mutex*, Conditional*);
             ~ThreadData();
-            bool exist(const std::string& name);
-            void set(std::string name, Value value);
-            Value get(std::string name);
-            void remove(std::string name);
+            bool exist(int slot);
+            void set(int slot, Variant value);
+            Variant get(int slot);
+            void remove(int slot);
             Conditional* condition;
             Mutex* mutex;
 
+            static const int SLOT_ERROR = -1;
+            static const int SLOT_WARN  = -2;
+
         private:
-            std::map<std::string, Value> share; // threads shared value
-            std::map<std::string, void*> sharevalue;
+            std::map<int, Variant> share; // threads shared value
         };
 
     public:
-        typedef int(ThreadRunner)(void* /*ThreadData*/);
+        typedef void(ThreadRunner)(Thread* thread);
         Thread(const std::string name, ThreadRunner threadfuncs);
         ~Thread();
         bool start();
         void wait();
-        void send(std::string name, Value value);
-        bool receive(std::string name);
-        Value fetch(std::string name);
-        Value demand(std::string name);
+        void send(int slot, Variant value);
+        bool receive(int slot);
+        Variant fetch(int slot);
+        Variant demand(int slot);
         const char* getName();
         bool isRunning();
-        //void kill();
-        //Value peek();
-
-    private:
         void lock();
         void unlock();
+
+    private:
     #if JIN_THREAD_SDL 
         SDL_Thread* handle;         // SDL thread
     #elif JIN_THREAD_CPP 
@@ -112,9 +106,40 @@ namespace thread
         Conditional* condition;     // condition variable
         ThreadRunner* threadRunner; // thread function 
         ThreadData* common;         // threads common data
-        const std::string name;     // thread name 
+        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
 
+        static int ThreadFunciton(void* p);
+
     };
 
 } // thread