gcalendar.cpp

Go to the documentation of this file.
00001 // gcalendar.cpp -- Version 0.0
00002 
00003 #include <string.h>
00004 #include "gcalendar.h"
00005 
00006 // Static members
00007 int gDateTime::minimumYear=1900;
00008 const t_uint8 gDateTime::tblCalDurMonth[13]={
00009     0,
00010     31,
00011     28,
00012     31,
00013     30,
00014     31,
00015     30,
00016     31,
00017     31,
00018     30,
00019     31,
00020     30,
00021     31};
00022 
00023 ////////////////////////////////////////////////////////////
00024 gDateTime::gDateTime (t_stamp aStamp)
00025     : gStorage( e_StoreExtend ),
00026       lastOpError( 0 ),
00027       year( 0 ),
00028       month( 0 ),
00029       day( 0 ),
00030       hour( 0 ),
00031       minu( 0 ),
00032       sec( 0 ),
00033       wday( 0 ),
00034       yday( 0 ),
00035       isdst( -1 )
00036 {
00037  lastOpError = thisConvertFromStamp( aStamp );
00038 }
00039 
00040 gDateTime::gDateTime (int iYear, int iMonth, int iDay,
00041                       t_uint8 uHour, t_uint8 uMin, t_uint8 uSec)
00042     : gStorage( e_StoreExtend ),
00043       lastOpError( 0 ),
00044       year( iYear ),
00045       month( iMonth ),
00046       day( iDay ),
00047       hour( uHour ),
00048       minu( uMin ),
00049       sec( uSec ),
00050       wday( 0 ),
00051       yday( 0 ),
00052       isdst( 0 )
00053 {
00054  lastOpError = iMonth<1 || iDay<1;
00055  if ( lastOpError==0 ) lastOpError = thisCalCheck();
00056 }
00057 
00058 gDateTime::gDateTime (gDateTime::eKindTime aKind)
00059     : gStorage( e_StoreExtend ),
00060       lastOpError( 0 ),
00061       year( 0 ),
00062       month( 0 ),
00063       day( 0 ),
00064       hour( 0 ),
00065       minu( 0 ),
00066       sec( 0 ),
00067       wday( 0 ),
00068       yday( 0 ),
00069       isdst( -1 )
00070 {
00071  lastOpError = thisConvertFromStamp( time(NULL) );
00072 }
00073 
00074 gDateTime::~gDateTime ()
00075 {
00076 }
00077 
00078 bool gDateTime::IsOk ()
00079 {
00080  // Note: gStorage::IsOk is always true...
00081  return lastOpError==0 && isdst!=-1 && thisCalCheck()==0;
00082 }
00083 
00084 char* gDateTime::StorageName ()
00085 {
00086  return (char*)"DTTM";
00087 }
00088 
00089 void gDateTime::Reset ()
00090 {
00091  lastOpError = 0;
00092  year = 0;
00093  month = 0;
00094  day = 0;
00095  hour = minu = sec = 0;
00096  wday = 0;
00097  yday = 0;
00098  isdst = -1;
00099 }
00100 
00101 int gDateTime::SetError (int opError)
00102 {
00103  lastOpError = opError;
00104  return gStorage::SetError( lastOpError );
00105 }
00106 
00107 t_stamp gDateTime::GetTimeStamp ()
00108 {
00109  t_stamp aStamp;
00110  SetError( thisConvertToStamp( *this, aStamp ) );
00111  return aStamp;
00112 }
00113 
00114 bool gDateTime::SetTimeStamp (t_stamp aStamp)
00115 {
00116  return SetError( thisConvertFromStamp( aStamp ) )==0;
00117 }
00118 
00119 t_uint8 gDateTime::DaysOfMonth (int aYear, t_uint8 aMonth)
00120 {
00121  t_uint8 nDays;
00122  if ( aMonth<1 || aMonth>12 ) return 0;
00123  nDays = tblCalDurMonth[aMonth];
00124  if ( aMonth==2 ) nDays += ((aYear%4)==0);
00125  return nDays;
00126 }
00127 
00128 gStorage* gDateTime::NewObject ()
00129 {
00130  gDateTime* a = new gDateTime( GetTimeStamp() );
00131  return a;
00132 }
00133 
00134 t_uchar* gDateTime::ToString (t_uchar* uBuf)
00135 {
00136  if ( uBuf==nil ) return nil;
00137  sprintf( (char*)uBuf, "%04d/%02u/%02u,%02u:%02u:%02u",
00138           year, month, day,
00139           hour, minu, sec );
00140  return uBuf;
00141 }
00142 
00143 bool gDateTime::SaveGuts (FILE* f)
00144 {
00145  if ( CanSave( f )==false ) return false;
00146  return
00147      fprintf(f,"%04d/%02u/%02u,%02u:%02u:%02u",
00148              year, month, day,
00149              hour, minu, sec)>0;
00150 }
00151 
00152 bool gDateTime::RestoreGuts (FILE* f)
00153 {
00154  t_stamp aStamp;
00155  int d1;
00156  unsigned d2, d3, h1, h2, h3;
00157 
00158  if ( CanRestore( f )==false ) return false;
00159  Reset();
00160  lastOpError =
00161      fscanf(f,"%d/%u/%u,%u:%u:%u",
00162             &d1, &d2, &d3,
00163             &h1, &h2, &h3);
00164  year = gRANGE0(d1,-65000,65000);
00165  month = gRANGE0(d2,1,12);
00166  day = gRANGE0(d3,1,31);
00167  hour = gRANGE0(h1,0,23);
00168  minu = gRANGE0(h2,0,59);
00169  sec = gRANGE0(h3,0,59);
00170  if ( lastOpError!=6 ) return SetError( 1 );
00171  lastOpError = 0;
00172  return SetError( thisConvertToStamp( *this, aStamp ) )==0;
00173 }
00174 
00175 int gDateTime::thisCalCheck ()
00176 {
00177  return thisDateTimeCheck( *this, minimumYear );
00178 }
00179 
00180 int gDateTime::thisDateTimeCheck (gDateTime& aDtTm, int minYear)
00181 {
00182  if ( thisDateCheck( aDtTm.year, aDtTm.month, aDtTm.day, minYear )!=0 )
00183      return 1;
00184  if ( thisTimeCheck( aDtTm.hour, aDtTm.minu, aDtTm.sec )!=0 )
00185      return 2;
00186  return 0;
00187 }
00188 
00189 int gDateTime::thisDateCheck (int aYear, t_uint8 aMonth, t_uint8 aDay, int minYear)
00190 {
00191  t_uint8 nDays;
00192  if ( aYear<minYear ) return 1;
00193  if ( aYear>65000 ) return 2;
00194  nDays = DaysOfMonth( aYear, aMonth );
00195  if ( nDays==0 ) return 3;
00196  if ( aDay<1 ) return 4;
00197  return aDay>nDays ? 5 : 0;
00198 }
00199 
00200 int gDateTime::thisTimeCheck (t_uint8 aHour, t_uint8 aMin, t_uint8 aSec)
00201 {
00202  return
00203      (aHour<24 &&
00204       aMin<60 && aSec<60)==false;
00205 }
00206 
00207 int gDateTime::thisConvertFromStamp (t_stamp aStamp)
00208 {
00209  struct tm* pTM;
00210  time_t tStamp = (time_t)aStamp;
00211 
00212  pTM = gmtime( &tStamp );
00213  if ( pTM==nil ) return -1;
00214  year = (t_int16)pTM->tm_year+1900;
00215  month = (t_uint8)pTM->tm_mon+1;
00216  day = (t_uint8)pTM->tm_mday;
00217  hour = (t_uint8)pTM->tm_hour;
00218  minu = (t_uint8)pTM->tm_min;
00219  sec =(t_uint8)pTM->tm_sec;
00220  ;
00221  wday = (t_uint8)pTM->tm_wday;
00222  yday = (t_uint16)pTM->tm_yday;
00223  isdst = (t_int8)pTM->tm_isdst;
00224  return 0;
00225 }
00226 
00227 int gDateTime::thisConvertToStamp (gDateTime& aDtTm, t_stamp& aStamp)
00228 {
00229  // Converts aDtTm into a timestamp (aStamp)
00230  time_t tStamp;
00231  struct tm aTM;
00232 
00233  // Within gobj lib, stamp 0 is invalid!, see below
00234  aStamp = 0;  // Default result already here, since mktime may fail, obviously!
00235  if ( thisConvertTo_libc_tm( aDtTm, &aTM )!=0 )
00236      return 4;  // Invalid date
00237  tStamp = mktime( &aTM );
00238  DBGPRINT_MIN("{[%d,%d,%d],dst?%d|%ld}",aTM.tm_year,aTM.tm_mon,aTM.tm_mday,aTM.tm_isdst,(long)tStamp);
00239  DBGPRINT_MIN("{tzname(%d)=%s:%s|%s}",daylight,tzname[daylight],tzname[0],tzname[1]);
00240  if ( tStamp==(time_t)-1 ) {
00241      // Cannot be represented as calendar time (a.k.a epoch time)
00242      return 8;
00243  }
00244  aStamp = (t_stamp)tStamp;
00245  // All ok, so returns 0
00246  return 0;
00247 }
00248 
00249 int gDateTime::thisConvertTo_libc_tm (gDateTime& aDtTm, struct tm* pTM)
00250 {
00251  ASSERTION(pTM!=nil,"pTM!=nil");
00252  memset( pTM, 0x0, sizeof(struct tm) );
00253  // memset: not needed, but useful if tm is changed,
00254  // or if some checks fail
00255  if ( thisDateTimeCheck( aDtTm, 1900 )!=0 )
00256      return 1;
00257  // (Note: parameter 1900 depends clearly on libc functions!)
00258  // Here we are sure year>=1900, and month>=1, ...etc
00259  pTM->tm_year = aDtTm.year-1900;
00260  pTM->tm_mon = aDtTm.month-1;
00261  pTM->tm_mday = aDtTm.day;
00262  pTM->tm_hour = aDtTm.hour;
00263  pTM->tm_min = aDtTm.minu;
00264  pTM->tm_sec = aDtTm.sec;
00265  pTM->tm_wday = aDtTm.wday;
00266  pTM->tm_yday = (int)aDtTm.yday;
00267  pTM->tm_isdst = aDtTm.isdst;
00268  DBGPRINT_MIN("{tm_isdst=%d}",aDtTm.isdst);
00269  return aDtTm.isdst==-1 ? -1 : 0;
00270 }
00271 ////////////////////////////////////////////////////////////
00272 // gTimeStamp - Stamp class
00273 // ---------------------------------------------------------
00274 gTimeStamp::gTimeStamp (t_stamp aStamp)
00275     : gUInt( aStamp ),
00276       iValid( aStamp!=0 )  //iValid=1 means valid!
00277 {
00278 }
00279 
00280 gTimeStamp::gTimeStamp (gDateTime& aDtTm)
00281     : iValid( aDtTm.IsOk()==true )
00282 {
00283  SetStamp( aDtTm.GetTimeStamp() );
00284 }
00285 
00286 gTimeStamp::~gTimeStamp ()
00287 {
00288 }
00289 
00290 bool gTimeStamp::IsOk ()
00291 {
00292  return (bool)(iValid = c!=0);
00293 }
00294 
00295 bool gTimeStamp::SetStamp (t_stamp aStamp)
00296 {
00297  return SetUInt( (unsigned)aStamp );
00298 }
00299 
00300 bool gTimeStamp::SetUInt (unsigned v)
00301 {
00302  gUInt::SetUInt( v );
00303  return IsOk();
00304 }
00305 ////////////////////////////////////////////////////////////
00306 

Generated on Sat Aug 18 02:40:51 2007 for xpfweb_v2x lib by  doxygen 1.4.2