home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c083 / 20.ddi / CLASSSRC.PAK / TIME.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-02  |  7.7 KB  |  276 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  TIME.CPP                                                              */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1993                                  */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __TIME_H )
  11. #include <time.h>
  12. #endif  // __TIME_H
  13.  
  14. #if !defined( __STDIO_H )
  15. #include <stdio.h>
  16. #endif  // __STDIO_H
  17.  
  18. #if !defined( __CHECKS_H )
  19. #include <checks.h>
  20. #endif  // __CHECKS_H
  21.  
  22. #if !defined( __CLASSLIB_TIME_H )
  23. #include "classlib\time.h"
  24. #endif  // __CLASSLIB_TIME_H
  25.  
  26. enum TimeZone { CarolineIslands=-11,    MarianaIslands,         Japan, 
  27.                 China,                  minusSeven,             minusSix, 
  28.                 Pakistan,               CaspianSea,             Turkey, 
  29.                 Finland,                Europe,                 Greenwich, 
  30.                 Azores,                 two,                    Greenland, 
  31.                 Atlantic,               USEastern,              USCentral, 
  32.                 USMountain,             USPacific,              Alaska, 
  33.                 Hawaii,                 Bearing};
  34.  
  35. static const unsigned long SECONDS_IN_DAY  = 86400L;
  36. static const unsigned long SECONDS_IN_HOUR = 3600L;
  37. static const unsigned      SECONDS_IN_MIN  = 60;
  38.  
  39. //  Be sure that you have set your environment variable TZ.
  40. //  For example, for Pacific coast time, set TZ=PDT8PST.  
  41. //  For other time zones, see your manuals.
  42.  
  43. struct TInitTime
  44. {
  45.     TInitTime()
  46.         { tzset(); }
  47. };
  48.  
  49. static TInitTime cludgeTime;      // To force the call to tzset()
  50.  
  51.  
  52. const TDate TTime::RefDate( (DayTy)0, (YearTy)0 );
  53. const TDate TTime::MaxDate( (DayTy)49709L, (YearTy)0 ); // ((2**32)-1)/SECONDS_IN_DAY -1
  54. static const int SUNDAY = 7;
  55.  
  56. int TTime::AssertDate( const TDate _BIDSFAR & date )
  57. {
  58.     return date.Between(RefDate,MaxDate);
  59. }   
  60.  
  61. /******************* private member functions ***********************/
  62.  
  63.  
  64. // Adjust for local time zone and Daylight Savings Time.
  65. ClockTy TTime::LocalSecs() const
  66. {
  67.     TTime local_time( Sec - timezone );
  68.     if (local_time.IsDST())
  69.         local_time.Sec += SECONDS_IN_HOUR;
  70.     return local_time.Sec;
  71. }
  72.  
  73. /*
  74.  * Builds the time from a local time, adjusting to GMT.  Does *not* adjust for DST.
  75.  */
  76. TTime TTime::BuildLocal( const TDate _BIDSFAR & date, HourTy h )
  77. {
  78.     return TTime( SECONDS_IN_DAY * (date-RefDate) + 
  79.                   SECONDS_IN_HOUR * h + 
  80.                   timezone);
  81. }
  82.  
  83. /*************** public static member functions *******************/
  84.  
  85. /*
  86.  * Return the time at which DST starts for the given year.
  87.  * Note that the time returned is the time at which DST starts locally,
  88.  * but it is returned in GMT.
  89.  */
  90. TTime TTime::BeginDST( unsigned year )
  91. {
  92.     if( year > 1986 ) 
  93.         {
  94.         TDate endMarch(31, 3, year);
  95.         return BuildLocal( endMarch.Previous(SUNDAY)+7, 2 );
  96.         }
  97.  
  98.     // Ah, remember those energy conscious years...???
  99.     if( year==1974 )
  100.         return BuildLocal( TDate(6,1,1974), 2 );
  101.     if( year==1975 )
  102.         return BuildLocal( TDate(23,2,1975), 2 );
  103.  
  104.     TDate endApril( 30, 4, year );
  105.     return BuildLocal( endApril.Previous(SUNDAY), 2 );
  106. }
  107.  
  108.  
  109. /*
  110.  * Return the time at which DST ends for the given year.
  111.  * Note that the time returned is the time at which DST ends locally,
  112.  * but it is returned in GMT.
  113.  */
  114. TTime TTime::EndDST( unsigned year )
  115. {
  116.     TDate endOctober( 31, 10, year );
  117.     return BuildLocal( endOctober.Previous(SUNDAY), 1 );
  118. }
  119.  
  120.  
  121. /************************* constructor *********************************/
  122.  
  123. // Construct TTime with current time (seconds since Jan 1, 1901).
  124. TTime::TTime()
  125. {
  126.   time_t ltime;
  127.   time(<ime);
  128.   struct tm _FAR *t = localtime(<ime);
  129.  
  130.   // Construct the date.  The time struct returns int, so casts are used.
  131.  
  132.   TDate today( (DayTy)t->tm_mday,
  133.                (MonthTy)(t->tm_mon + 1),
  134.                (YearTy)t->tm_year );
  135.  
  136.   *this = TTime( today, 
  137.                  (HourTy)t->tm_hour, 
  138.                  (MinuteTy)t->tm_min, 
  139.                  (SecondTy)t->tm_sec );
  140. } 
  141.  
  142. // Specified time and today's date:
  143. TTime::TTime( HourTy h, MinuteTy m, SecondTy s )
  144. {
  145.     Sec = TTime( TDate(),h,m,s ).Sec;
  146. }
  147.  
  148. /*
  149.  * Construct a Time for the specified (local) Date, hour, minute, and second.
  150.  * Note: this algorithm will fail if DST correction is something other
  151.  * than an hour.
  152.  * It is complicated by the DST boundary problem: 
  153.  * 1) Times in the phantom zone between 2AM and 3AM when DST is invoked are invalid.
  154.  * 2) Times in the hour after 1AM when DST ends, are redundant.
  155.  * Checking for these situations necessitates a lot of jumping back 
  156.  * and forth by an hour to check for the boundary.
  157.  */
  158. TTime::TTime( const TDate _BIDSFAR & date, HourTy h, MinuteTy m, SecondTy s )
  159. {
  160.     if( date.IsValid() )
  161.         {
  162.         Sec =   SECONDS_IN_DAY  * (date-RefDate) + 
  163.                 SECONDS_IN_HOUR * (h-1L) +    /* Note the adjustment by one hour */
  164.                 SECONDS_IN_MIN  * m + s;
  165.         if( Sec )
  166.             Sec += timezone;           // Adjust to GMT.
  167.  
  168.         if( IsDST() )
  169.             {
  170.             Sec += SECONDS_IN_HOUR;
  171.             if( IsDST() ) 
  172.                 Sec -= SECONDS_IN_HOUR;
  173.             }
  174.         else
  175.             {
  176.             Sec += SECONDS_IN_HOUR;
  177.             if( IsDST() ) 
  178.                 Sec = 0;            // Invalid "phantom" time.
  179.             }
  180.         }
  181.     else
  182.         Sec = 0;    // Invalid date
  183. }
  184.  
  185. /*************** conversion from TTime to TDate *******************/
  186.  
  187. // Type conversion to date.
  188. TDate::TDate( const TTime _BIDSFAR & t )
  189. {
  190.     Julnum = t.IsValid() ? jul1901 + (JulTy)(t.LocalSecs()/SECONDS_IN_DAY) : 0;
  191. }
  192.  
  193. /********************* public member functions **********************/
  194.  
  195. int TTime::CompareTo( const TTime _BIDSFAR &t ) const
  196. {
  197.     ClockTy diff = Sec - t.Sec;
  198.     return diff==0 ? 0 : diff>0 ? 1 : -1;
  199. }
  200.  
  201. // Hash function:
  202. unsigned TTime::Hash() const
  203. {
  204.     return (unsigned)Sec;
  205. }
  206.  
  207. /*
  208.  * The hour in local time:
  209.  */
  210. HourTy TTime::Hour() const
  211. {
  212.     return HourTy((LocalSecs() % SECONDS_IN_DAY) / SECONDS_IN_HOUR);
  213. }
  214.  
  215. /*
  216.  * The hour in GMT:
  217.  */
  218. HourTy TTime::HourGMT() const 
  219. {
  220.     return HourTy((Sec % SECONDS_IN_DAY) / SECONDS_IN_HOUR);
  221. } 
  222.  
  223. /*
  224.  * Return TRUE if DST is active for this time:
  225.  */
  226. int TTime::IsDST() const
  227. {
  228.   if( !daylight ) 
  229.     return 0;
  230.  
  231.   DayTy daycount = (unsigned)(Sec/SECONDS_IN_DAY);
  232.   YearTy year = TDate( (DayTy)daycount, (YearTy)0 ).Year();
  233.  
  234.   // Check to see if the time falls between the starting & stopping DST times.
  235.   return *this >= BeginDST( year ) && *this < EndDST( year );
  236. }
  237.  
  238. TTime TTime::Max( const TTime _BIDSFAR & t ) const 
  239. {
  240.     if( *this > t ) 
  241.         return *this;
  242.     else
  243.         return t;
  244. }
  245.  
  246. TTime TTime::Min( const TTime _BIDSFAR & t ) const 
  247. {
  248.     if( *this < t ) 
  249.         return *this;
  250.     else
  251.         return t;
  252. }
  253.  
  254. /*
  255.  * minute, in local time
  256.  */
  257. MinuteTy TTime::Minute() const
  258. {
  259.     return MinuteTy(((LocalSecs()%SECONDS_IN_DAY)%SECONDS_IN_HOUR)/SECONDS_IN_MIN);
  260. }
  261.  
  262. /*
  263.  * minute: GMT
  264.  */
  265. MinuteTy TTime::MinuteGMT() const 
  266. {
  267.     return MinuteTy(((Sec%SECONDS_IN_DAY)%SECONDS_IN_HOUR)/SECONDS_IN_MIN);
  268. } 
  269.  
  270. // second;local time or GMT 
  271. SecondTy TTime::Second() const 
  272. {
  273.     return SecondTy(((Sec%SECONDS_IN_DAY)%SECONDS_IN_HOUR)%SECONDS_IN_MIN);
  274. }
  275.  
  276.