00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "common.h"
00016 #include "CArch.h"
00017
00018 #undef ARCH_CONSOLE
00019 #undef ARCH_DAEMON
00020 #undef ARCH_FILE
00021 #undef ARCH_LOG
00022 #undef ARCH_MULTITHREAD
00023 #undef ARCH_NETWORK
00024 #undef ARCH_SLEEP
00025 #undef ARCH_STRING
00026 #undef ARCH_SYSTEM
00027 #undef ARCH_TASKBAR
00028 #undef ARCH_TIME
00029
00030
00031 #if SYSAPI_WIN32
00032 # include "CArchConsoleWindows.h"
00033 # include "CArchDaemonWindows.h"
00034 # include "CArchFileWindows.h"
00035 # include "CArchLogWindows.h"
00036 # include "CArchMiscWindows.h"
00037 # include "CArchMultithreadWindows.h"
00038 # include "CArchNetworkWinsock.h"
00039 # include "CArchSleepWindows.h"
00040 # include "CArchStringWindows.h"
00041 # include "CArchSystemWindows.h"
00042 # include "CArchTaskBarWindows.h"
00043 # include "CArchTimeWindows.h"
00044 #elif SYSAPI_UNIX
00045 # include "CArchConsoleUnix.h"
00046 # include "CArchDaemonUnix.h"
00047 # include "CArchFileUnix.h"
00048 # include "CArchLogUnix.h"
00049 # if HAVE_PTHREAD
00050 # include "CArchMultithreadPosix.h"
00051 # endif
00052 # include "CArchNetworkBSD.h"
00053 # include "CArchSleepUnix.h"
00054 # include "CArchStringUnix.h"
00055 # include "CArchSystemUnix.h"
00056 # include "CArchTaskBarXWindows.h"
00057 # include "CArchTimeUnix.h"
00058 #endif
00059
00060 #if !defined(ARCH_CONSOLE)
00061 # error unsupported platform for console
00062 #endif
00063
00064 #if !defined(ARCH_DAEMON)
00065 # error unsupported platform for daemon
00066 #endif
00067
00068 #if !defined(ARCH_FILE)
00069 # error unsupported platform for file
00070 #endif
00071
00072 #if !defined(ARCH_LOG)
00073 # error unsupported platform for logging
00074 #endif
00075
00076 #if !defined(ARCH_MULTITHREAD)
00077 # error unsupported platform for multithreading
00078 #endif
00079
00080 #if !defined(ARCH_NETWORK)
00081 # error unsupported platform for network
00082 #endif
00083
00084 #if !defined(ARCH_SLEEP)
00085 # error unsupported platform for sleep
00086 #endif
00087
00088 #if !defined(ARCH_STRING)
00089 # error unsupported platform for string
00090 #endif
00091
00092 #if !defined(ARCH_SYSTEM)
00093 # error unsupported platform for system
00094 #endif
00095
00096 #if !defined(ARCH_TASKBAR)
00097 # error unsupported platform for taskbar
00098 #endif
00099
00100 #if !defined(ARCH_TIME)
00101 # error unsupported platform for time
00102 #endif
00103
00104
00105
00106
00107
00108 CArch* CArch::s_instance = NULL;
00109
00110 CArch::CArch(ARCH_ARGS* args)
00111 {
00112
00113 assert(s_instance == NULL);
00114 s_instance = this;
00115
00116
00117 m_mt = new ARCH_MULTITHREAD;
00118 m_system = new ARCH_SYSTEM;
00119 m_file = new ARCH_FILE;
00120 m_log = new ARCH_LOG;
00121 m_net = new ARCH_NETWORK;
00122 m_sleep = new ARCH_SLEEP;
00123 m_string = new ARCH_STRING;
00124 m_time = new ARCH_TIME;
00125 m_console = new ARCH_CONSOLE(args);
00126 m_daemon = new ARCH_DAEMON;
00127 m_taskbar = new ARCH_TASKBAR(args);
00128
00129 #if SYSAPI_WIN32
00130 CArchMiscWindows::init();
00131 #endif
00132 }
00133
00134 CArch::~CArch()
00135 {
00136
00137 delete m_taskbar;
00138 delete m_daemon;
00139 delete m_console;
00140 delete m_time;
00141 delete m_string;
00142 delete m_sleep;
00143 delete m_net;
00144 delete m_log;
00145 delete m_file;
00146 delete m_system;
00147 delete m_mt;
00148
00149
00150 s_instance = NULL;
00151 }
00152
00153 CArch*
00154 CArch::getInstance()
00155 {
00156 assert(s_instance != NULL);
00157
00158 return s_instance;
00159 }
00160
00161 void
00162 CArch::openConsole(const char* title)
00163 {
00164 m_console->openConsole(title);
00165 }
00166
00167 void
00168 CArch::closeConsole()
00169 {
00170 m_console->closeConsole();
00171 }
00172
00173 void
00174 CArch::showConsole(bool showIfEmpty)
00175 {
00176 m_console->showConsole(showIfEmpty);
00177 }
00178
00179 void
00180 CArch::writeConsole(const char* str)
00181 {
00182 m_console->writeConsole(str);
00183 }
00184
00185 const char*
00186 CArch::getNewlineForConsole()
00187 {
00188 return m_console->getNewlineForConsole();
00189 }
00190
00191 void
00192 CArch::installDaemon(const char* name,
00193 const char* description,
00194 const char* pathname,
00195 const char* commandLine,
00196 const char* dependencies,
00197 bool allUsers)
00198 {
00199 m_daemon->installDaemon(name, description, pathname,
00200 commandLine, dependencies, allUsers);
00201 }
00202
00203 void
00204 CArch::uninstallDaemon(const char* name, bool allUsers)
00205 {
00206 m_daemon->uninstallDaemon(name, allUsers);
00207 }
00208
00209 int
00210 CArch::daemonize(const char* name, DaemonFunc func)
00211 {
00212 return m_daemon->daemonize(name, func);
00213 }
00214
00215 bool
00216 CArch::canInstallDaemon(const char* name, bool allUsers)
00217 {
00218 return m_daemon->canInstallDaemon(name, allUsers);
00219 }
00220
00221 bool
00222 CArch::isDaemonInstalled(const char* name, bool allUsers)
00223 {
00224 return m_daemon->isDaemonInstalled(name, allUsers);
00225 }
00226
00227 const char*
00228 CArch::getBasename(const char* pathname)
00229 {
00230 return m_file->getBasename(pathname);
00231 }
00232
00233 std::string
00234 CArch::getUserDirectory()
00235 {
00236 return m_file->getUserDirectory();
00237 }
00238
00239 std::string
00240 CArch::getSystemDirectory()
00241 {
00242 return m_file->getSystemDirectory();
00243 }
00244
00245 std::string
00246 CArch::concatPath(const std::string& prefix, const std::string& suffix)
00247 {
00248 return m_file->concatPath(prefix, suffix);
00249 }
00250
00251 void
00252 CArch::openLog(const char* name)
00253 {
00254 m_log->openLog(name);
00255 }
00256
00257 void
00258 CArch::closeLog()
00259 {
00260 m_log->closeLog();
00261 }
00262
00263 void
00264 CArch::showLog(bool showIfEmpty)
00265 {
00266 m_log->showLog(showIfEmpty);
00267 }
00268
00269 void
00270 CArch::writeLog(ELevel level, const char* msg)
00271 {
00272 m_log->writeLog(level, msg);
00273 }
00274
00275 CArchCond
00276 CArch::newCondVar()
00277 {
00278 return m_mt->newCondVar();
00279 }
00280
00281 void
00282 CArch::closeCondVar(CArchCond cond)
00283 {
00284 m_mt->closeCondVar(cond);
00285 }
00286
00287 void
00288 CArch::signalCondVar(CArchCond cond)
00289 {
00290 m_mt->signalCondVar(cond);
00291 }
00292
00293 void
00294 CArch::broadcastCondVar(CArchCond cond)
00295 {
00296 m_mt->broadcastCondVar(cond);
00297 }
00298
00299 bool
00300 CArch::waitCondVar(CArchCond cond, CArchMutex mutex, double timeout)
00301 {
00302 return m_mt->waitCondVar(cond, mutex, timeout);
00303 }
00304
00305 CArchMutex
00306 CArch::newMutex()
00307 {
00308 return m_mt->newMutex();
00309 }
00310
00311 void
00312 CArch::closeMutex(CArchMutex mutex)
00313 {
00314 m_mt->closeMutex(mutex);
00315 }
00316
00317 void
00318 CArch::lockMutex(CArchMutex mutex)
00319 {
00320 m_mt->lockMutex(mutex);
00321 }
00322
00323 void
00324 CArch::unlockMutex(CArchMutex mutex)
00325 {
00326 m_mt->unlockMutex(mutex);
00327 }
00328
00329 CArchThread
00330 CArch::newThread(ThreadFunc func, void* data)
00331 {
00332 return m_mt->newThread(func, data);
00333 }
00334
00335 CArchThread
00336 CArch::newCurrentThread()
00337 {
00338 return m_mt->newCurrentThread();
00339 }
00340
00341 CArchThread
00342 CArch::copyThread(CArchThread thread)
00343 {
00344 return m_mt->copyThread(thread);
00345 }
00346
00347 void
00348 CArch::closeThread(CArchThread thread)
00349 {
00350 m_mt->closeThread(thread);
00351 }
00352
00353 void
00354 CArch::cancelThread(CArchThread thread)
00355 {
00356 m_mt->cancelThread(thread);
00357 }
00358
00359 void
00360 CArch::setPriorityOfThread(CArchThread thread, int n)
00361 {
00362 m_mt->setPriorityOfThread(thread, n);
00363 }
00364
00365 void
00366 CArch::testCancelThread()
00367 {
00368 m_mt->testCancelThread();
00369 }
00370
00371 bool
00372 CArch::wait(CArchThread thread, double timeout)
00373 {
00374 return m_mt->wait(thread, timeout);
00375 }
00376
00377 bool
00378 CArch::isSameThread(CArchThread thread1, CArchThread thread2)
00379 {
00380 return m_mt->isSameThread(thread1, thread2);
00381 }
00382
00383 bool
00384 CArch::isExitedThread(CArchThread thread)
00385 {
00386 return m_mt->isExitedThread(thread);
00387 }
00388
00389 void*
00390 CArch::getResultOfThread(CArchThread thread)
00391 {
00392 return m_mt->getResultOfThread(thread);
00393 }
00394
00395 IArchMultithread::ThreadID
00396 CArch::getIDOfThread(CArchThread thread)
00397 {
00398 return m_mt->getIDOfThread(thread);
00399 }
00400
00401 void
00402 CArch::setSignalHandler(ESignal signal, SignalFunc func, void* userData)
00403 {
00404 m_mt->setSignalHandler(signal, func, userData);
00405 }
00406
00407 void
00408 CArch::raiseSignal(ESignal signal)
00409 {
00410 m_mt->raiseSignal(signal);
00411 }
00412
00413 CArchSocket
00414 CArch::newSocket(EAddressFamily family, ESocketType type)
00415 {
00416 return m_net->newSocket(family, type);
00417 }
00418
00419 CArchSocket
00420 CArch::copySocket(CArchSocket s)
00421 {
00422 return m_net->copySocket(s);
00423 }
00424
00425 void
00426 CArch::closeSocket(CArchSocket s)
00427 {
00428 m_net->closeSocket(s);
00429 }
00430
00431 void
00432 CArch::closeSocketForRead(CArchSocket s)
00433 {
00434 m_net->closeSocketForRead(s);
00435 }
00436
00437 void
00438 CArch::closeSocketForWrite(CArchSocket s)
00439 {
00440 m_net->closeSocketForWrite(s);
00441 }
00442
00443 void
00444 CArch::bindSocket(CArchSocket s, CArchNetAddress addr)
00445 {
00446 m_net->bindSocket(s, addr);
00447 }
00448
00449 void
00450 CArch::listenOnSocket(CArchSocket s)
00451 {
00452 m_net->listenOnSocket(s);
00453 }
00454
00455 CArchSocket
00456 CArch::acceptSocket(CArchSocket s, CArchNetAddress* addr)
00457 {
00458 return m_net->acceptSocket(s, addr);
00459 }
00460
00461 bool
00462 CArch::connectSocket(CArchSocket s, CArchNetAddress name)
00463 {
00464 return m_net->connectSocket(s, name);
00465 }
00466
00467 int
00468 CArch::pollSocket(CPollEntry pe[], int num, double timeout)
00469 {
00470 return m_net->pollSocket(pe, num, timeout);
00471 }
00472
00473 void
00474 CArch::unblockPollSocket(CArchThread thread)
00475 {
00476 m_net->unblockPollSocket(thread);
00477 }
00478
00479 size_t
00480 CArch::readSocket(CArchSocket s, void* buf, size_t len)
00481 {
00482 return m_net->readSocket(s, buf, len);
00483 }
00484
00485 size_t
00486 CArch::writeSocket(CArchSocket s, const void* buf, size_t len)
00487 {
00488 return m_net->writeSocket(s, buf, len);
00489 }
00490
00491 void
00492 CArch::throwErrorOnSocket(CArchSocket s)
00493 {
00494 m_net->throwErrorOnSocket(s);
00495 }
00496
00497 bool
00498 CArch::setNoDelayOnSocket(CArchSocket s, bool noDelay)
00499 {
00500 return m_net->setNoDelayOnSocket(s, noDelay);
00501 }
00502
00503 bool
00504 CArch::setReuseAddrOnSocket(CArchSocket s, bool reuse)
00505 {
00506 return m_net->setReuseAddrOnSocket(s, reuse);
00507 }
00508
00509 std::string
00510 CArch::getHostName()
00511 {
00512 return m_net->getHostName();
00513 }
00514
00515 CArchNetAddress
00516 CArch::newAnyAddr(EAddressFamily family)
00517 {
00518 return m_net->newAnyAddr(family);
00519 }
00520
00521 CArchNetAddress
00522 CArch::copyAddr(CArchNetAddress addr)
00523 {
00524 return m_net->copyAddr(addr);
00525 }
00526
00527 CArchNetAddress
00528 CArch::nameToAddr(const std::string& name)
00529 {
00530 return m_net->nameToAddr(name);
00531 }
00532
00533 void
00534 CArch::closeAddr(CArchNetAddress addr)
00535 {
00536 m_net->closeAddr(addr);
00537 }
00538
00539 std::string
00540 CArch::addrToName(CArchNetAddress addr)
00541 {
00542 return m_net->addrToName(addr);
00543 }
00544
00545 std::string
00546 CArch::addrToString(CArchNetAddress addr)
00547 {
00548 return m_net->addrToString(addr);
00549 }
00550
00551 IArchNetwork::EAddressFamily
00552 CArch::getAddrFamily(CArchNetAddress addr)
00553 {
00554 return m_net->getAddrFamily(addr);
00555 }
00556
00557 void
00558 CArch::setAddrPort(CArchNetAddress addr, int port)
00559 {
00560 m_net->setAddrPort(addr, port);
00561 }
00562
00563 int
00564 CArch::getAddrPort(CArchNetAddress addr)
00565 {
00566 return m_net->getAddrPort(addr);
00567 }
00568
00569 bool
00570 CArch::isAnyAddr(CArchNetAddress addr)
00571 {
00572 return m_net->isAnyAddr(addr);
00573 }
00574
00575 bool
00576 CArch::isEqualAddr(CArchNetAddress a, CArchNetAddress b)
00577 {
00578 return m_net->isEqualAddr(a, b);
00579 }
00580
00581 void
00582 CArch::sleep(double timeout)
00583 {
00584 m_sleep->sleep(timeout);
00585 }
00586
00587 int
00588 CArch::vsnprintf(char* str, int size, const char* fmt, va_list ap)
00589 {
00590 return m_string->vsnprintf(str, size, fmt, ap);
00591 }
00592
00593 int
00594 CArch::convStringMBToWC(wchar_t* dst, const char* src, UInt32 n, bool* errors)
00595 {
00596 return m_string->convStringMBToWC(dst, src, n, errors);
00597 }
00598
00599 int
00600 CArch::convStringWCToMB(char* dst, const wchar_t* src, UInt32 n, bool* errors)
00601 {
00602 return m_string->convStringWCToMB(dst, src, n, errors);
00603 }
00604
00605 IArchString::EWideCharEncoding
00606 CArch::getWideCharEncoding()
00607 {
00608 return m_string->getWideCharEncoding();
00609 }
00610
00611 std::string
00612 CArch::getOSName() const
00613 {
00614 return m_system->getOSName();
00615 }
00616
00617 std::string
00618 CArch::getPlatformName() const
00619 {
00620 return m_system->getPlatformName();
00621 }
00622
00623 void
00624 CArch::addReceiver(IArchTaskBarReceiver* receiver)
00625 {
00626 m_taskbar->addReceiver(receiver);
00627 }
00628
00629 void
00630 CArch::removeReceiver(IArchTaskBarReceiver* receiver)
00631 {
00632 m_taskbar->removeReceiver(receiver);
00633 }
00634
00635 void
00636 CArch::updateReceiver(IArchTaskBarReceiver* receiver)
00637 {
00638 m_taskbar->updateReceiver(receiver);
00639 }
00640
00641 double
00642 CArch::time()
00643 {
00644 return m_time->time();
00645 }