CArch.cpp

00001 /*
00002  * synergy -- mouse and keyboard sharing utility
00003  * Copyright (C) 2002 Chris Schoeneman
00004  * 
00005  * This package is free software you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * found in the file COPYING that should have accompanied this file.
00008  * 
00009  * This package is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
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 // include appropriate architecture implementation
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 // CArch
00106 //
00107 
00108 CArch*                  CArch::s_instance = NULL;
00109 
00110 CArch::CArch(ARCH_ARGS* args)
00111 {
00112     // only once instance of CArch
00113     assert(s_instance == NULL);
00114     s_instance = this;
00115 
00116     // create architecture implementation objects
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     // clean up
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     // no instance
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 }

Generated on Fri Nov 6 00:18:44 2009 for synergy-plus by  doxygen 1.4.7