• Main Page
  • Classes
  • Files
  • File List

datetime.h

00001 //-< DATEIME.H >-----------------------------------------------------*--------*
00002 // GigaBASE                  Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Post Relational Database Management System)                      *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     20-Nov-98    K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 10-Dec-98    K.A. Knizhnik  * GARRET *
00007 //-------------------------------------------------------------------*--------*
00008 // Date-time field type
00009 //-------------------------------------------------------------------*--------*
00010 
00011 #ifndef __DATETIME_H__
00012 #define __DATETIME_H__
00013 
00014 #include "stdtp.h"
00015 #include "class.h"
00016 
00017 BEGIN_GIGABASE_NAMESPACE
00018 
00019 
00023 class GIGABASE_DLL_ENTRY dbDateTime {
00024     int4 stamp;
00025   public:
00026     bool operator == (dbDateTime const& dt) const {
00027         return stamp == dt.stamp;
00028     }
00029     bool operator != (dbDateTime const& dt) const {
00030         return stamp != dt.stamp;
00031     }
00032     bool operator > (dbDateTime const& dt) const {
00033         return stamp > dt.stamp;
00034     }
00035     bool operator >= (dbDateTime const& dt) const {
00036         return stamp >= dt.stamp;
00037     }
00038     bool operator < (dbDateTime const& dt) const {
00039         return stamp < dt.stamp;
00040     }
00041     bool operator <= (dbDateTime const& dt) const {
00042         return stamp <= dt.stamp;
00043     }
00044     int operator - (dbDateTime const& dt) const {
00045         return stamp - dt.stamp;
00046     }
00047     int operator + (dbDateTime const& dt) const {
00048         return stamp + dt.stamp;
00049     }
00050 
00054     static dbDateTime current() {
00055 #ifdef _WINCE
00056         SYSTEMTIME st;
00057         GetSystemTime(&st);
00058         return dbDateTime(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
00059 #else
00060         return dbDateTime(time(NULL));
00061 #endif
00062     }
00063     
00067     dbDateTime(time_t t) {
00068         stamp = (int4)t;
00069     }
00070     
00074     dbDateTime() {
00075         stamp = -1;
00076     }
00077     
00081     bool isValid() const {
00082         return stamp != -1;
00083     }
00084 
00088     time_t asTime_t() const { return stamp; }
00089 
00093     void clear() { stamp = -1; }
00094 
00104     dbDateTime(int year, int month, int day,
00105                int hour=0, int min=0, int sec = 0)
00106     {
00107 #ifdef _WINCE
00108         SYSTEMTIME st;
00109         ULARGE_INTEGER ft;
00110         st.wYear = year; 
00111         st.wMonth = month; 
00112         st.wDay = day; 
00113         st.wHour = hour; 
00114         st.wMinute = min; 
00115         st.wSecond = sec; 
00116         st.wMilliseconds = 0; 
00117         SystemTimeToFileTime(&st, (LPFILETIME)&ft);        
00118         stamp = (int4)(ft.QuadPart/1000000);
00119 #else
00120         struct tm t;
00121         t.tm_year = year > 1900 ? year - 1900 : year;
00122         t.tm_mon = month-1;
00123         t.tm_mday = day;
00124         t.tm_hour = hour;
00125         t.tm_min = min;
00126         t.tm_sec = sec;
00127         t.tm_isdst = -1;
00128         stamp = (int4)mktime(&t);
00129 #endif
00130     }
00131     
00135     dbDateTime(int hour, int min) {
00136         stamp = (hour*60+min)*60;
00137     }
00138 
00139 #if defined(HAVE_LOCALTIME_R) && !defined(NO_PTHREADS)
00140 
00143     int year() {
00144         struct tm t;
00145         time_t tt = (nat4)stamp;
00146         return localtime_r(&tt, &t)->tm_year + 1900;
00147     }
00151     int month() { // 1..12
00152         struct tm t;
00153         time_t tt = (nat4)stamp;
00154         return localtime_r(&tt, &t)->tm_mon + 1;
00155     }
00159     int day() { // 1..31
00160         struct tm t;
00161         time_t tt = (nat4)stamp;
00162         return localtime_r(&tt, &t)->tm_mday;
00163     }
00167     int dayOfYear() { // 1..366
00168         struct tm t;
00169         time_t tt = (nat4)stamp;
00170         return localtime_r(&tt, &t)->tm_yday+1;
00171     }
00175     int dayOfWeek() { // 1..7
00176         struct tm t;
00177         time_t tt = (nat4)stamp;
00178         return localtime_r(&tt, &t)->tm_wday+1;
00179     }
00183     int hour() { // 0..24
00184         struct tm t;
00185         time_t tt = (nat4)stamp;
00186         return localtime_r(&tt, &t)->tm_hour;
00187     }
00191     int minute() { // 0..59
00192         struct tm t;
00193         time_t tt = (nat4)stamp;
00194         return localtime_r(&tt, &t)->tm_min;
00195     }
00199     int second() { // 0..59
00200         struct tm t;
00201         time_t tt = (nat4)stamp;
00202         return localtime_r(&tt, &t)->tm_sec;
00203     }
00211     char_t* asString(char* buf, int buf_size, char_t const* format = "%c") const {
00212         struct tm t;
00213         time_t tt = (nat4)stamp;
00214         strftime(buf, buf_size, format, localtime_r(&tt, &t));
00215         return buf;
00216     }
00220     static dbDateTime currentDate() {
00221         struct tm t;
00222         time_t curr = time(NULL);
00223         localtime_r(&curr, &t);;
00224         t.tm_hour = 0;
00225         t.tm_min = 0;
00226         t.tm_sec = 0;
00227         return dbDateTime(mktime(&t));
00228     }
00229 #elif defined(_WINCE)
00230     SYSTEMTIME& localtime(SYSTEMTIME& st) const {
00231         ULARGE_INTEGER ui;
00232         ui.QuadPart = (ULONGLONG)stamp*1000000;
00233         FileTimeToSystemTime((FILETIME*)&ui, &st); 
00234         return st;
00235     }
00239     int year() {
00240         SYSTEMTIME st;
00241         return localtime(st).wYear;
00242     }
00246     int month() { // 1..12
00247         SYSTEMTIME st;
00248         return localtime(st).wMonth;
00249     }
00253     int day() { // 1..31
00254         SYSTEMTIME st;
00255         return localtime(st).wDay;
00256     }
00260     int dayOfWeek() { // 1..7
00261         SYSTEMTIME st;
00262         return localtime(st).wDayOfWeek;
00263     }
00267     int hour() { // 0..24
00268         SYSTEMTIME st;
00269         return localtime(st).wHour;
00270     }
00274     int minute() { // 0..59
00275         SYSTEMTIME st;
00276         return localtime(st).wMinute;
00277     }
00281     int second() { // 0..59
00282         SYSTEMTIME st;
00283         return localtime(st).wSecond;
00284     }
00292     char_t* asString(char_t* buf, int buf_size, char_t const* format = _T("%c")) const {
00293         SYSTEMTIME st;
00294         localtime(st);
00295         wchar_t cnvBuf[256];
00296         wsprintf(cnvBuf, _T("%02d/02d/%40d %02d:%02d:%02d"), st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
00297         wsprintf(buf, _T("%.*s"), buf_size, cnvBuf);
00298         return buf;
00299     }
00303     static dbDateTime currentDate() {
00304         SYSTEMTIME st;
00305         GetSystemTime(&st);
00306         return dbDateTime(st.wYear, st.wMonth, st.wDay);
00307     }
00308 #else
00309 
00312     int year() {
00313         time_t tt = (nat4)stamp;
00314         return localtime(&tt)->tm_year + 1900;
00315     }
00319     int month() { // 1..12
00320         time_t tt = (nat4)stamp;
00321         return localtime(&tt)->tm_mon + 1;
00322     }
00326     int day() { // 1..31
00327         time_t tt = (nat4)stamp;
00328         return localtime(&tt)->tm_mday;
00329     }
00333     int dayOfYear() { // 1..366
00334         time_t tt = (nat4)stamp;
00335         return localtime(&tt)->tm_yday+1;
00336     }
00340     int dayOfWeek() { // 1..7
00341         time_t tt = (nat4)stamp;
00342         return localtime(&tt)->tm_wday+1;
00343     }
00347     int hour() { // 0..24
00348         time_t tt = (nat4)stamp;
00349         return localtime(&tt)->tm_hour;
00350     }
00354     int minute() { // 0..59
00355         time_t tt = (nat4)stamp;
00356         return localtime(&tt)->tm_min;
00357     }
00361     int second() { // 0..59
00362         time_t tt = (nat4)stamp;
00363         return localtime(&tt)->tm_sec;
00364     }
00372     char_t* asString(char_t* buf, int buf_size, char_t const* format = _T("%c")) const {
00373         time_t tt = (nat4)stamp;
00374 #if defined(_WINCE)
00375         struct tm* t = localtime(&tt);
00376         wchar_t cnvBuf[256];
00377         wsprintf(cnvBuf, _T("%02d/02d/%40d %02d:%02d:%02d"),  t->tm_mday+1, t->tm_mon+1, t->tm_year + 1900,
00378                         t->tm_hour, t->tm_min, t->tm_sec);
00379         wsprintf(buf, _T("%.*s"), buf_size, cnvBuf);
00380 #else
00381         STRFTIME(buf, buf_size, format, localtime(&tt));
00382 #endif
00383         return buf;
00384     }
00388     static dbDateTime currentDate() {
00389         time_t curr = time(NULL);
00390         struct tm* tp = localtime(&curr);;
00391         tp->tm_hour = 0;
00392         tp->tm_min = 0;
00393         tp->tm_sec = 0;
00394         return dbDateTime(mktime(tp));
00395     }
00396 #endif
00397 
00398 #ifdef _WINCE
00399     CLASS_DESCRIPTOR(dbDateTime,
00400                      (KEY(stamp,INDEXED|HASHED),
00401                       METHOD(year), METHOD(month), METHOD(day), METHOD(dayOfWeek),
00402                       METHOD(hour), METHOD(minute), METHOD(second)));
00403 #else
00404     CLASS_DESCRIPTOR(dbDateTime,
00405                      (KEY(stamp,INDEXED|HASHED),
00406                       METHOD(year), METHOD(month), METHOD(day),
00407                       METHOD(dayOfYear), 
00408                       METHOD(dayOfWeek),
00409                       METHOD(hour), METHOD(minute), METHOD(second)));
00410 #endif
00411 
00417     dbQueryExpression operator == (char_t const* field) {
00418         dbQueryExpression expr;
00419         expr = dbComponent(field,_T("stamp")),_T("="),stamp;
00420         return expr;
00421     }
00427     dbQueryExpression operator != (char_t const* field) {
00428         dbQueryExpression expr;
00429         expr = dbComponent(field,_T("stamp")),_T("<>"),stamp;
00430         return expr;
00431     }
00437     dbQueryExpression operator < (char_t const* field) {
00438         dbQueryExpression expr;
00439         expr = dbComponent(field,_T("stamp")),_T(">"),stamp;
00440         return expr;
00441     }
00447     dbQueryExpression operator <= (char_t const* field) {
00448         dbQueryExpression expr;
00449         expr = dbComponent(field,_T("stamp")),_T(">="),stamp;
00450         return expr;
00451     }
00457     dbQueryExpression operator > (char_t const* field) {
00458         dbQueryExpression expr;
00459         expr = dbComponent(field,_T("stamp")),_T("<"),stamp;
00460         return expr;
00461     }
00467     dbQueryExpression operator >= (char_t const* field) {
00468         dbQueryExpression expr;
00469         expr = dbComponent(field,_T("stamp")),_T("<="),stamp;
00470         return expr;
00471     }
00479     friend dbQueryExpression between(char_t const* field, dbDateTime& from,
00480                                      dbDateTime& till)
00481     {
00482         dbQueryExpression expr;
00483         expr=dbComponent(field,_T("stamp")),_T("between"),from.stamp,_T("and"),till.stamp;
00484         return expr;
00485     }
00486 
00491     static dbQueryExpression ascent(char_t const* field) {
00492         dbQueryExpression expr;
00493         expr=dbComponent(field,_T("stamp"));
00494         return expr;
00495     }
00500     static dbQueryExpression descent(char_t const* field) {
00501         dbQueryExpression expr;
00502         expr=dbComponent(field,_T("stamp")),_T("desc");
00503         return expr;
00504     }
00505 };
00506 
00507 END_GIGABASE_NAMESPACE
00508 
00509 #endif
00510 
00511 
00512 
00513 
00514 
00515 
00516 

Generated on Mon Aug 23 2010 00:04:01 for GigaBASE by  doxygen 1.7.1