Classes/System/System.cpp

#include "System.h"
#include <iostream.h>
#include "../NetWork/MutexHandler.h"
#include "SystemDefine.h"

System::System(){}

System::~System(){}

void System::println(const String &string)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (string.buffer != null) 
        {
                cout << string.buffer << endl;
        }

   pthread_mutex_unlock(&mut);
}

void System::print(const String &string)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (string.buffer != null) 
        {
                cout << string.buffer;
        }

   pthread_mutex_unlock(&mut);
}

void System::println(String *string)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (string!=null)
        {
                if (string->buffer != null) 
                {
                        cout << string->buffer << endl;
                }
        }

   pthread_mutex_unlock(&mut);
}

void System::print(String *string)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (string!=null)
        {
                if (string->buffer != null) 
                {
                        cout << string->buffer;
                }
        }

   pthread_mutex_unlock(&mut);
}


void System::println(char* input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (input != null) 
        {
                cout << input << endl;
        }

   pthread_mutex_unlock(&mut);
}

void System::print(char* input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (input != null) 
        {
                cout << input;
        }

        pthread_mutex_unlock(&mut);
}

void System::println(unsigned char* input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (input != null) 
        {
                cout << input << endl;
        }

    pthread_mutex_unlock(&mut);
}

void System::print(unsigned char* input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        if (input != null) 
        {
                cout << input;
        }

    pthread_mutex_unlock(&mut);
}

void System::println(int input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

    pthread_mutex_unlock(&mut);
}

void System::print(int input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}

void System::println(float input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

    pthread_mutex_unlock(&mut);
}

void System::print(float input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}

void System::println(short input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

    pthread_mutex_unlock(&mut);
}

void System::print(short input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}

void System::println(unsigned short input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

    pthread_mutex_unlock(&mut);
}

void System::print(unsigned short input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}

void System::println(char input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

        pthread_mutex_unlock(&mut);
}

void System::print(char input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}

void System::println(unsigned char input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input << endl;

   pthread_mutex_unlock(&mut);
}

void System::print(unsigned char input)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    pthread_mutex_lock(&mut);

        cout << input;

    pthread_mutex_unlock(&mut);
}
1	bearsoft	1.1	#include "System.h"
2			#include <iostream.h>
3			#include "../NetWork/MutexHandler.h"
4			#include "SystemDefine.h"
5
6			System::System(){}
7
8			System::~System(){}
9
10			void System::println(const String &string)
11			{
12			pthread_mutex_t mut=MutexHandler::getMutex();
13
14			pthread_mutex_lock(&mut);
15
16			if (string.buffer != null)
17			{
18			cout << string.buffer << endl;
19			}
20
21			pthread_mutex_unlock(&mut);
22			}
23
24			void System::print(const String &string)
25			{
26			pthread_mutex_t mut=MutexHandler::getMutex();
27
28			pthread_mutex_lock(&mut);
29
30			if (string.buffer != null)
31			{
32			cout << string.buffer;
33			}
34
35			pthread_mutex_unlock(&mut);
36			}
37
38			void System::println(String *string)
39			{
40			pthread_mutex_t mut=MutexHandler::getMutex();
41
42			pthread_mutex_lock(&mut);
43
44			if (string!=null)
45			{
46			if (string->buffer != null)
47			{
48			cout << string->buffer << endl;
49			}
50			}
51
52			pthread_mutex_unlock(&mut);
53			}
54
55			void System::print(String *string)
56			{
57			pthread_mutex_t mut=MutexHandler::getMutex();
58
59			pthread_mutex_lock(&mut);
60
61			if (string!=null)
62			{
63			if (string->buffer != null)
64			{
65			cout << string->buffer;
66			}
67			}
68
69			pthread_mutex_unlock(&mut);
70			}
71
72
73			void System::println(char* input)
74			{
75			pthread_mutex_t mut=MutexHandler::getMutex();
76
77			pthread_mutex_lock(&mut);
78
79			if (input != null)
80			{
81			cout << input << endl;
82			}
83
84			pthread_mutex_unlock(&mut);
85			}
86
87			void System::print(char* input)
88			{
89			pthread_mutex_t mut=MutexHandler::getMutex();
90
91			pthread_mutex_lock(&mut);
92
93			if (input != null)
94			{
95			cout << input;
96			}
97
98			pthread_mutex_unlock(&mut);
99			}
100
101			void System::println(unsigned char* input)
102			{
103			pthread_mutex_t mut=MutexHandler::getMutex();
104
105			pthread_mutex_lock(&mut);
106
107			if (input != null)
108			{
109			cout << input << endl;
110			}
111
112			pthread_mutex_unlock(&mut);
113			}
114
115			void System::print(unsigned char* input)
116			{
117			pthread_mutex_t mut=MutexHandler::getMutex();
118
119			pthread_mutex_lock(&mut);
120
121			if (input != null)
122			{
123			cout << input;
124			}
125
126			pthread_mutex_unlock(&mut);
127			}
128
129			void System::println(int input)
130			{
131			pthread_mutex_t mut=MutexHandler::getMutex();
132
133			pthread_mutex_lock(&mut);
134
135			cout << input << endl;
136
137			pthread_mutex_unlock(&mut);
138			}
139
140			void System::print(int input)
141			{
142			pthread_mutex_t mut=MutexHandler::getMutex();
143
144			pthread_mutex_lock(&mut);
145
146			cout << input;
147
148			pthread_mutex_unlock(&mut);
149			}
150
151			void System::println(float input)
152			{
153			pthread_mutex_t mut=MutexHandler::getMutex();
154
155			pthread_mutex_lock(&mut);
156
157			cout << input << endl;
158
159			pthread_mutex_unlock(&mut);
160			}
161
162			void System::print(float input)
163			{
164			pthread_mutex_t mut=MutexHandler::getMutex();
165
166			pthread_mutex_lock(&mut);
167
168			cout << input;
169
170			pthread_mutex_unlock(&mut);
171			}
172
173			void System::println(short input)
174			{
175			pthread_mutex_t mut=MutexHandler::getMutex();
176
177			pthread_mutex_lock(&mut);
178
179			cout << input << endl;
180
181			pthread_mutex_unlock(&mut);
182			}
183
184			void System::print(short input)
185			{
186			pthread_mutex_t mut=MutexHandler::getMutex();
187
188			pthread_mutex_lock(&mut);
189
190			cout << input;
191
192			pthread_mutex_unlock(&mut);
193			}
194
195			void System::println(unsigned short input)
196			{
197			pthread_mutex_t mut=MutexHandler::getMutex();
198
199			pthread_mutex_lock(&mut);
200
201			cout << input << endl;
202
203			pthread_mutex_unlock(&mut);
204			}
205
206			void System::print(unsigned short input)
207			{
208			pthread_mutex_t mut=MutexHandler::getMutex();
209
210			pthread_mutex_lock(&mut);
211
212			cout << input;
213
214			pthread_mutex_unlock(&mut);
215			}
216
217			void System::println(char input)
218			{
219			pthread_mutex_t mut=MutexHandler::getMutex();
220
221			pthread_mutex_lock(&mut);
222
223			cout << input << endl;
224
225			pthread_mutex_unlock(&mut);
226			}
227
228			void System::print(char input)
229			{
230			pthread_mutex_t mut=MutexHandler::getMutex();
231
232			pthread_mutex_lock(&mut);
233
234			cout << input;
235
236			pthread_mutex_unlock(&mut);
237			}
238
239			void System::println(unsigned char input)
240			{
241			pthread_mutex_t mut=MutexHandler::getMutex();
242
243			pthread_mutex_lock(&mut);
244
245			cout << input << endl;
246
247			pthread_mutex_unlock(&mut);
248			}
249
250			void System::print(unsigned char input)
251			{
252			pthread_mutex_t mut=MutexHandler::getMutex();
253
254			pthread_mutex_lock(&mut);
255
256			cout << input;
257
258			pthread_mutex_unlock(&mut);
259			}