3b66767e5d99bd8fbf1ae57872c5572688c2f8ce
[scilab.git] / scilab / modules / ast / src / cpp / types / threadId.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
4 *
5 *  This file must be used under the terms of the CeCILL.
6 *  This source file is licensed as described in the file COPYING, which
7 *  you should have received as part of this distribution.  The terms
8 *  are also available at
9 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12
13 #include <map>
14 #include <sstream>
15 #include "core_math.h"
16 #include "threadId.hxx"
17 #include "tostring_common.hxx"
18 #include "scilabWrite.hxx"
19
20 extern "C"
21 {
22 #include "charEncoding.h"
23 #include "os_string.h"
24 }
25
26 namespace types
27 {
28
29 ThreadId::~ThreadId()
30 {
31 }
32
33 ThreadId::ThreadId(__threadId _id, __threadKey _key)
34 {
35     m_threadId = _id;
36     m_threadKey = _key;
37     __InitLock(&m_threadLock);
38     m_threadStatus = Running;
39     m_isInterruptible = true;
40     m_doInterrupt = false;
41 }
42
43 __threadId ThreadId::getThreadId()
44 {
45     return m_threadId;
46 }
47
48 void ThreadId::setThreadId(__threadId _id)
49 {
50     this->m_threadId = _id;
51 }
52
53 __threadKey ThreadId::getKey()
54 {
55     return m_threadKey;
56 }
57
58 void ThreadId::setKey(__threadKey _key)
59 {
60     this->m_threadKey = _key;
61 }
62
63 InternalType* ThreadId::clone()
64 {
65     return this;
66 }
67
68 std::wstring ThreadId::StatusToString(Status _status)
69 {
70     switch (_status)
71     {
72         case Running :
73             return L"Running";
74         case Paused :
75             return L"Paused";
76         case Aborted :
77             return L"Aborted";
78         case Done :
79             return L"Done";
80     }
81     return L"";
82 }
83
84 void ThreadId::setStatus(ThreadId::Status _status)
85 {
86     m_threadStatus = _status;
87 }
88
89 ThreadId::Status ThreadId::getStatus(void)
90 {
91     return m_threadStatus;
92 }
93
94 void ThreadId::suspend()
95 {
96     setStatus(Paused);
97     /*
98     ** BJ: Under Linux / Mac having a lock twice will force thread to wait.
99     ** this will not work under windows. So use native Thread suspend and resume functions.
100     */
101
102 #ifndef _MSC_VER
103     __Lock(&m_threadLock);
104     // UnLock will come if resume is called for that thread.
105     __Lock(&m_threadLock);
106     __UnLock(&m_threadLock);
107 #else
108     __SuspendThread(m_threadId);
109 #endif
110 }
111
112 void ThreadId::resume()
113 {
114     setStatus(Running);
115     /*
116     ** BJ: Lock trick to force thread wait does not work under windows.
117     ** This will release Thread::suspend function.
118     ** Thread waiting in pause GW will then continue and check new thread status (Running)
119     */
120 #ifndef _MSC_VER
121     __UnLock(&m_threadLock);
122 #else
123     __ResumeThread(m_threadId);
124 #endif
125 }
126
127 void ThreadId::abort()
128 {
129     setStatus(Aborted);
130     /*
131     ** BJ: Lock trick to force thread wait does not work under windows.
132     ** This will release Thread::suspend function.
133     ** Thread waiting in pause GW will then continue and check new thread status (Aborted)
134     */
135 #ifndef _MSC_VER
136     __UnLock(&m_threadLock);
137 #else
138     __ResumeThread(m_threadId);
139 #endif
140 }
141
142 bool ThreadId::toString(std::wostringstream& ostr)
143 {
144     ostr << L"ThreadId : " << this << std::endl;
145     ostr << L"Status : " << StatusToString(this->getStatus());
146     return true;
147 }
148
149 void ThreadId::setInterrupt(bool _doInterrupt)
150 {
151     m_doInterrupt = _doInterrupt;
152 }
153
154 bool ThreadId::getInterrupt()
155 {
156     return m_doInterrupt;
157 }
158
159 void ThreadId::setInterruptible(bool _isInterruptible)
160 {
161     m_isInterruptible = _isInterruptible;
162 }
163
164 bool ThreadId::isInterruptible()
165 {
166     return m_isInterruptible;
167 }
168
169 }
170