开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
osutil.inl
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：26k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

osutil.inl：源码内容
  1. /*
  2.  * osutil.inl
  3.  *
  4.  * Operating System Classes Inline Function Definitions
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: osutil.inl,v $
  30.  * Revision 1.74  2000/05/25 11:07:26  robertj
  31.  * Added PConfig::HasKey() function to determine if value actually set.
  32.  *
  33.  * Revision 1.73  2000/04/05 02:50:16  robertj
  34.  * Added microseconds to PTime class.
  35.  *
  36.  * Revision 1.72  2000/01/06 14:09:42  robertj
  37.  * Fixed problems with starting up timers,losing up to 10 seconds
  38.  *
  39.  * Revision 1.71  1999/08/22 12:13:43  robertj
  40.  * Fixed warning when using inlines on older GNU compiler
  41.  *
  42.  * Revision 1.70  1999/07/06 04:45:59  robertj
  43.  * Fixed being able to case an unsigned to a PTimeInterval.
  44.  * Improved resolution of PTimer::Tick() to be millisecond accurate.
  45.  *
  46.  * Revision 1.69  1999/03/09 03:08:39  robertj
  47.  * Changes for new documentation system
  48.  *
  49.  * Revision 1.68  1998/11/30 08:57:17  robertj
  50.  * Fixed problem where if += is used on PFilePath, it no longer may be normalised.
  51.  *
  52.  * Revision 1.67  1998/11/19 05:17:35  robertj
  53.  * Added PWaitAndSignal class for easier mutexing.
  54.  *
  55.  * Revision 1.66  1998/11/01 04:56:52  robertj
  56.  * Added BOOl return value to Parse() to indicate there are parameters available.
  57.  *
  58.  * Revision 1.65  1998/10/30 12:23:56  robertj
  59.  * Added ability to get all key values as a dictionary.
  60.  *
  61.  * Revision 1.64  1998/10/30 05:24:30  robertj
  62.  * Added return value to << and >> operators for shifting arguments.
  63.  *
  64.  * Revision 1.63  1998/10/29 05:35:16  robertj
  65.  * Fixed porblem with GetCount() == 0 if do not call Parse() function.
  66.  *
  67.  * Revision 1.62  1998/10/28 03:26:42  robertj
  68.  * Added multi character arguments (-abc style) and options precede parameters mode.
  69.  *
  70.  * Revision 1.61  1998/10/28 00:59:48  robertj
  71.  * New improved argument parsing.
  72.  *
  73.  * Revision 1.60  1998/09/24 07:24:00  robertj
  74.  * Moved structured fiel into separate module so don't need silly implementation file for GNU C.
  75.  *
  76.  * Revision 1.59  1998/09/23 06:21:04  robertj
  77.  * Added open source copyright license.
  78.  *
  79.  * Revision 1.58  1998/01/26 00:31:38  robertj
  80.  * Added functions to get/set 64bit integers from a PConfig.
  81.  * Added multiply and divide operators to PTimeInterval.
  82.  *
  83.  * Revision 1.57  1998/01/04 08:04:27  robertj
  84.  * Changed gmtime and locatime to use operating system specific functions.
  85.  *
  86.  * Revision 1.56  1997/10/03 13:38:26  robertj
  87.  * Fixed race condition on socket close in Select() function.
  88.  *
  89.  * Revision 1.55  1997/08/07 11:58:02  robertj
  90.  * Added ability to get registry data from other applications and anywhere in system registry.
  91.  *
  92.  * Revision 1.54  1997/02/09 03:55:22  robertj
  93.  * Changed PProcess::Current() from pointer to reference.
  94.  *
  95.  * Revision 1.53  1997/01/12 04:21:39  robertj
  96.  * Added IsPast() and IsFuture() functions for time comparison.
  97.  *
  98.  * Revision 1.52  1996/09/14 13:09:23  robertj
  99.  * Major upgrade:
  100.  *   rearranged sockets to help support IPX.
  101.  *   added indirect channel class and moved all protocols to descend from it,
  102.  *   separating the protocol from the low level byte transport.
  103.  *
  104.  * Revision 1.51  1996/05/23 09:59:04  robertj
  105.  * Added mutex to timer list.
  106.  *
  107.  * Revision 1.50  1996/05/18 09:18:25  robertj
  108.  * Added mutex to timer list.
  109.  *
  110.  * Revision 1.49  1996/05/15 10:09:53  robertj
  111.  * Changed millisecond access functions to get 64 bit integer.
  112.  *
  113.  * Revision 1.48  1996/05/09 12:15:34  robertj
  114.  * Resolved C++ problems with 64 bit PTimeInterval for Mac platform.
  115.  *
  116.  * Revision 1.47  1996/04/15 12:33:04  robertj
  117.  * Fixed SetReadTimeout/SetWriteTimeout to use const reference so works with GNU compiler.
  118.  *
  119.  * Revision 1.46  1996/04/15 10:57:57  robertj
  120.  * Moved some functions from INL to serial.cxx so unix linker can make smaller executables.
  121.  *
  122.  * Revision 1.45  1996/04/14 02:53:32  robertj
  123.  * Split serial and pipe channel into separate compilation units for Linux executable size reduction.
  124.  *
  125.  * Revision 1.44  1996/04/09 03:31:33  robertj
  126.  * Fixed bug in config GetTime() cannot use PTime(0) in western hemisphere.
  127.  *
  128.  * Revision 1.43  1996/03/31 08:48:14  robertj
  129.  * Fixed WriteString() so works with sockets.
  130.  *
  131.  * Revision 1.42  1996/03/17 05:43:21  robertj
  132.  * Changed PTimeInterval to 64 bit integer.
  133.  *
  134.  * Revision 1.41  1996/02/25 03:02:45  robertj
  135.  * Added consts to all GetXxxx functions in PConfig.
  136.  *
  137.  * Revision 1.40  1996/02/15 14:47:33  robertj
  138.  * Fixed bugs in time zone compensation (some in the C library).
  139.  *
  140.  * Revision 1.39  1996/02/13 13:06:55  robertj
  141.  * Changed GetTimeZone() so can specify the standard/daylight time.
  142.  *
  143.  * Revision 1.38  1996/02/08 12:12:01  robertj
  144.  * Changed zone parameter in PTime to indicate the time zone as minutes not enum.
  145.  *
  146.  * Revision 1.37  1996/01/28 14:10:12  robertj
  147.  * Added time functions to PConfig.
  148.  *
  149.  * Revision 1.36  1996/01/28 02:51:59  robertj
  150.  * Added assert into all Compare functions to assure comparison between compatible objects.
  151.  *
  152.  * Revision 1.35  1996/01/03 23:15:34  robertj
  153.  * Fixed some PTime bugs.
  154.  *
  155.  * Revision 1.34  1996/01/03 11:09:33  robertj
  156.  * Added Universal Time and Time Zones to PTime class.
  157.  *
  158.  * Revision 1.33  1995/12/23 03:49:46  robertj
  159.  * Chnaged version numbers.
  160.  * Added directory constructor from C string literal.
  161.  *
  162.  * Revision 1.32  1995/12/10 11:32:44  robertj
  163.  * Added extra user information to processes and applications.
  164.  *
  165.  * Revision 1.31  1995/08/12 22:30:05  robertj
  166.  * Work around for  GNU bug: can't have private copy constructor with multiple inheritance.
  167.  *
  168.  * Revision 1.30  1995/07/31 12:15:44  robertj
  169.  * Removed PContainer from PChannel ancestor.
  170.  *
  171.  * Revision 1.29  1995/04/22 00:49:19  robertj
  172.  * Fixed missing common construct code call in edit box constructor.
  173.  *
  174.  * Revision 1.28  1995/03/12 04:41:16  robertj
  175.  * Moved GetHandle() function from PFile to PChannel.
  176.  *
  177.  * Revision 1.27  1995/01/27  11:11:19  robertj
  178.  * Changed single string default constructor to be section name not file name.
  179.  *
  180.  * Revision 1.26  1995/01/18  09:00:40  robertj
  181.  * Added notifiers to timers.
  182.  *
  183.  * Revision 1.25  1995/01/15  04:51:09  robertj
  184.  * Mac compatibility.
  185.  * Added structure function to structured files.
  186.  *
  187.  * Revision 1.24  1995/01/11  09:45:02  robertj
  188.  * Documentation and normalisation.
  189.  *
  190.  * Revision 1.23  1995/01/09  12:34:25  robertj
  191.  * Removed unnecesary return value from I/O functions.
  192.  *
  193.  * Revision 1.22  1994/10/24  00:07:01  robertj
  194.  * Changed PFilePath and PDirectory so descends from either PString or
  195.  *     PCaselessString depending on the platform.
  196.  *
  197.  * Revision 1.21  1994/10/23  04:49:00  robertj
  198.  * Chnaged PDirectory to descend of PString.
  199.  * Added PDirectory Exists() function.
  200.  * Implemented PPipeChannel.
  201.  *
  202.  * Revision 1.20  1994/09/25  10:41:19  robertj
  203.  * Moved PFile::DestroyContents() to cxx file.
  204.  * Added PTextFile constructors for DOS/NT platforms.
  205.  * Added Pipe channel.
  206.  *
  207.  * Revision 1.19  1994/08/21  23:43:02  robertj
  208.  * Added "remove on close" feature for temporary files.
  209.  * Added "force" option to Remove/Rename etc to override write protection.
  210.  * Removed default argument when of PString type (MSC crashes).
  211.  *
  212.  * Revision 1.18  1994/07/27  05:58:07  robertj
  213.  * Synchronisation.
  214.  *
  215.  * Revision 1.17  1994/07/21  12:33:49  robertj
  216.  * Moved cooperative threads to common.
  217.  *
  218.  * Revision 1.16  1994/07/17  10:46:06  robertj
  219.  * Moved file handle to PChannel.
  220.  *
  221.  * Revision 1.15  1994/07/02  03:03:49  robertj
  222.  * Time interval and timer redesign.
  223.  *
  224.  * Revision 1.14  1994/06/25  11:55:15  robertj
  225.  * Unix version synchronisation.
  226.  *
  227.  * Revision 1.13  1994/04/20  12:17:44  robertj
  228.  * assert stuff
  229.  *
  230.  * Revision 1.12  1994/04/01  14:06:48  robertj
  231.  * Text file streams.
  232.  *
  233.  * Revision 1.11  1994/03/07  07:45:40  robertj
  234.  * Major upgrade
  235.  *
  236.  * Revision 1.10  1994/01/13  03:14:51  robertj
  237.  * Added AsString() function to convert a time to a string.
  238.  *
  239.  * Revision 1.9  1994/01/03  04:42:23  robertj
  240.  * Mass changes to common container classes and interactors etc etc etc.
  241.  *
  242.  * Revision 1.8  1993/12/31  06:47:59  robertj
  243.  * Made inlines optional for debugging purposes.
  244.  *
  245.  * Revision 1.7  1993/08/31  03:38:02  robertj
  246.  * Changed PFile::Status to PFile::Info due to X-Windows compatibility.
  247.  * Added copy constructor and assignement operator due to G++ wierdness.
  248.  *
  249.  * Revision 1.6  1993/08/27  18:17:47  robertj
  250.  * Moved a lot of code from MS-DOS platform specific to common files.
  251.  *
  252.  * Revision 1.5  1993/08/21  04:40:19  robertj
  253.  * Added Copy() function.
  254.  *
  255.  * Revision 1.4  1993/08/21  01:50:33  robertj
  256.  * Made Clone() function optional, default will assert if called.
  257.  *
  258.  * Revision 1.3  1993/07/14  12:49:16  robertj
  259.  * Fixed RCS keywords.
  260.  *
  261.  */
  265. ///////////////////////////////////////////////////////////////////////////////
  266. // PTimeInterval
  268. PINLINE PTimeInterval::PTimeInterval(int millisecs)
  269.   : milliseconds(millisecs) { }
  271. PINLINE PTimeInterval::PTimeInterval(unsigned millisecs)
  272.   : milliseconds(millisecs) { }
  274. PINLINE PTimeInterval::PTimeInterval(PInt64 millisecs)
  275.   : milliseconds(millisecs) { }
  278. PINLINE PObject * PTimeInterval::Clone() const
  279.   { return PNEW PTimeInterval(milliseconds); }
  281. PINLINE PInt64 PTimeInterval::GetMilliSeconds() const
  282.   { return milliseconds; }
  284. PINLINE DWORD PTimeInterval::GetInterval() const
  285.   { return (DWORD)milliseconds; }
  287. PINLINE long PTimeInterval::GetSeconds() const
  288.   { return (long)(milliseconds/1000); }
  290. PINLINE long PTimeInterval::GetMinutes() const
  291.   { return (long)(milliseconds/60000); }
  293. PINLINE int PTimeInterval::GetHours() const
  294.   { return (int)(milliseconds/3600000); }
  296. PINLINE int PTimeInterval::GetDays() const
  297.   { return (int)(milliseconds/86400000); }
  300. PINLINE PTimeInterval PTimeInterval::operator+(const PTimeInterval & t) const
  301.   { return PTimeInterval(milliseconds + t.milliseconds); }
  303. PINLINE PTimeInterval & PTimeInterval::operator+=(const PTimeInterval & t)
  304.   { milliseconds += t.milliseconds; return *this; }
  306. PINLINE PTimeInterval PTimeInterval::operator-(const PTimeInterval & t) const
  307.   { return PTimeInterval(milliseconds - t.milliseconds); }
  309. PINLINE PTimeInterval & PTimeInterval::operator-=(const PTimeInterval & t)
  310.   { milliseconds -= t.milliseconds; return *this; }
  312. PINLINE PTimeInterval PTimeInterval::operator*(int f) const
  313.   { return PTimeInterval(milliseconds * f); }
  315. PINLINE PTimeInterval & PTimeInterval::operator*=(int f)
  316.   { milliseconds *= f; return *this; }
  318. PINLINE PTimeInterval PTimeInterval::operator/(int f) const
  319.   { return PTimeInterval(milliseconds / f); }
  321. PINLINE PTimeInterval & PTimeInterval::operator/=(int f)
  322.   { milliseconds /= f; return *this; }
  325. PINLINE BOOL PTimeInterval::operator==(const PTimeInterval & t) const
  326.   { return milliseconds == t.milliseconds; }
  328. PINLINE BOOL PTimeInterval::operator!=(const PTimeInterval & t) const
  329.   { return milliseconds != t.milliseconds; }
  331. PINLINE BOOL PTimeInterval::operator> (const PTimeInterval & t) const
  332.   { return milliseconds > t.milliseconds; }
  334. PINLINE BOOL PTimeInterval::operator>=(const PTimeInterval & t) const
  335.   { return milliseconds >= t.milliseconds; }
  337. PINLINE BOOL PTimeInterval::operator< (const PTimeInterval & t) const
  338.   { return milliseconds < t.milliseconds; }
  340. PINLINE BOOL PTimeInterval::operator<=(const PTimeInterval & t) const
  341.   { return milliseconds <= t.milliseconds; }
  343. PINLINE BOOL PTimeInterval::operator==(long msecs) const
  344.   { return (long)milliseconds == msecs; }
  346. PINLINE BOOL PTimeInterval::operator!=(long msecs) const
  347.   { return (long)milliseconds != msecs; }
  349. PINLINE BOOL PTimeInterval::operator> (long msecs) const
  350.   { return (long)milliseconds > msecs; }
  352. PINLINE BOOL PTimeInterval::operator>=(long msecs) const
  353.   { return (long)milliseconds >= msecs; }
  355. PINLINE BOOL PTimeInterval::operator< (long msecs) const
  356.   { return (long)milliseconds < msecs; }
  358. PINLINE BOOL PTimeInterval::operator<=(long msecs) const
  359.   { return (long)milliseconds <= msecs; }
  362. ///////////////////////////////////////////////////////////////////////////////
  363. // PTime
  365. PINLINE PObject * PTime::Clone() const
  366.   { return PNEW PTime(theTime, microseconds); }
  368. PINLINE void PTime::PrintOn(ostream & strm) const
  369.   { strm << AsString(); }
  371. PINLINE PInt64 PTime::GetTimestamp() const
  372.   { return theTime*(PInt64)1000000 + microseconds; }
  374. PINLINE time_t PTime::GetTimeInSeconds() const
  375.   { return theTime; }
  377. PINLINE long PTime::GetMicrosecond() const
  378.   { return microseconds; }
  380. PINLINE int PTime::GetSecond() const
  381.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_sec; }
  383. PINLINE int PTime::GetMinute() const
  384.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_min; }
  386. PINLINE int PTime::GetHour() const
  387.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_hour; }
  389. PINLINE int PTime::GetDay() const
  390.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_mday; }
  392. PINLINE PTime::Months PTime::GetMonth() const
  393.   { struct tm ts; return (Months)(os_localtime(&theTime, &ts)->tm_mon+January); }
  395. PINLINE int PTime::GetYear() const
  396.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_year+1900; }
  398. PINLINE PTime::Weekdays PTime::GetDayOfWeek() const
  399.   { struct tm ts; return (Weekdays)os_localtime(&theTime, &ts)->tm_wday; }
  401. PINLINE int PTime::GetDayOfYear() const
  402.   { struct tm ts; return os_localtime(&theTime, &ts)->tm_yday; }
  404. PINLINE BOOL PTime::IsPast() const
  405.   { return theTime < time(NULL); }
  407. PINLINE BOOL PTime::IsFuture() const
  408.   { return theTime > time(NULL); }
  411. PINLINE PString PTime::AsString(const PString & format, int zone) const
  412.   { return AsString((const char *)format, zone); }
  414. PINLINE int PTime::GetTimeZone() 
  415.   { return GetTimeZone(IsDaylightSavings() ? DaylightSavings : StandardTime); }
  418. ///////////////////////////////////////////////////////////////////////////////
  419. // PTimer
  421. PINLINE BOOL PTimer::IsRunning() const
  422.   { return state == Starting || state == Running; }
  424. PINLINE BOOL PTimer::IsPaused() const
  425.   { return state == Paused; }
  427. PINLINE const PNotifier & PTimer::GetNotifier() const
  428.   { return callback; }
  430. PINLINE void PTimer::SetNotifier(const PNotifier & func)
  431.   { callback = func; }
  434. ///////////////////////////////////////////////////////////////////////////////
  436. PINLINE PChannelStreamBuffer::PChannelStreamBuffer(const PChannelStreamBuffer & sbuf)
  437.   : channel(sbuf.channel) { }
  439. PINLINE PChannelStreamBuffer &
  440.           PChannelStreamBuffer::operator=(const PChannelStreamBuffer & sbuf)
  441.   { channel = sbuf.channel; return *this; }
  443. PINLINE PChannel::PChannel(const PChannel &)
  444.   { PAssertAlways("Cannot copy channels"); }
  446. PINLINE PChannel & PChannel::operator=(const PChannel &)
  447.   { PAssertAlways("Cannot assign channels"); return *this; }
  449. PINLINE void PChannel::SetReadTimeout(const PTimeInterval & time)
  450.   { readTimeout = time; }
  452. PINLINE PTimeInterval PChannel::GetReadTimeout() const
  453.   { return readTimeout; }
  455. PINLINE PINDEX PChannel::GetLastReadCount() const
  456.   { return lastReadCount; }
  458. PINLINE void PChannel::SetWriteTimeout(const PTimeInterval & time)
  459.   { writeTimeout = time; }
  461. PINLINE PTimeInterval PChannel::GetWriteTimeout() const
  462.   { return writeTimeout; }
  464. PINLINE PINDEX PChannel::GetLastWriteCount() const
  465.   { return lastWriteCount; }
  467. PINLINE int PChannel::GetHandle() const
  468.   { return os_handle; }
  470. PINLINE PChannel::Errors PChannel::GetErrorCode() const
  471.   { return lastError; }
  473. PINLINE int PChannel::GetErrorNumber() const
  474.   { return osError; }
  476. PINLINE void PChannel::AbortCommandString()
  477.   { abortCommandString = TRUE; }
  480. ///////////////////////////////////////////////////////////////////////////////
  481. // PIndirectChannel
  483. PINLINE PIndirectChannel::~PIndirectChannel()
  484.   { Close(); }
  486. PINLINE PChannel * PIndirectChannel::GetReadChannel() const
  487.   { return readChannel; }
  489. PINLINE PChannel * PIndirectChannel::GetWriteChannel() const
  490.   { return writeChannel; }
  493. ///////////////////////////////////////////////////////////////////////////////
  494. // PDirectory
  496. PINLINE PDirectory::PDirectory()
  497.   : PFilePathString(".") { Construct(); }
  499. PINLINE PDirectory::PDirectory(const char * cpathname)  
  500.   : PFilePathString(cpathname) { Construct(); }
  501.   
  502. PINLINE PDirectory::PDirectory(const PString & pathname)
  503.   : PFilePathString(pathname) { Construct(); }
  504.   
  506. PINLINE void PDirectory::DestroyContents()
  507.   { Close(); PFilePathString::DestroyContents(); }
  509. PINLINE BOOL PDirectory::Exists() const
  510.   { return Exists(*this); }
  512. PINLINE BOOL PDirectory::Change() const
  513.   { return Change(*this); }
  515. PINLINE BOOL PDirectory::Create(int perm) const
  516.   { return Create(*this, perm); }
  518. PINLINE BOOL PDirectory::Remove()
  519.   { Close(); return Remove(*this); }
  522. ///////////////////////////////////////////////////////////////////////////////
  524. PINLINE PFilePath::PFilePath()
  525.   { }
  527. PINLINE PFilePath::PFilePath(const PFilePath & path)
  528.   : PFilePathString(path) { }
  530. PINLINE PFilePath & PFilePath::operator=(const char * cstr)
  531.   { return operator=(PString(cstr)); }
  533. PINLINE PFilePath & PFilePath::operator=(const PFilePath & path)
  534.   { PFilePathString::operator=(path); return *this; }
  536. PINLINE PFilePath & PFilePath::operator+=(const PString & str)
  537.   { operator=(*this + str); return *this; }
  539. PINLINE PFilePath & PFilePath::operator+=(const char * cstr)
  540.   { operator=(*this + cstr); return *this; }
  542. PINLINE PFilePath & PFilePath::operator+=(char ch)
  543.   { operator=(*this + ch); return *this; }
  546. ///////////////////////////////////////////////////////////////////////////////
  548. PINLINE PFile::PFile()
  549.   { os_handle = -1; removeOnClose = FALSE; }
  551. PINLINE PFile::PFile(OpenMode mode, int opts)
  552.   { os_handle = -1; removeOnClose = FALSE; Open(mode, opts); }
  554. PINLINE PFile::PFile(const PFilePath & name, OpenMode mode, int opts)
  555.   { os_handle = -1; removeOnClose = FALSE; Open(name, mode, opts); }
  558. PINLINE BOOL PFile::Exists() const
  559.   { return Exists(path); }
  561. PINLINE BOOL PFile::Access(OpenMode mode)
  562.   { return ConvertOSError(Access(path, mode) ? 0 : -1); }
  564. PINLINE BOOL PFile::Remove(BOOL force)
  565.   { Close(); return ConvertOSError(Remove(path, force) ? 0 : -1); }
  567. PINLINE BOOL PFile::Copy(const PFilePath & newname, BOOL force)
  568.   { return ConvertOSError(Copy(path, newname, force) ? 0 : -1); }
  570. PINLINE BOOL PFile::GetInfo(PFileInfo & info)
  571.   { return ConvertOSError(GetInfo(path, info) ? 0 : -1); }
  573. PINLINE BOOL PFile::SetPermissions(int permissions)
  574.   { return ConvertOSError(SetPermissions(path, permissions) ? 0 : -1); }
  577. PINLINE const PFilePath & PFile::GetFilePath() const
  578.   { return path; }
  579.       
  581. PINLINE PString PFile::GetName() const
  582.   { return path; }
  584. PINLINE off_t PFile::GetPosition() const
  585.   { return _lseek(GetHandle(), 0, SEEK_CUR); }
  588. ///////////////////////////////////////////////////////////////////////////////
  590. PINLINE PTextFile::PTextFile()
  591.   { }
  593. PINLINE PTextFile::PTextFile(OpenMode mode, int opts)
  594.   { Open(mode, opts); }
  596. PINLINE PTextFile::PTextFile(const PFilePath & name, OpenMode mode, int opts)
  597.   { Open(name, mode, opts); }
  600. ///////////////////////////////////////////////////////////////////////////////
  601. // PConfig
  603. #ifdef _PCONFIG
  605. PINLINE PConfig::PConfig(Source src)
  606.   : defaultSection("Options") { Construct(src, "", ""); }
  608. PINLINE PConfig::PConfig(Source src, const PString & appname)
  609.   : defaultSection("Options") { Construct(src, appname, ""); }
  611. PINLINE PConfig::PConfig(Source src, const PString & appname, const PString & manuf)
  612.   : defaultSection("Options") { Construct(src, appname, manuf); }
  614. PINLINE PConfig::PConfig(const PString & section, Source src)
  615.   : defaultSection(section) { Construct(src, "", ""); }
  617. PINLINE PConfig::PConfig(const PString & section, Source src, const PString & appname)
  618.   : defaultSection(section) { Construct(src, appname, ""); }
  620. PINLINE PConfig::PConfig(const PString & section,
  621.                          Source src,
  622.                          const PString & appname,
  623.                          const PString & manuf)
  624.   : defaultSection(section) { Construct(src, appname, manuf); }
  626. PINLINE PConfig::PConfig(const PFilePath & filename, const PString & section)
  627.   : defaultSection(section) { Construct(filename); }
  629. PINLINE void PConfig::SetDefaultSection(const PString & section)
  630.   { defaultSection = section; }
  632. PINLINE PString PConfig::GetDefaultSection() const
  633.   { return defaultSection; }
  635. PINLINE PStringList PConfig::GetKeys() const
  636.   { return GetKeys(defaultSection); }
  638. PINLINE PStringToString PConfig::GetAllKeyValues() const
  639.   { return GetAllKeyValues(defaultSection); }
  641. PINLINE void PConfig::DeleteSection()
  642.   { DeleteSection(defaultSection); }
  644. PINLINE void PConfig::DeleteKey(const PString & key)
  645.   { DeleteKey(defaultSection, key); }
  647. PINLINE BOOL PConfig::HasKey(const PString & key) const
  648.   { return HasKey(defaultSection, key); }
  650. PINLINE PString PConfig::GetString(const PString & key) const
  651.   { return GetString(defaultSection, key, PString()); }
  653. PINLINE PString PConfig::GetString(const PString & key, const PString & dflt) const
  654.   { return GetString(defaultSection, key, dflt); }
  656. PINLINE void PConfig::SetString(const PString & key, const PString & value)
  657.   { SetString(defaultSection, key, value); }
  659. PINLINE BOOL PConfig::GetBoolean(const PString & key, BOOL dflt) const
  660.   { return GetBoolean(defaultSection, key, dflt); }
  662. PINLINE void PConfig::SetBoolean(const PString & key, BOOL value)
  663.   { SetBoolean(defaultSection, key, value); }
  665. PINLINE long PConfig::GetInteger(const PString & key, long dflt) const
  666.   { return GetInteger(defaultSection, key, dflt); }
  668. PINLINE void PConfig::SetInteger(const PString & key, long value)
  669.   { SetInteger(defaultSection, key, value); }
  671. PINLINE PInt64 PConfig::GetInt64(const PString & key, PInt64 dflt) const
  672.   { return GetInt64(defaultSection, key, dflt); }
  674. PINLINE void PConfig::SetInt64(const PString & key, PInt64 value)
  675.   { SetInt64(defaultSection, key, value); }
  677. PINLINE double PConfig::GetReal(const PString & key, double dflt) const
  678.   { return GetReal(defaultSection, key, dflt); }
  680. PINLINE void PConfig::SetReal(const PString & key, double value)
  681.   { SetReal(defaultSection, key, value); }
  683. PINLINE PTime PConfig::GetTime(const PString & key) const
  684.   { return GetTime(defaultSection, key); }
  686. PINLINE PTime PConfig::GetTime(const PString & key, const PTime & dflt) const
  687.   { return GetTime(defaultSection, key, dflt); }
  689. PINLINE void PConfig::SetTime(const PString & key, const PTime & value)
  690.   { SetTime(defaultSection, key, value); }
  693. #endif
  696. ///////////////////////////////////////////////////////////////////////////////
  697. // PArgList
  699. PINLINE void PArgList::SetArgs(int argc, char ** argv)
  700.   { SetArgs(PStringArray(argc, argv)); }
  702. PINLINE BOOL PArgList::Parse(const PString & theArgumentSpec, BOOL optionsBeforeParams)
  703.   { return Parse((const char *)theArgumentSpec, optionsBeforeParams); }
  705. PINLINE BOOL PArgList::HasOption(char option) const
  706.   { return GetOptionCount(option) != 0; }
  708. PINLINE BOOL PArgList::HasOption(const char * option) const
  709.   { return GetOptionCount(option) != 0; }
  711. PINLINE BOOL PArgList::HasOption(const PString & option) const
  712.   { return GetOptionCount(option) != 0; }
  714. PINLINE PINDEX PArgList::GetCount() const
  715.   { return parameterIndex.GetSize()-shift; }
  717. PINLINE PString PArgList::operator[](PINDEX num) const
  718.   { return GetParameter(num); }
  720. PINLINE PArgList & PArgList::operator<<(int sh)
  721.   { Shift(sh); return *this; }
  723. PINLINE PArgList & PArgList::operator>>(int sh)
  724.   { Shift(-sh); return *this; }
  727. ///////////////////////////////////////////////////////////////////////////////
  728. // PSemaphore
  730. PINLINE PWaitAndSignal::PWaitAndSignal(PSemaphore & sem)
  731.   : semaphore(sem) { semaphore.Wait(); }
  733. PINLINE PWaitAndSignal::~PWaitAndSignal()
  734.   { semaphore.Signal(); }
  737. ///////////////////////////////////////////////////////////////////////////////
  738. // PThread
  740. #ifndef P_PLATFORM_HAS_THREADS
  742. PINLINE PThread * PThread::Current()
  743.   { return PProcess::Current().currentThread; }
  745. PINLINE BOOL PThread::IsTerminated() const
  746.   { return status == Terminated; }
  748. PINLINE void PThread::Resume()
  749.   { Suspend(FALSE); }
  751. PINLINE BOOL PThread::IsSuspended() const
  752.   { return suspendCount > 0; }
  754. PINLINE void PThread::SetPriority(Priority priorityLevel)
  755.   { basePriority = priorityLevel; }
  757. PINLINE PThread::Priority PThread::GetPriority() const
  758.   { return basePriority; }
  760. #endif
  763. ///////////////////////////////////////////////////////////////////////////////
  764. // PProcess
  766. PINLINE PArgList & PProcess::GetArguments()
  767.   { return arguments; }
  769. PINLINE const PString & PProcess::GetManufacturer() const
  770.   { return manufacturer; }
  772. PINLINE const PString & PProcess::GetName() const
  773.   { return productName; }
  775. PINLINE const PFilePath & PProcess::GetFile() const
  776.   { return executableFile; }
  778. PINLINE PTimerList * PProcess::GetTimerList()
  779.   { return &timers; }
  781. PINLINE void PProcess::SetTerminationValue(int value)
  782.   { terminationValue = value; }
  784. PINLINE int PProcess::GetTerminationValue() const
  785.   { return terminationValue; }
  789. // End Of File ///////////////////////////////////////////////////////////////