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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbitime.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：44k
源码类别：

生物技术

开发平台：

C/C++

ncbitime.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbitime.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:09:28  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.49
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbitime.cpp,v 1000.4 2004/06/01 19:09:28 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Anton Butanayev, Denis Vakatov, Vladimir Ivanov
  36.  *
  37.  *
  38.  */
  40. #include <ncbi_pch.hpp>
  41. #include <corelib/ncbitime.hpp>
  42. #include <corelib/ncbimtx.hpp>
  43. #include <corelib/ncbithr.hpp>
  44. #include <corelib/ncbi_safe_static.hpp>
  45. #include <stdlib.h>
  47. #if defined(NCBI_OS_MSWIN)
  48. #  include <sys/timeb.h>
  49. #  include <windows.h>
  50. #elif defined(NCBI_OS_UNIX)
  51. #  include <sys/time.h>
  52. #endif
  54. #if defined(NCBI_OS_MAC) || defined(NCBI_COMPILER_MW_MSL)
  55. #  include <OSUtils.h>
  57. typedef struct MyTZDLS {
  58.     long timezone;
  59.     bool daylight;
  60. } MyTZDLS;
  62. static MyTZDLS MyReadLocation()
  63. {
  64.     MachineLocation loc;
  65.     ReadLocation(&loc);
  66.     long tz = loc.u.gmtDelta & 0x00ffffff;
  67.     // Propogate sign bit from bit 23 to bit 31 if West of UTC.
  68.     // (Sign-extend the GMT correction)
  69.     if ((tz & 0x00800000) != 0) {
  70.         tz |= 0xFF000000;
  71.     }
  72.     bool dls = (loc.u.dlsDelta != 0);
  73.     MyTZDLS tzdls = {tz, dls};
  74.     return tzdls;
  75. }
  77. static MyTZDLS sTZDLS = MyReadLocation();
  79. #  define TimeZone()  sTZDLS.timezone
  80. #  define Daylight()  sTZDLS.daylight
  81. #elif defined(__CYGWIN__)
  82. #  define TimeZone() _timezone
  83. #  define Daylight() _daylight
  84. #else
  85. #  define TimeZone()  timezone
  86. #  define Daylight()  daylight
  87. #endif
  89. #if defined(NCBI_OS_DARWIN)  ||  defined(NCBI_OS_BSD)
  90. #  define TIMEZONE_IS_UNDEFINED  1
  91. #endif
  94. BEGIN_NCBI_SCOPE
  97. // Protective mutex
  98. DEFINE_STATIC_FAST_MUTEX(s_TimeMutex);
  99. DEFINE_STATIC_FAST_MUTEX(s_TimeAdjustMutex);
  101. // Store global time format in TLS
  102. static CSafeStaticRef< CTls<string> > s_TlsFormat;
  104. static void s_TlsFormatCleanup(string* fmt, void* /* data */)
  105. {
  106.     delete fmt;
  107. }
  111. //============================================================================
  112. //
  113. //  CTime
  114. //
  115. //============================================================================
  118. // Number of days per month
  119. static int s_DaysInMonth[12] = {
  120.     31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  121. };
  123. // Month names
  124. static const char* kMonthAbbr[12] = {
  125.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  126.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  127. };
  128. static const char* kMonthFull[12] = {
  129.     "January", "February", "March", "April", "May", "June",
  130.     "July", "August", "September", "October", "November", "December"
  131. };
  133. // Day of week names
  134. static const char* kWeekdayAbbr[7] = {
  135.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  136. };
  137. static const char* kWeekdayFull [7] = {
  138.     "Sunday", "Monday", "Tuesday", "Wednesday",
  139.     "Thursday", "Friday", "Saturday"
  140. };
  141.  
  142. // Default value for time format
  143. static const char* kDefaultFormat = "M/D/Y h:m:s";
  145. // Set of the checked format symbols (w,W not included)
  146. static const char* kFormatSymbols = "yYMbBDhmsSzZwW";
  148. // Error messages
  149. static const string kMsgInvalidTime = "CTime:  invalid";
  153. // Get number of days in "date"
  154. static unsigned s_Date2Number(const CTime& date)
  155. {
  156.     unsigned d = date.Day();
  157.     unsigned m = date.Month();
  158.     unsigned y = date.Year();
  159.     unsigned c, ya;
  161.     if (m > 2) {
  162.         m -= 3;
  163.     } else {
  164.         m += 9;
  165.         y--;
  166.     }
  167.     c  = y / 100;
  168.     ya = y - 100 * c;
  169.     
  170.     return ((146097 * c) >> 2) + ((1461 * ya) >> 2) +
  171.             (153 * m + 2) / 5 +  d + 1721119;
  172. }
  175. // Conversion number of days in date format
  176. // timezone value compute on base <t>
  177. static CTime s_Number2Date(unsigned num, const CTime& t)
  178. {
  179.     unsigned d;
  180.     unsigned j = num - 1721119;
  181.     unsigned year;
  182.     unsigned day;
  183.     unsigned month;
  185.     year = (((j<<2) - 1) / 146097);
  186.     j = (j<<2) - 1 - 146097 * year;
  187.     d = (j>>2);
  188.     j = ((d<<2) + 3) / 1461;
  189.     d = (d<<2) + 3 - 1461 * j;
  190.     d = (d + 4) >> 2;
  191.     month = (5*d - 3) / 153;
  192.     d = 5*d - 3 - 153 * month;
  193.     day = (d + 5) / 5;
  194.     year = 100 * year + j;
  196.     if (month < 10) {
  197.         month += 3;
  198.     } else {
  199.         month -= 9;
  200.         year++;
  201.     }
  202.     // Construct new CTime object
  203.     return 
  204.         CTime (year, month, day, t.Hour(), t.Minute(), t.Second(), 
  205.               t.NanoSecond(), t.GetTimeZoneFormat(), t.GetTimeZonePrecision());
  206. }
  209. // Calc <value> + <offset> on module <bound>. 
  210. // Normalized value return in <value> and other part, which above 
  211. // than <bound>, write at <major>.
  212. static void s_Offset(long *value, long offset, long bound, int *major)
  213. {
  214.     *value += offset;
  215.     *major += (int) (*value / bound);
  216.     *value %= bound;
  217.     if (*value < 0) {
  218.         *major -= 1;
  219.         *value += bound;
  220.     }
  221. }
  224. CTime::CTime(const CTime& t)
  225. {
  226.     *this = t;
  227. }
  230. CTime::CTime(int year, int yearDayNumber, ETimeZone tz, ETimeZonePrecision tzp)
  231. {
  232.     Clear();
  233.     m_Tz = tz;
  234.     m_TzPrecision = tzp;
  236.     CTime t = CTime(year, 1, 1);
  237.     t += yearDayNumber - 1;
  238.     m_Year  = t.Year();
  239.     m_Month = t.Month();
  240.     m_Day   = t.Day();
  241. }
  244. void CTime::x_VerifyFormat(const string& fmt)
  245. {
  246.     // Check for duplicated format symbols...
  247.     const int kSize = 256;
  248.     int count[kSize];
  249.     for (int i = 0;  i < kSize;  i++) {
  250.         count[i] = 0;
  251.     }
  252.     ITERATE(string, it, fmt) {
  253.         if (strchr(kFormatSymbols, *it) != 0  &&
  254.             ++count[(unsigned int) *it] > 1) {
  255.             NCBI_THROW(CTimeException, eFormat, "CTime's format is incorrect");
  256.         }
  257.     }
  258. }
  261. void CTime::x_Init(const string& str, const string& fmt)
  262. {
  263.     Clear();
  265.     if ( str.empty() ) {
  266.         return;
  267.     }
  268.     
  269.     const char* fff;
  270.     const char* sss = str.c_str();
  271. #if ! defined(TIMEZONE_IS_UNDEFINED)
  272.     bool  adjust_needed = false;
  273.     long  adjust_tz     = 0;
  274. #endif
  276.     int weekday = -1;
  277.     for (fff = fmt.c_str();  *fff != '';  fff++) {
  279.         // Non-format symbols
  280.         if (strchr(kFormatSymbols, *fff) == 0) {
  282.             if (*fff == *sss) {
  283.                 sss++;
  284.                 continue;  // skip matching non-format symbols
  285.             }
  286.             break;  // error: non-matching non-format symbols
  287.         }
  289.         // Month
  290.         if (*fff == 'b'  ||  *fff == 'B') {
  291.             const char** name;
  292.             if (*fff == 'b') {
  293.                 name = kMonthAbbr;
  294.             } else {
  295.                 name = kMonthFull;
  296.             }
  297.             for (unsigned char i = 0;  i < 12;  i++) {
  298.                 size_t namelen = strlen(*name);
  299.                 if (strncmp(sss, *name, namelen) == 0) {
  300.                     sss += namelen;
  301.                     m_Month = i + 1;
  302.                     break;
  303.                 }
  304.                 name++;
  305.             }
  306.             continue;
  307.         }
  309.         // Day of week
  310.         if (*fff == 'w'  ||  *fff == 'W') {
  311.             const char** day = (*fff == 'w') ? kWeekdayAbbr : kWeekdayFull;
  312.             for (unsigned char i = 0;  i < 7;  i++) {
  313.                 size_t len = strlen(*day);
  314.                 if (strncmp(sss, *day, len) == 0) {
  315.                     sss += len;
  316.                     weekday = i;
  317.                     break;
  318.                 }
  319.                 day++;
  320.             }
  321.             continue;
  322.         }
  324.         // Timezone (GMT time) 
  325.         if (*fff == 'Z') {
  326.             if (strncmp(sss, "GMT", 3) == 0) {
  327.                 m_Tz = eGmt;
  328.                 sss += 3;
  329.             } else {
  330.                 m_Tz = eLocal;
  331.                 if (fff[1] == ' ') fff++;
  332.             }
  333.             continue;
  334.         }
  336.         // Timezone (local time in format GMT+HHMM)
  337.         if (*fff == 'z') {
  338. #if defined(TIMEZONE_IS_UNDEFINED)
  339.             ERR_POST("Format symbol 'z' is unsupported on this platform");
  340. #else
  341.             m_Tz = eLocal;
  342.             if (strncmp(sss, "GMT", 3) == 0) {
  343.                 sss += 3;
  344.             }
  345.             while ( isspace(*sss) ) {
  346.                 sss++; 
  347.             }
  348.             int sign = (*sss == '+') ? 1 : ((*sss == '-') ? -1 : 0);
  349.             if ( sign ) {
  350.                 sss++;
  351.             } else {
  352.                 sign = 1;
  353.             }
  354.             long x_hour = 0;
  355.             long x_min  = 0;
  357.             char value_str[3];
  358.             char* s = value_str;
  359.             for (size_t len = 2; len != 0  &&  *sss != ''  &&  isdigit(*sss);  len--) {
  360.                 *s++ = *sss++; 
  361.             }
  362.             *s = '';
  363.             try {
  364.                 x_hour = NStr::StringToLong(value_str);
  365.             }
  366.             catch (CStringException) {
  367.                 x_hour = 0;
  368.             }
  369.             try {
  370.                 if ( *sss != '' ) {
  371.                     s = value_str;
  372.                     for (size_t len = 2; len != 0  &&  *sss != ''  &&  isdigit(*sss);  len--) {
  373.                         *s++ = *sss++; 
  374.                     }
  375.                     *s = '';
  376.                     x_min = NStr::StringToLong(value_str, 10, NStr::eCheck_Skip);
  377.                 }
  378.             }
  379.             catch (CStringException) {
  380.                 x_min = 0;
  381.             }
  382.             adjust_needed = true;
  383.             adjust_tz = sign * (x_hour * 60 + x_min) * 60;
  384. #endif
  385.             continue;
  386.         }
  388.         // Other format symbols -- read the next data ingredient
  389.         char value_str[10];
  390.         char* s = value_str;
  391.         for (size_t len = (*fff == 'Y') ? 4 : ((*fff == 'S') ? 9 : 2);
  392.              len != 0  &&  *sss != ''  &&  isdigit(*sss);  len--) {
  393.             *s++ = *sss++; 
  394.         }
  395.         *s = '';
  397.         long value = NStr::StringToLong(value_str);
  399.         switch ( *fff ) {
  400.         case 'Y':
  401.             m_Year = (int) value;
  402.             break;
  403.         case 'y':
  404.             if (value >= 0  &&  value < 50) {
  405.                 value += 2000;
  406.             } else if (value >= 50  &&  value < 100) {
  407.                 value += 1900;
  408.             }
  409.             m_Year = (int) value;
  410.             break;
  411.         case 'M':
  412.             m_Month = (unsigned char) value;
  413.             break;
  414.         case 'D':
  415.             m_Day = (unsigned char) value;
  416.             break;
  417.         case 'h':
  418.             m_Hour = (unsigned char) value;
  419.             break;
  420.         case 'm':
  421.             m_Minute = (unsigned char) value;
  422.             break;
  423.         case 's':
  424.             m_Second = (unsigned char) value;
  425.             break;
  426.         case 'S':
  427.             m_NanoSecond = value;
  428.             break;
  429.         default:
  430.             NCBI_THROW(CTimeException, eFormat, "CTime:  format is incorrect");
  431.         }
  432.     }
  434.     // Check on errors
  435.     if (weekday != -1  &&  weekday != DayOfWeek()) {
  436.         NCBI_THROW(CTimeException, eInvalid, "CTime:  invalid day of week");
  437.     }
  439.     if (*fff != ''  ||  *sss != '') {
  440.         NCBI_THROW(CTimeException, eFormat, "CTime:  format is incorrect");
  441.     }
  443.     if ( !IsValid() ) {
  444.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  445.     }
  446. #if ! defined(TIMEZONE_IS_UNDEFINED)
  447.     // Adjust time for current timezone
  448.     if ( adjust_needed  &&  adjust_tz != -TimeZone() ) {
  449.         AddSecond(-TimeZone() - adjust_tz);
  450.     }
  451. #endif
  452. }
  455. CTime::CTime(int year, int month, int day, int hour, 
  456.              int minute, int second, long nanosecond,
  457.              ETimeZone tz, ETimeZonePrecision tzp)
  458. {
  459.     m_Year           = year;
  460.     m_Month          = month;
  461.     m_Day            = day;
  462.     m_Hour           = hour;
  463.     m_Minute         = minute;
  464.     m_Second         = second;
  465.     m_NanoSecond     = nanosecond;
  466.     m_Tz             = tz;
  467.     m_TzPrecision    = tzp;
  468.     m_AdjustTimeDiff = 0;
  470.     if ( !IsValid() ) {
  471.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  472.     }
  473. }
  476. CTime::CTime(EInitMode mode, ETimeZone tz, ETimeZonePrecision tzp)
  477. {
  478.     m_Tz = tz;
  479.     m_TzPrecision = tzp;
  480.     if (mode == eCurrent) {
  481.         SetCurrent();
  482.     } else {
  483.         Clear();
  484.     }
  485. }
  487. CTime::CTime(time_t t, ETimeZonePrecision tzp)
  488. {
  489.     m_Tz = eGmt;
  490.     m_TzPrecision = tzp;
  491.     SetTimeT(t);
  492. }
  495. CTime::CTime(const string& str, const string& fmt, 
  496.              ETimeZone tz, ETimeZonePrecision tzp)
  497. {
  498.     m_Tz = tz;
  499.     m_TzPrecision = tzp;
  501.     if (fmt.empty()) {
  502.         x_Init(str, GetFormat());
  503.     } else {
  504.         x_VerifyFormat(fmt);
  505.         x_Init(str, fmt);
  506.     }
  507. }
  510. void CTime::SetYear(int year)
  511. {
  512.     m_Year = year;
  513.     int n_days = DaysInMonth();
  514.     if ( m_Day > n_days ) {
  515.         m_Day = n_days;
  516.     }
  517.     if ( !IsValid() ) {
  518.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  519.     }
  520. }
  523. void CTime::SetMonth(int month)
  524. {
  525.     m_Month = month;
  526.     int n_days = DaysInMonth();
  527.     if ( m_Day > n_days ) {
  528.         m_Day = n_days;
  529.     }
  530.     if ( !IsValid() ) {
  531.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  532.     }
  533. }
  536. void CTime::SetDay(int day)
  537. {
  538.     m_Day = day;
  539.     int n_days = DaysInMonth();
  540.     if ( m_Day > n_days ) {
  541.         m_Day = n_days;
  542.     }
  543.     if ( !IsValid() ) {
  544.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  545.     }
  546. }
  549. void CTime::SetHour(int hour)
  550. {
  551.     m_Hour = hour;
  552.     if ( !IsValid() ) {
  553.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  554.     }
  555. }
  558. void CTime::SetMinute(int minute)
  559. {
  560.     m_Minute = minute;
  561.     if ( !IsValid() ) {
  562.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  563.     }
  564. }
  567. void CTime::SetSecond(int second)
  568. {
  569.     m_Second = second;
  570.     if ( !IsValid() ) {
  571.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  572.     }
  573. }
  576. void CTime::SetNanoSecond(long nanosecond)
  577. {
  578.     m_NanoSecond = nanosecond;
  579.     if ( !IsValid() ) {
  580.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  581.     }
  582. }
  585. int CTime::YearDayNumber(void) const
  586. {
  587.     unsigned first = s_Date2Number(CTime(Year(), 1, 1));
  588.     unsigned self  = s_Date2Number(*this);
  589.     _ASSERT(first <= self  &&  self < first + (IsLeap() ? 366 : 365));
  590.     return (int) (self - first + 1);
  591. }
  594. int CTime::YearWeekNumber(EDayOfWeek first_day_of_week) const
  595. {
  596.     if (first_day_of_week > eSaturday) {
  597.         NCBI_THROW(CTimeException, eArgument,
  598.                    "CTime:  first day of week parameter is incorrect");
  599.     }
  601.     int week_num = 0;
  602.     int wday = DayOfWeek();
  604.     // Adjust day of week (from default Sunday)
  605.     wday -= first_day_of_week;
  606.     if (wday < 0) {
  607.         wday += 7;
  608.     }
  610.     // Calculate week number
  611.     int yday = YearDayNumber() - 1;  // YearDayNumber() returns 1..366
  612.     if (yday >= wday) {
  613.         week_num = yday / 7;
  614.         if ( (yday % 7) >= wday ) {
  615.             week_num++;
  616.         }
  617.     }
  618.     // Adjust range from [0..53] to [1..54]
  619.     return week_num + 1;
  620. }
  623. int CTime::MonthWeekNumber(EDayOfWeek first_day_of_week) const
  624. {
  625.     CTime first_of_month(Year(), Month(), 1);
  626.     int week_num_first   = first_of_month.YearWeekNumber(first_day_of_week);
  627.     int week_num_current = YearWeekNumber(first_day_of_week);
  628.     return week_num_current - week_num_first + 1;
  629. }
  632. int CTime::DayOfWeek(void) const 
  633. {
  634.     int y = Year();
  635.     int m = Month();
  637.     y -= int(m < 3);
  638.     return (y + y/4 - y/100 + y/400 + "-bed=pen+mad."[m] + Day()) % 7;
  639. }
  642. int CTime::DaysInMonth(void) const 
  643. {
  644.     int n_days = s_DaysInMonth[Month()-1];
  645.     if (n_days == 0) {
  646.         n_days = IsLeap() ? 29 : 28;
  647.     }
  648.     return n_days;
  649. }
  652. void CTime::SetFormat(const string& fmt)
  653. {
  654.     x_VerifyFormat(fmt);
  655.     // Here we do not need to delete a previous value stored in the TLS.
  656.     // The TLS will destroy it using s_TlsFormatCleanup().
  657.     string* format = new string(fmt);
  658.     s_TlsFormat->SetValue(format, s_TlsFormatCleanup);
  659. }
  662. string CTime::GetFormat(void)
  663. {
  664.     string* format = s_TlsFormat->GetValue();
  665.     if ( !format ) {
  666.         return kDefaultFormat;
  667.     }
  668.     return *format;
  669. }
  672. int CTime::MonthNameToNum(const string& month)
  673. {
  674.     const char** name = month.length() == 3 ? kMonthAbbr : kMonthFull; 
  675.     for (int i = 0; i < 12; i++) {
  676.         if (month == name[i]) {
  677.             return i+1;
  678.         }
  679.     }
  680.     // Always throw exceptions here. 
  681.     // Next if statements avoid compilation warnings.
  682.     if ( name ) {
  683.         NCBI_THROW(CTimeException, eInvalid, "CTime:  invalid month name");
  684.     }
  685.     return -1;
  686. }
  689. string CTime::MonthNumToName(int month, ENameFormat format)
  690. {
  691.     if (month < 1  ||  month > 12) {
  692.         NCBI_THROW(CTimeException, eInvalid, "CTime:  invalid month number");
  693.     }
  694.     month--;
  695.     return format == eFull ? kMonthFull[month] : kMonthAbbr[month];
  696. }
  699. int CTime::DayOfWeekNameToNum(const string& day)
  700. {
  701.     const char** name = day.length() == 3 ? kWeekdayAbbr : kWeekdayFull; 
  702.     for (int i = 0; i <= 6; i++) {
  703.         if (day == name[i]) {
  704.             return i;
  705.         }
  706.     }
  707.     // Always throw exceptions here. 
  708.     // Next if statements avoid compilation warnings.
  709.     if ( name ) {
  710.         NCBI_THROW(CTimeException,eInvalid,"CTime:  invalid day of week name");
  711.     }
  712.     return -1;
  713. }
  716. string CTime::DayOfWeekNumToName(int day, ENameFormat format)
  717. {
  718.     if (day < 0  ||  day > 6) {
  719.         return kEmptyStr;
  720.     }
  721.     return format == eFull ? kWeekdayFull[day] : kWeekdayAbbr[day];
  722. }
  725. static void s_AddZeroPadInt(string& str, long value, SIZE_TYPE len = 2)
  726. {
  727.     string s_value = NStr::IntToString(value);
  728.     if (s_value.length() < len) {
  729.         str.insert(str.end(), len - s_value.length(), '0');
  730.     }
  731.     str += s_value;
  732. }
  735. string CTime::AsString(const string& fmt, long out_tz) const
  736. {
  737.     if ( fmt.empty() ) {
  738.         return AsString(GetFormat());
  739.     }
  741.     x_VerifyFormat(fmt);
  743.     if ( !IsValid() ) {
  744.         NCBI_THROW(CTimeException, eInvalid, kMsgInvalidTime);
  745.     }
  747.     if ( IsEmpty() ) {
  748.         return kEmptyStr;
  749.     }
  751.     const CTime* t = this;
  752.     CTime* t_out = 0;
  753.     // Adjust time for output timezone
  754.     if (out_tz != eCurrentTimeZone) {
  755. #if defined(TIMEZONE_IS_UNDEFINED)
  756.     ERR_POST("Output timezone is unsupported on this platform");
  757. #else
  758.         if (out_tz != TimeZone()) {
  759.             t_out = new CTime(*this);
  760.             t_out->AddSecond(TimeZone() - out_tz);
  761.             t = t_out;
  762.         }
  763. #endif
  764.     }
  765.     
  766.     string str;
  767.     ITERATE(string, it, fmt) {
  768.         switch ( *it ) {
  769.         case 'y': s_AddZeroPadInt(str, t->Year() % 100);    break;
  770.         case 'Y': s_AddZeroPadInt(str, t->Year(), 4);       break;
  771.         case 'M': s_AddZeroPadInt(str, t->Month());         break;
  772.         case 'b': str += kMonthAbbr[t->Month()-1];          break;
  773.         case 'B': str += kMonthFull[t->Month()-1];          break;
  774.         case 'D': s_AddZeroPadInt(str, t->Day());           break;
  775.         case 'h': s_AddZeroPadInt(str, t->Hour());          break;
  776.         case 'm': s_AddZeroPadInt(str, t->Minute());        break;
  777.         case 's': s_AddZeroPadInt(str, t->Second());        break;
  778.         case 'S': s_AddZeroPadInt(str, t->NanoSecond(), 9); break;
  779.         case 'z': {
  780. #if defined(TIMEZONE_IS_UNDEFINED)
  781.               ERR_POST("Format symbol 'z' is unsupported on this platform");
  782. #else
  783.                       str += "GMT";
  784.                       if (IsGmtTime()) {
  785.                           break;
  786.                       }
  787.                       long tz = (out_tz == eCurrentTimeZone) ? TimeZone() : 
  788.                                                                out_tz;
  789.                       str += (tz > 0) ? '-' : '+';
  790.                       if (tz < 0) tz = -tz;
  791.                       int tzh = tz / 3600;
  792.                       s_AddZeroPadInt(str, tzh);
  793.                       s_AddZeroPadInt(str, (int)(tz - tzh * 3600) / 60);
  794. #endif
  795.                       break;
  796.                   }
  797.         case 'Z': if (IsGmtTime()) str += "GMT";            break;
  798.         case 'w': str += kWeekdayAbbr[t->DayOfWeek()];      break;
  799.         case 'W': str += kWeekdayFull[t->DayOfWeek()];      break;
  800.         default : str += *it;                               break;
  801.         }
  802.     }
  803.     // Free used memory
  804.     if ( t_out ) {
  805.         delete t_out;
  806.     }
  807.     return str;
  808. }
  811. #if defined (NCBI_OS_MAC)
  812. // Mac OS 9 does not correctly support daylight savings flag.
  813. time_t CTime::GetTimeT(void) const
  814. {
  815.     struct tm t;
  816.     t.tm_sec   = Second() + (int) (IsGmtTime() ? +TimeZone() : 0);
  817.     t.tm_min   = Minute();
  818.     t.tm_hour  = Hour();
  819.     t.tm_mday  = Day();
  820.     t.tm_mon   = Month()-1;
  821.     t.tm_year  = Year()-1900;
  822.     t.tm_isdst = -1;
  823.     return mktime(&t);
  824. }
  825. #else
  826. time_t CTime::GetTimeT(void) const
  827. {
  828.     // MT-Safe protect
  829.     CFastMutexGuard LOCK(s_TimeMutex);
  831.     struct tm t;
  833.     // Convert time to time_t value at base local time
  834. #if defined(HAVE_TIMEGM)  ||  (defined(NCBI_OS_DARWIN)  &&  ! defined(NCBI_COMPILER_MW_MSL))
  835.     t.tm_sec   = Second();
  836. #else
  837.     t.tm_sec   = Second() + (int) (IsGmtTime() ? -TimeZone() : 0);
  838. #endif
  839.     t.tm_min   = Minute();
  840.     t.tm_hour  = Hour();
  841.     t.tm_mday  = Day();
  842.     t.tm_mon   = Month()-1;
  843.     t.tm_year  = Year()-1900;
  844.     t.tm_isdst = -1;
  845. #if defined(NCBI_OS_DARWIN) && ! defined(NCBI_COMPILER_MW_MSL)
  846.     time_t tt = mktime(&t);
  847.     return IsGmtTime() ? tt+t.tm_gmtoff : tt;
  848. #elif defined(HAVE_TIMEGM)
  849.     return IsGmtTime() ? timegm(&t) : mktime(&t);
  850. #else
  851.     struct tm *ttemp;
  852.     time_t timer;
  853.     timer = mktime(&t);
  855.     // Correct timezone for GMT time
  856.     if ( IsGmtTime() ) {
  858.        // Call mktime() second time for GMT time !!!  
  859.        // 1st - to get correct value of TimeZone().
  860.        // 2nd - to get value "timer". 
  862.         t.tm_sec   = Second() - (int)TimeZone();
  863.         t.tm_min   = Minute();
  864.         t.tm_hour  = Hour();
  865.         t.tm_mday  = Day();
  866.         t.tm_mon   = Month()-1;
  867.         t.tm_year  = Year()-1900;
  868.         t.tm_isdst = -1;
  869.         timer = mktime(&t);
  871. #  if defined(HAVE_LOCALTIME_R)
  872.         struct tm temp;
  873.         localtime_r(&timer, &temp);
  874.         ttemp = &temp;
  875. #  else
  876.         ttemp = localtime(&timer);
  877. #  endif
  878.         if (ttemp == NULL)
  879.             return -1;
  880.         if (ttemp->tm_isdst > 0  &&  Daylight())
  881.             timer += 3600;
  882.     }
  883.     return timer;
  884. #endif
  885. }
  886. #endif
  888. TDBTimeU CTime::GetTimeDBU(void) const
  889. {
  890.     TDBTimeU dbt;
  891.     CTime t  = GetLocalTime();
  892.     unsigned first = s_Date2Number(CTime(1900, 1, 1));
  893.     unsigned curr  = s_Date2Number(t);
  895.     dbt.days = (Uint2)(curr - first);
  896.     dbt.time = (Uint2)(t.Hour() * 60 + t.Minute());
  897.     return dbt;
  898. }
  901. TDBTimeI CTime::GetTimeDBI(void) const
  902. {
  903.     TDBTimeI dbt;
  904.     CTime t  = GetLocalTime();
  905.     unsigned first = s_Date2Number(CTime(1900, 1, 1));
  906.     unsigned curr  = s_Date2Number(t);
  908.     dbt.days = (Int4)(curr - first);
  909.     dbt.time = (Int4)((t.Hour() * 3600 + t.Minute() * 60 + t.Second()) * 300) +
  910.         (Int4)((double)t.NanoSecond() * 300 / kNanoSecondsPerSecond);
  911.     return dbt;
  912. }
  915. CTime& CTime::SetTimeDBU(const TDBTimeU& t)
  916. {
  917.     // Local time - 1/1/1900 00:00:00.0
  918.     CTime time(1900, 1, 1, 0, 0, 0, 0, eLocal);
  920.     time.SetTimeZonePrecision(GetTimeZonePrecision());
  921.     time.AddDay(t.days);
  922.     time.AddMinute(t.time);
  923.     time.ToTime(GetTimeZoneFormat());
  925.     *this = time;
  926.     return *this;
  927. }
  930. CTime& CTime::SetTimeDBI(const TDBTimeI& t)
  931. {
  932.     // Local time - 1/1/1900 00:00:00.0
  933.     CTime time(1900, 1, 1, 0, 0, 0, 0, eLocal);
  935.     time.SetTimeZonePrecision(GetTimeZonePrecision());
  936.     time.AddDay(t.days);
  937.     time.AddSecond(t.time / 300);
  938.     time.AddNanoSecond((long)((t.time % 300) * 
  939.                               (double)kNanoSecondsPerSecond / 300));
  940.     time.ToTime(GetTimeZoneFormat());
  942.     *this = time;
  943.     return *this;
  944. }
  947. CTime& CTime::x_SetTime(const time_t* value)
  948. {
  949.     long ns = 0;
  950.     time_t timer;
  952.     // MT-Safe protect
  953.     CFastMutexGuard LOCK(s_TimeMutex);
  955.     // Get time with nanoseconds
  956. #if defined(NCBI_OS_MSWIN)
  958.     if ( value ) {
  959.         timer = *value;
  960.     } else {
  961.         struct _timeb timebuffer;
  962.         _ftime(&timebuffer);
  963.         timer = timebuffer.time;
  964.         ns = (long) timebuffer.millitm * 
  965.             (long) (kNanoSecondsPerSecond / kMilliSecondsPerSecond);
  966.     }
  967. #elif defined(NCBI_OS_UNIX)
  969.     if ( value ) {
  970.         timer = *value;
  971.     } else {
  972.         struct timeval tp;
  973.         if (gettimeofday(&tp,0) == -1) {
  974.             timer = 0;
  975.             ns = 0;
  976.         } else { 
  977.             timer = tp.tv_sec;
  978.             ns = long((double)tp.tv_usec * 
  979.                       (double)kNanoSecondsPerSecond /
  980.                       (double)kMicroSecondsPerSecond);
  981.         }
  982.     }
  984. #else // NCBI_OS_MAC
  986.     timer = value ? *value : time(0);
  987.     ns = 0;
  988. #endif
  990.     // Bind values to internal variables
  991.     struct tm *t;
  993. #ifdef HAVE_LOCALTIME_R
  994.     struct tm temp;
  995.     if (GetTimeZoneFormat() == eLocal) {
  996.         localtime_r(&timer, &temp);
  997.     } else {
  998.         gmtime_r(&timer, &temp);
  999.     }
  1000.     t = &temp;
  1001. #else
  1002.     t = ( GetTimeZoneFormat() == eLocal ) ? localtime(&timer) : gmtime(&timer);
  1003. #endif
  1004.     m_AdjustTimeDiff = 0;
  1005.     m_Year           = t->tm_year + 1900;
  1006.     m_Month          = t->tm_mon + 1;
  1007.     m_Day            = t->tm_mday;
  1008.     m_Hour           = t->tm_hour;
  1009.     m_Minute         = t->tm_min;
  1010.     m_Second         = t->tm_sec;
  1011.     m_NanoSecond     = ns;
  1013.     return *this;
  1014. }
  1017. CTime& CTime::AddMonth(int months, EDaylight adl)
  1018. {
  1019.     if ( !months ) {
  1020.         return *this;
  1021.     }
  1022.     CTime *pt = 0;
  1023.     bool aflag = false; 
  1024.     if ((adl == eAdjustDaylight)  &&  x_NeedAdjustTime()) {
  1025.         pt = new CTime(*this);
  1026.         if ( !pt ) {
  1027.             NCBI_THROW(CCoreException, eNullPtr, kEmptyStr);
  1028.         }
  1029.         aflag = true;
  1030.     }
  1031.     long newMonth = Month() - 1;
  1032.     int newYear = Year();
  1033.     s_Offset(&newMonth, months, 12, &newYear);
  1034.     m_Year = newYear;
  1035.     m_Month = (int) newMonth + 1;
  1036.     x_AdjustDay();
  1037.     if ( aflag ) {
  1038.         x_AdjustTime(*pt);
  1039.         delete pt;
  1040.     }
  1041.     return *this;
  1042. }
  1045. CTime& CTime::AddDay(int days, EDaylight adl)
  1046. {
  1047.     if ( !days ) {
  1048.         return *this;
  1049.     }
  1050.     CTime *pt = 0;
  1051.     bool aflag = false; 
  1052.     if ((adl == eAdjustDaylight)  &&  x_NeedAdjustTime()) {
  1053.         pt = new CTime(*this);
  1054.         if ( !pt ) {
  1055.             NCBI_THROW(CCoreException, eNullPtr, kEmptyStr);
  1056.         }
  1057.         aflag = true;
  1058.     }
  1060.     // Make nesessary object
  1061.     *this = s_Number2Date(s_Date2Number(*this) + days, *this);
  1063.     // If need, make adjustment time specially
  1064.     if ( aflag ) {
  1065.         x_AdjustTime(*pt);
  1066.         delete pt;
  1067.     }
  1068.     return *this;
  1069. }
  1072. // Parameter <shift_time> access or denied use time shift in process 
  1073. // adjust hours.
  1074. CTime& CTime::x_AddHour(int hours, EDaylight adl, bool shift_time)
  1075. {
  1076.     if ( !hours ) {
  1077.         return *this;
  1078.     }
  1079.     CTime *pt = 0;
  1080.     bool aflag = false; 
  1081.     if ((adl == eAdjustDaylight)  &&  x_NeedAdjustTime()) {
  1082.         pt = new CTime(*this);
  1083.         if ( !pt ) {
  1084.             NCBI_THROW(CCoreException, eNullPtr, kEmptyStr);
  1085.         }
  1086.         aflag = true;
  1087.     }
  1088.     int dayOffset = 0;
  1089.     long newHour = Hour();
  1090.     s_Offset(&newHour, hours, 24, &dayOffset);
  1091.     m_Hour = (int) newHour;
  1092.     AddDay(dayOffset, eIgnoreDaylight);
  1093.     if ( aflag ) {
  1094.         x_AdjustTime(*pt, shift_time);
  1095.         delete pt;
  1096.     }
  1097.     return *this;
  1098. }
  1101. CTime& CTime::AddMinute(int minutes, EDaylight adl)
  1102. {
  1103.     if ( !minutes ) {
  1104.         return *this;
  1105.     }
  1106.     CTime *pt = 0;
  1107.     bool aflag = false; 
  1108.     if ((adl == eAdjustDaylight) && x_NeedAdjustTime()) {
  1109.         pt = new CTime(*this);
  1110.         if ( !pt ) {
  1111.             NCBI_THROW(CCoreException, eNullPtr, kEmptyStr);
  1112.         }
  1113.         aflag = true;
  1114.     }
  1115.     int hourOffset = 0;
  1116.     long newMinute = Minute();
  1117.     s_Offset(&newMinute, minutes, 60, &hourOffset);
  1118.     m_Minute = (int) newMinute;
  1119.     AddHour(hourOffset, eIgnoreDaylight);
  1120.     if ( aflag ) {
  1121.         x_AdjustTime(*pt);
  1122.         delete pt;
  1123.     }
  1124.     return *this;
  1125. }
  1128. CTime& CTime::AddSecond(int seconds)
  1129. {
  1130.     if ( !seconds ) {
  1131.         return *this;
  1132.     }
  1133.     int minuteOffset = 0;
  1134.     long newSecond = Second();
  1135.     s_Offset(&newSecond, seconds, 60, &minuteOffset);
  1136.     m_Second = (int) newSecond;
  1137.     return AddMinute(minuteOffset);
  1138. }
  1141. CTime& CTime::AddNanoSecond(long ns)
  1142. {
  1143.     if ( !ns ) {
  1144.         return *this;
  1145.     }
  1146.     int secondOffset = 0;
  1147.     long newNanoSecond = NanoSecond();
  1148.     s_Offset(&newNanoSecond, ns, kNanoSecondsPerSecond, &secondOffset);
  1149.     m_NanoSecond = newNanoSecond;
  1150.     return AddSecond(secondOffset);
  1151. }
  1154. bool CTime::IsValid(void) const
  1155. {
  1156.     if ( IsEmpty() ) 
  1157.         return true;
  1159.     if (Year() < 1583) // first Gregorian date February 24, 1582
  1160.         return false;
  1161.     if (Month()  < 1  ||  Month()  > 12)
  1162.         return false;
  1163.     if (Month() == 2) {
  1164.         if (Day() < 1 ||  Day() > (IsLeap() ? 29 : 28))
  1165.             return false;
  1166.     } else {
  1167.         if (Day() < 1 ||  Day() > s_DaysInMonth[Month() - 1])
  1168.             return false;
  1169.     }
  1170.     if (Hour()   < 0  ||  Hour()   > 23)
  1171.         return false;
  1172.     if (Minute() < 0  ||  Minute() > 59)
  1173.         return false;
  1174.     if (Second() < 0  ||  Second() > 59)
  1175.         return false;
  1176.     if (NanoSecond() < 0  ||  NanoSecond() >= kNanoSecondsPerSecond)
  1177.         return false;
  1179.     return true;
  1180. }
  1183. CTime& CTime::ToTime(ETimeZone tz)
  1184. {
  1185.     if (GetTimeZoneFormat() != tz) {
  1186.         struct tm* t;
  1187.         time_t timer;
  1188.         timer = GetTimeT();
  1189.         if (timer == -1) 
  1190.             return *this;
  1192.         // MT-Safe protect
  1193.         CFastMutexGuard LOCK(s_TimeMutex);
  1195. #if defined(HAVE_LOCALTIME_R)
  1196.         struct tm temp;
  1197.         if (tz == eLocal) {
  1198.             localtime_r(&timer, &temp);
  1199.         } else {
  1200.             gmtime_r(&timer, &temp);
  1201.         }
  1202.         t = &temp;
  1203. #else
  1204.         t = ( tz == eLocal ) ? localtime(&timer) : gmtime(&timer);
  1205. #endif
  1206.         m_Year   = t->tm_year + 1900;
  1207.         m_Month  = t->tm_mon + 1;
  1208.         m_Day    = t->tm_mday;
  1209.         m_Hour   = t->tm_hour;
  1210.         m_Minute = t->tm_min;
  1211.         m_Second = t->tm_sec;
  1212.         m_Tz     = tz;
  1213.     }
  1214.     return *this;
  1215. }
  1218. bool CTime::operator == (const CTime& t) const
  1219. {
  1220.     CTime tmp(t);
  1221.     tmp.ToTime(GetTimeZoneFormat());
  1222.     return
  1223.         Year()       == tmp.Year()    &&
  1224.         Month()      == tmp.Month()   &&
  1225.         Day()        == tmp.Day()     &&
  1226.         Hour()       == tmp.Hour()    &&
  1227.         Minute()     == tmp.Minute()  &&
  1228.         Second()     == tmp.Second()  &&
  1229.         NanoSecond() == tmp.NanoSecond();
  1230. }
  1233. bool CTime::operator > (const CTime& t) const
  1234. {
  1235.     CTime tmp(t);
  1236.     tmp.ToTime(GetTimeZoneFormat());
  1238.     if (Year()   > tmp.Year())   
  1239.         return true;
  1240.     if (Year()   < tmp.Year())   
  1241.         return false;
  1242.     if (Month()  > tmp.Month())  
  1243.         return true;
  1244.     if (Month()  < tmp.Month())  
  1245.         return false;
  1246.     if (Day()    > tmp.Day())    
  1247.         return true;
  1248.     if (Day()    < tmp.Day())    
  1249.         return false;
  1250.     if (Hour()   > tmp.Hour())   
  1251.         return true;
  1252.     if (Hour()   < tmp.Hour())   
  1253.         return false;
  1254.     if (Minute() > tmp.Minute()) 
  1255.         return true;
  1256.     if (Minute() < tmp.Minute()) 
  1257.         return false;
  1258.     if (Second() > tmp.Second()) 
  1259.         return true;
  1260.     if (Second() < tmp.Second()) 
  1261.         return false;
  1262.     if (NanoSecond() > tmp.NanoSecond()) 
  1263.         return true;
  1265.     return false;
  1266. }
  1269. bool CTime::operator < (const CTime& t) const
  1270. {
  1271.     CTime tmp(t);
  1272.     tmp.ToTime(GetTimeZoneFormat());
  1274.     if (Year()   < tmp.Year())   
  1275.         return true;
  1276.     if (Year()   > tmp.Year())   
  1277.         return false;
  1278.     if (Month()  < tmp.Month())  
  1279.         return true;
  1280.     if (Month()  > tmp.Month())  
  1281.         return false;
  1282.     if (Day()    < tmp.Day())    
  1283.         return true;
  1284.     if (Day()    > tmp.Day())    
  1285.         return false;
  1286.     if (Hour()   < tmp.Hour())   
  1287.         return true;
  1288.     if (Hour()   > tmp.Hour())  
  1289.         return false;
  1290.     if (Minute() < tmp.Minute()) 
  1291.         return true;
  1292.     if (Minute() > tmp.Minute()) 
  1293.         return false;
  1294.     if (Second() < tmp.Second()) 
  1295.         return true;
  1296.     if (Second() > tmp.Second()) 
  1297.         return false;
  1298.     if (NanoSecond() > tmp.NanoSecond()) 
  1299.         return true;
  1301.     return false;
  1302. }
  1305. bool CTime::IsLeap(void) const
  1306. {
  1307.     int year = Year();
  1308.     return year % 4 == 0  &&  year % 100 != 0  ||  year % 400 == 0;
  1309. }
  1312. CTime& CTime::Truncate(void)
  1313. {
  1314.     m_Hour           = 0;
  1315.     m_Minute         = 0;
  1316.     m_Second         = 0;
  1317.     m_NanoSecond     = 0;
  1318.     m_AdjustTimeDiff = 0;
  1319.     return *this;
  1320. }
  1323. CTime& CTime::Clear()
  1324. {
  1325.     m_Year  = 0;
  1326.     m_Month = 0;
  1327.     m_Day   = 0;
  1328.     Truncate();
  1329.     return *this;
  1330. }
  1333. int CTime::DiffSecond(const CTime& t) const
  1334. {
  1335.     int dSec  = Second() - t.Second();
  1336.     int dMin  = Minute() - t.Minute();
  1337.     int dHour = Hour()   - t.Hour();
  1338.     int dDay  = (*this)  - t;
  1339.     return dSec + 60 * dMin + 60 * 60 * dHour + 60 * 60 * 24 * dDay;
  1340. }
  1343. void CTime::x_AdjustDay()
  1344. {
  1345.     int n_days = DaysInMonth();
  1346.     if (Day() > n_days) {
  1347.         m_Day = n_days;
  1348.     }
  1349. }
  1352. CTime& CTime::x_AdjustTime(const CTime& from, bool shift_time)
  1353. {
  1354.     if ( !x_NeedAdjustTime() )
  1355.         return *this; 
  1357.     switch ( GetTimeZonePrecision() ) {
  1358.     case eMinute:
  1359.         if (Minute() != from.Minute())
  1360.             return x_AdjustTimeImmediately(from, shift_time);
  1361.     case eHour:
  1362.         if (Hour() != from.Hour())
  1363.             return x_AdjustTimeImmediately(from, shift_time);
  1364.     case eDay:
  1365.         if (Day() != from.Day())
  1366.             return x_AdjustTimeImmediately(from, shift_time);
  1367.     case eMonth:
  1368.         if (Month() != from.Month())
  1369.             return x_AdjustTimeImmediately(from, shift_time);
  1370.     default:
  1371.         break;
  1372.     }
  1373.     return *this;
  1374. }
  1375.   
  1377. CTime& CTime::x_AdjustTimeImmediately(const CTime& from, bool shift_time)
  1378. {
  1379.     // Time in hours for temporary time shift.
  1380.     // Shift used for obtainment correct result at changeover daytime saving.
  1381.     // Must be > 3 (Linux distinction). On other platforms may be == 3.
  1382.     const int kShift = 4;
  1384.     // MT-Safe protect
  1385.     CFastMutexGuard LOCK(s_TimeAdjustMutex);
  1387.     // Special conversion from <const CTime> to <CTime>
  1388.     CTime tmp(from); 
  1389.     int sign = 0;
  1390.     int diff = 0;
  1391.     // Primary procedure call
  1392.     if ( shift_time ) {
  1393.         sign = ( *this > from ) ? 1 : -1;
  1394.         // !!! Run TimeZoneDiff() first for old time value 
  1395.         diff = -tmp.TimeZoneDiff() + TimeZoneDiff();
  1396.         // Correction need's if time already in identical timezone
  1397.         if (!diff  ||  diff == m_AdjustTimeDiff) {
  1398.             return *this;
  1399.         }
  1400.     } 
  1401.     // Recursive procedure call. Inside below 
  1402.     // x_AddHour(*, eAdjustDaylight, false)
  1403.     else  {
  1404.         // Correction need't if difference not found
  1405.         if (diff == m_AdjustTimeDiff) {
  1406.             return *this;
  1407.         }
  1408.     }
  1409.     // Make correction with temporary time shift
  1410.     time_t t = GetTimeT();
  1411.     CTime tn(t + diff + 3600 * kShift * sign);
  1412.     if (from.GetTimeZoneFormat() == eLocal) {
  1413.         tn.ToLocalTime();
  1414.     }
  1415.     tn.SetTimeZonePrecision(GetTimeZonePrecision());
  1417.     // Release adjust time mutex
  1418.     LOCK.Release();
  1420.     // Primary procedure call
  1421.     if ( shift_time ) {
  1422.         // Cancel temporary time shift
  1423.         tn.x_AddHour(-kShift * sign, eAdjustDaylight, false);
  1424.         tn.m_AdjustTimeDiff = diff;
  1425.     }
  1426.     *this = tn;
  1427.     return *this;
  1428. }
  1432. //=============================================================================
  1433. //
  1434. //  CStopWatch
  1435. //
  1436. //=============================================================================
  1439. double CStopWatch::GetTimeMark()
  1440. {
  1441. #if defined(NCBI_OS_MSWIN)
  1442.     // For Win32, we use QueryPerformanceCounter()
  1444.     LARGE_INTEGER bigint;
  1445.     static double freq;
  1446.     static bool first = true;
  1448.     if ( first ) {
  1449.         LARGE_INTEGER nfreq;
  1450.         QueryPerformanceFrequency(&nfreq);
  1451.         freq  = nfreq.QuadPart;
  1452.         first = false;
  1453.     }
  1455.     if ( !QueryPerformanceCounter(&bigint) ) {
  1456.         return 0.0;
  1457.     }
  1458.     return double(bigint.QuadPart) / freq;
  1460. #else
  1461.     // For Unixes, we use gettimeofday()
  1463.     struct timeval time;
  1464.     if ( gettimeofday (&time, 0) ) {
  1465.         return 0.0;
  1466.     }
  1467.     return double(time.tv_sec) + double(time.tv_usec) / 1e6;
  1468. #endif
  1469. }
  1472. //============================================================================
  1473. //
  1474. //  Extern
  1475. //
  1476. //============================================================================
  1478. // Return difference between times <t1> and <t2> as number of days
  1479. int operator - (const CTime& t1, const CTime& t2)
  1480. {
  1481.     return (int) (s_Date2Number(t1) - s_Date2Number(t2));
  1482. }
  1485. CTime AddYear(const CTime& t, int years)
  1486. {
  1487.     CTime tmp(t);
  1488.     return tmp.AddYear(years);
  1489. }
  1491.  
  1492. CTime AddMonth(const CTime& t, int months)
  1493. {
  1494.     CTime tmp(t);
  1495.     return tmp.AddMonth(months);
  1496. }
  1498.  
  1499. CTime AddDay(const CTime& t, int days)
  1500. {
  1501.     CTime tmp(t);
  1502.     return tmp.AddDay(days);
  1503. }
  1505.  
  1506. CTime AddHour(const CTime& t, int hours)
  1507. {
  1508.     CTime tmp(t);
  1509.     return tmp.AddHour(hours);
  1510. }
  1512.  
  1513. CTime AddMinute(const CTime& t, int minutes)
  1514. {
  1515.     CTime tmp(t);
  1516.     return tmp.AddMinute(minutes);
  1517. }
  1519.  
  1520. CTime AddSecond(const CTime& t, int seconds)
  1521. {
  1522.     CTime tmp(t);
  1523.     return tmp.AddSecond(seconds);
  1524. }
  1526.  
  1527. CTime AddNanoSecond(const CTime& t, long nanoseconds)
  1528. {
  1529.     CTime tmp(t);
  1530.     return tmp.AddNanoSecond(nanoseconds);
  1531. }
  1534. CTime operator + (const CTime& t, int days)
  1535. {
  1536.     CTime tmp = s_Number2Date(s_Date2Number(t) + days, t);
  1537.     tmp.x_AdjustTime(t);
  1538.     return tmp;
  1539. }
  1541.  
  1542. CTime operator + (int days, const CTime& t)
  1543. {
  1544.     CTime tmp = s_Number2Date(s_Date2Number(t) + days, t);
  1545.     tmp.x_AdjustTime(t);
  1546.     return tmp;
  1547. }
  1549.  
  1550. CTime operator - (const CTime& t, int days)
  1551. {
  1552.     CTime tmp = s_Number2Date(s_Date2Number(t) - days, t);
  1553.     tmp.x_AdjustTime(t);
  1554.     return tmp;
  1555. }
  1557.  
  1558. CTime CurrentTime(CTime::ETimeZone tz, CTime::ETimeZonePrecision tzp)
  1559. {
  1560.     return CTime(CTime::eCurrent,tz,tzp);
  1561. }
  1563.  
  1564. CTime Truncate(const CTime& t)
  1565. {
  1566.     CTime tmp(t);
  1567.     return tmp.Truncate();
  1568. }
  1571. END_NCBI_SCOPE
  1574. /*
  1575.  * ===========================================================================
  1576.  * $Log: ncbitime.cpp,v $
  1577.  * Revision 1000.4  2004/06/01 19:09:28  gouriano
  1578.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.49
  1579.  *
  1580.  * Revision 1.49  2004/05/14 13:59:27  gorelenk
  1581.  * Added include of ncbi_pch.hpp
  1582.  *
  1583.  * Revision 1.48  2004/03/26 16:05:29  ivanov
  1584.  * Format symbol 'z' and output time zone for AsString are unsupported
  1585.  * on NCBI_OS_DARWIN and NCBI_OS_BSD (problems with determinition daylight
  1586.  * flag for specified time).
  1587.  *
  1588.  * Revision 1.47  2004/03/25 13:03:31  ivanov
  1589.  * Temporary fix for NCBI_OS_DARWIN and NCBI_OS_BSD
  1590.  *
  1591.  * Revision 1.46  2004/03/24 18:47:47  ivanov
  1592.  * Replaced abs() with if-clause
  1593.  *
  1594.  * Revision 1.45  2004/03/24 15:52:08  ivanov
  1595.  * Added new format symbol support 'z' (local time in format GMT{+|-}HHMM).
  1596.  * Added second parameter to AsString() method that specify an output
  1597.  * timezone.
  1598.  *
  1599.  * Revision 1.44  2003/11/25 19:55:49  ivanov
  1600.  * Added setters for various components of time -- Set*().
  1601.  * Added YearWeekNumber(), MonthWeekNumber().
  1602.  * Reimplemented AddYear() as AddMonth(years*12).
  1603.  * Changed DayOfWeek() to use other computation method.
  1604.  *
  1605.  * Revision 1.43  2003/11/21 20:04:23  ivanov
  1606.  * + DaysInMonth()
  1607.  *
  1608.  * Revision 1.42  2003/10/06 13:59:01  ivanov
  1609.  * Some cosmetics
  1610.  *
  1611.  * Revision 1.41  2003/10/06 13:30:37  ivanov
  1612.  * Fixed cut&paste bug in the MonthNumToName()
  1613.  *
  1614.  * Revision 1.40  2003/10/03 18:27:06  ivanov
  1615.  * Added month and day of week names conversion functions
  1616.  *
  1617.  * Revision 1.39  2003/09/29 21:20:17  golikov
  1618.  * x_Init: create empty CTime obj if str.empty() true, ignore format
  1619.  *
  1620.  * Revision 1.38  2003/07/15 20:09:22  ivanov
  1621.  * Fixed some memory leaks
  1622.  *
  1623.  * Revision 1.37  2003/07/15 19:37:03  vakatov
  1624.  * CTime::x_Init() -- recognize (but then just skip, ignoring the value)
  1625.  * the weekday
  1626.  *
  1627.  * Revision 1.36  2003/04/23 21:07:31  ivanov
  1628.  * CStopWatch::GetTimeMark: removed 'f' to avoid a conversion float
  1629.  * 1e6f to double.
  1630.  *
  1631.  * Revision 1.35  2003/04/16 20:28:00  ivanov
  1632.  * Added class CStopWatch
  1633.  *
  1634.  * Revision 1.34  2003/04/04 16:02:38  lavr
  1635.  * Lines wrapped at 79th column; some minor reformatting
  1636.  *
  1637.  * Revision 1.33  2003/04/03 14:15:48  rsmith
  1638.  * combine pp symbols NCBI_COMPILER_METROWERKS & _MSL_USING_MW_C_HEADERS
  1639.  * into NCBI_COMPILER_MW_MSL
  1640.  *
  1641.  * Revision 1.32  2003/04/02 16:22:34  rsmith
  1642.  * clean up metrowerks ifdefs.
  1643.  *
  1644.  * Revision 1.31  2003/04/02 13:31:18  rsmith
  1645.  * change #ifdefs to allow compilation on MacOSX w/codewarrior
  1646.  * using MSL headers.
  1647.  *
  1648.  * Revision 1.30  2003/02/10 17:17:30  lavr
  1649.  * Fix off-by-one bug in DayOfWeek() calculation
  1650.  *
  1651.  * Revision 1.29  2002/10/24 15:16:37  ivanov
  1652.  * Fixed bug with using two obtainments of the current time in x_SetTime().
  1653.  *
  1654.  * Revision 1.28  2002/10/18 20:13:01  ivanov
  1655.  * Get rid of some Sun Workshop compilation warnings
  1656.  *
  1657.  * Revision 1.27  2002/10/17 16:55:30  ivanov
  1658.  * Added new time format symbols - 'b' and 'B' (month abbreviated and full name)
  1659.  *
  1660.  * Revision 1.26  2002/09/19 20:05:43  vasilche
  1661.  * Safe initialization of static mutexes
  1662.  *
  1663.  * Revision 1.25  2002/08/19 14:02:24  ivanov
  1664.  * MT-safe fix for ToTime()
  1665.  *
  1666.  * Revision 1.24  2002/07/23 19:51:17  lebedev
  1667.  * NCBI_OS_MAC: GetTimeT fix
  1668.  *
  1669.  * Revision 1.23  2002/07/15 18:17:25  gouriano
  1670.  * renamed CNcbiException and its descendents
  1671.  *
  1672.  * Revision 1.22  2002/07/11 14:18:28  gouriano
  1673.  * exceptions replaced by CNcbiException-type ones
  1674.  *
  1675.  * Revision 1.21  2002/06/26 20:47:45  lebedev
  1676.  * Darwin specific: ncbitime changes
  1677.  *
  1678.  * Revision 1.20  2002/06/19 17:18:05  ucko
  1679.  * Fix confusing indentation introduced by R1.19.
  1680.  *
  1681.  * Revision 1.19  2002/06/19 16:18:36  lebedev
  1682.  * Added CoreServices.h for Darwin (timezone and daylight
  1683.  *
  1684.  * Revision 1.18  2002/06/18 16:08:01  ivanov
  1685.  * Fixed all clauses "#if defined *" to "#if defined(*)"
  1686.  *
  1687.  * Revision 1.17  2002/05/13 13:56:46  ivanov
  1688.  * Added MT-Safe support
  1689.  *
  1690.  * Revision 1.16  2002/04/11 21:08:04  ivanov
  1691.  * CVS log moved to end of the file
  1692.  *
  1693.  * Revision 1.15  2002/03/25 17:08:17  ucko
  1694.  * Centralize treatment of Cygwin as Unix rather than Windows in configure.
  1695.  *
  1696.  * Revision 1.14  2002/03/22 19:59:29  ucko
  1697.  * Use timegm() when available [fixes FreeBSD build].
  1698.  * Tweak to work on Cygwin.
  1699.  *
  1700.  * Revision 1.13  2001/07/23 16:05:57  ivanov
  1701.  * Fixed bug in Get/Set DB-time formats (1 day difference)
  1702.  *
  1703.  * Revision 1.12  2001/07/06 15:11:11  ivanov
  1704.  * Added support DataBase-time's -- GetTimeDBI(), GetTimeDBU()
  1705.  *                                  SetTimeDBI(), SetTimeDBU()
  1706.  *
  1707.  * Revision 1.11  2001/06/20 14:46:17  vakatov
  1708.  * Get rid of the '^M' symbols introduced in the R1.10 log
  1709.  *
  1710.  * Revision 1.10  2001/06/19 23:03:46  juran
  1711.  * Replace timezone and daylight with macros
  1712.  * Implement for Mac OS
  1713.  * Note:  This compiles, but it may not work correctly yet.
  1714.  *
  1715.  * Revision 1.9  2001/05/29 20:14:03  ivanov
  1716.  * Added #include <sys/time.h> for UNIX platforms.
  1717.  *
  1718.  * Revision 1.8  2001/05/29 16:14:01  ivanov
  1719.  * Return to nanosecond-revision. Corrected mistake of the work with local
  1720.  * time on Linux. Polish and improvement source code.
  1721.  * Renamed AsTimeT() -> GetTimerT().
  1722.  *
  1723.  * Revision 1.7  2001/05/17 15:05:00  lavr
  1724.  * Typos corrected
  1725.  *
  1726.  * Revision 1.6  2001/04/30 22:01:30  lavr
  1727.  * Rollback to pre-nanosecond-revision due to necessity to use
  1728.  * configure to figure out names of global variables governing time zones
  1729.  *
  1730.  * Revision 1.5  2001/04/29 03:06:09  lavr
  1731.  * #include <time.h>" moved from .cpp to ncbitime.hpp
  1732.  *
  1733.  * Revision 1.4  2001/04/27 20:38:14  ivanov
  1734.  * Support for Local and UTC time added.
  1735.  * Support for work with nanoseconds added.
  1736.  *
  1737.  * Revision 1.3  2001/01/03 17:53:05  butanaev
  1738.  * Fixed bug in SetCurrent()
  1739.  *
  1740.  * Revision 1.2  2000/11/21 18:14:58  butanaev
  1741.  * Fixed bug in operator ++/-- (int)
  1742.  *
  1743.  * Revision 1.1  2000/11/20 22:17:46  vakatov
  1744.  * Added NCBI date/time class CTime ("ncbitime.[ch]pp") and
  1745.  * its test suite ("test/test_ncbitime.cpp")
  1746.  *
  1747.  * ===========================================================================
  1748.  */