include/DataType.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *    Copyright (C) Lakshya Solutions Ltd. All rights reserved.            *
   4  *                                                                         *
   5  ***************************************************************************/
   6
   7 #ifndef DATATYPE_H
   8 #define DATATYPE_H
   9 #include<sqlext.h>
  10 #include<sqltypes.h>
  11 #include<ErrorType.h>
  12 #include<Config.h>
  13 #include<Function.h>
  14 typedef int JulianRep;
  15
  16
  17 /**
  18 * @class DataType
  19 * Data Types supported by the database system.
  20 * <br/>
  21 *
  22 */
  23 enum DataType {
  24    typeInt         =  0, /**<integer type*/
  25    typeLong        =  1,
  26    typeLongLong    =  2,
  27    typeShort       =  3,
  28    typeByteInt     =  4,
  29
  30    typeDouble      =  10,
  31    typeFloat       =  11,
  32    typeDecimal     =  12,
  33
  34    typeDate        =  20,
  35    typeTime        =  21,
  36    typeTimeStamp   =  22,
  37
  38    typeString      =  30,
  39    typeBinary      =  31,
  40    typeVarchar     =  32,
  41
  42    typeComposite   =  98,
  43    typeULong       =  99,
  44    typeUnknown     =  100
  45 };
  46
  47 /**
  48 * @class ComparisionOp
  49 * Comparision operators supported by the database system.
  50 * <br/>
  51 *
  52 */
  53 enum ComparisionOp {
  54     OpEquals = 0,
  55     OpNotEquals,
  56     OpLessThan,
  57     OpLessThanEquals,
  58     OpGreaterThan,
  59     OpGreaterThanEquals,
  60     OpLike, // for Like operator
  61     OpIsNull,
  62     OpInvalidComparisionOp
  63 };
  64 static char CompOpNames[][20] =
  65 {
  66     "Equals", "NotEquals", "LessThan", "LessThanEquals", "GreaterThan",
  67     "GreaterThanEquals", "Like", "isNULL", "Invalid"
  68 };
  69
  70
  71 /**
  72 * @class LogicalOp
  73 * Logical operators supported by the database system.
  74 * <br/>
  75 *
  76 */
  77 enum LogicalOp {
  78     OpAnd = 0,
  79     OpOr,
  80     OpNot,
  81     OpInvalidLogicalOp
  82 };
  83
  84 static char LogOpNames[][10] =
  85 {
  86     "AND", "OR", "NOT", "Invalid"
  87 };
  88
  89 class AllDataType
  90 {
  91     public:
  92     inline static long size(DataType type, int length =0);
  93     static char* getSQLString(DataType type);
  94     static SQLSMALLINT convertToSQLType(DataType type);
  95     static SQLSMALLINT convertToCSQLSQLType(DataType type);
  96     static SQLSMALLINT convertToSQL_C_Type(DataType type,TDBInfo tdbname=mysql);
  97     static DataType convertFromSQLType(SQLSMALLINT type,int length=0, int scale=0, TDBInfo tdbname=mysql);
  98
  99     inline static void copyVal(void* dest, void *src, DataType type, int length = 0,int dbFlag=0);
 100     inline static void copyZeroVal(void* dest, DataType type, int length = 0);
 101     inline static void cachecopyVal(void* dest, void *src, DataType type, int length = 0,int dbFlag=0);
 102     inline static void addVal(void* dest, void *src, DataType type);
 103     static void divVal(double* dest, int src, DataType type);
 104     static void subVal(void* dest, void *src, DataType type);
 105     static void mulVal(void* dest, void *src, DataType type);
 106     static void mudVal(void* dest, void *src, DataType type);
 107     static void divVal(void* dest, void *src, DataType type);
 108     static void increment(void* dest, void *src, DataType type);
 109     static bool isValueZero(void* dest, DataType type);
 110
 111     inline static bool compareVal(void *src1, void *src2, ComparisionOp op,
 112                            DataType type, long length = 0);
 113     static bool compareIntVal(void* src1, void* src2, ComparisionOp op);
 114     static bool compareLongVal(void* src1, void* src2, ComparisionOp op);
 115     static bool compareLongLongVal(void* src1, void* src2, ComparisionOp op);
 116     static bool compareShortVal(void* src1, void* src2, ComparisionOp op);
 117     static bool compareByteIntVal(void* src1, void* src2, ComparisionOp op);
 118     static bool compareDoubleVal(void* src1, void* src2, ComparisionOp op);
 119     static bool compareFloatVal(void* src1, void* src2, ComparisionOp op);
 120     static bool compareDateVal(void* src1, void* src2, ComparisionOp op);
 121     static bool compareTimeVal(void* src1, void* src2, ComparisionOp op);
 122     static bool compareTimeStampVal(void* src1, void* src2, ComparisionOp op);
 123     static bool compareStringVal(void* src1, void* src2, ComparisionOp op);
 124     static bool compareBinaryVal(void* src1, void* src2,
 125                                  ComparisionOp op, int length);
 126
 127
 128     static void convert(DataType srcType, void *src, DataType destType, void *dest, int length=0);
 129     static void convertToInt(void* dest, void* src, DataType srcType);
 130     static void convertToLong(void* dest, void* src, DataType srcType);
 131     static void convertToLongLong(void* dest, void* src, DataType srcType);
 132     static void convertToShort(void* dest, void* src, DataType srcType);
 133     static void convertToByteInt(void* dest, void* src, DataType srcType);
 134     static void convertToFloat(void* dest, void* src, DataType srcType);
 135     static void convertToDouble(void* dest, void* src, DataType srcType);
 136     static void convertToString(void* dest, void* src, DataType srcType, int length=0,TDBInfo tdbname=mysql);
 137     static void convertToDate(void* dest, void* src, DataType srcType);
 138     static void convertToTime(void* dest, void* src, DataType srcType);
 139     static void convertToTimeStamp(void* dest, void* src, DataType srcType);
 140     static void convertToBinary(void* dest, void* src, DataType srcType, int length);
 141     static DataType getCsqlTypeFromFunctionType(FunctionType type);
 142     static  DataType getCsqlTypeFromFunctionTypeForComparision(FunctionType type);
 143     static void memoryset(void *value,DataType type);
 144     inline static ComparisionOp getComparisionOperator(char *str);
 145
 146     static void* alloc(DataType type, int length =0);
 147     static DbRetVal strToValue(void *dest, char *src, DataType type, int length=0);
 148     static int printVal(void *src, DataType type, int length,int dbFlag=0);
 149     inline static bool isValidFieldForAvg(DataType type);
 150 };
 151
 152
 153 /**
 154 * @class ByteInt
 155 * Represents 8 bit integer.
 156 * <br/>
 157 *
 158 */
 159 class ByteInt {
 160
 161     public:
 162     ByteInt() { }
 163
 164     /** copy constructor
 165     */
 166     ByteInt(const ByteInt &v) { val = v.val; }
 167     /** constructor with char
 168     *   @param v char value
 169     */
 170     ByteInt(char v) { val = v; }
 171     operator int() const { return (int) val; }
 172     char operator=(ByteInt v)   { return val = v.val; }
 173     char operator=(char v)          { return val = v; }
 174     char operator+=(ByteInt v)  { return val += v.val; }
 175     char operator+=(char v)         { return val += v; }
 176     char operator-=(ByteInt v)  { return val -= v.val; }
 177     char operator-=(char v)         { return val -= v; }
 178     char operator*=(ByteInt v)  { return val *= v.val; }
 179     char operator*=(char v)         { return val *= v; }
 180     char operator/=(ByteInt v)  { return val /= v.val; }
 181     char operator/=(char v)         { return val /= v; }
 182     char operator%=(ByteInt v)  { return val %= v.val; }
 183     char operator%=(char v)         { return val %= v; }
 184     char operator<<=(ByteInt v) { return val <<= v.val; }
 185     char operator<<=(char v)        { return val <<= v; }
 186     char operator>>=(ByteInt v) { return val >>= v.val; }
 187     char operator>>=(char v)        { return val >>= v; }
 188     char operator&=(ByteInt v)  { return val &= v.val; }
 189     char operator&=(char v)         { return val &= v; }
 190     char operator|=(ByteInt v)  { return val |= v.val; }
 191     char operator|=(char v)         { return val |= v; }
 192     char operator^=(ByteInt v)  { return val ^= v.val; }
 193     char operator^=(char v)         { return val ^= v; }
 194     char operator++()               { return val++; }
 195     char operator++(int)               { char tmp = val; val++; return val; }
 196     char operator--()               { return val--; }
 197     char operator--(int)               { char tmp = val; val--; return val; }
 198
 199     private:
 200     signed char val;
 201 };
 202
 203
 204 /**
 205 * @class Date
 206 * Represents Date Data type.
 207 * <br/>
 208 *
 209 */
 210 class Date {  // The class a user would declare to hold date
 211
 212     public:
 213     Date() {julianDate = 0;}
 214     Date(JulianRep julian) : julianDate(julian) {}
 215
 216     /** constructor with year, month, day
 217     *   @param year year
 218     *   @param month month
 219     *   @param day day
 220     */
 221     Date(int year, int month, int day);
 222
 223     Date(const Date &d2) { julianDate = d2.julianDate; }
 224     Date& operator=(const Date& d2)
 225         { julianDate=d2.julianDate; return *this; }
 226
 227     /** sets the date with specified year, month, day
 228     *   @param year year
 229     *   @param month month
 230     *   @param day day
 231     */
 232     int set(int year, int month, int day);
 233     int set(const struct tm *tmptr);
 234
 235     /** get year, month, day of the date
 236     *   @param year year IN
 237     *   @param month month IN
 238     *   @param day day IN
 239     */
 240     int get(int &year, int &month, int &day) const;
 241
 242     /** checks for the validity of the date
 243     */
 244     bool isValid() const;
 245
 246     /** resets the date to zero
 247     */
 248     void setNull() { julianDate = 0;}
 249
 250     /** returns day of the week
 251     */
 252     int dayOfWeek() const;
 253
 254     /** returns day of the week.
 255     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday".
 256     */
 257     const char *dayOfWeekName() const;
 258
 259     /** returns day of the week abbreviation
 260     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 261     */
 262     const char *dayOfWeekAbbr() const;
 263
 264     /** returns day of the week.
 265     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday".
 266     */
 267     static const char *dayOfWeekName(int day); // 0--> Sunday
 268
 269     /** returns day of the week abbreviation
 270     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 271     */
 272     static const char *dayOfWeekAbbr(int day);
 273
 274     static int dayOfWeek(JulianRep juldate);
 275
 276
 277     void addDay(int noOfDays);
 278     void subDay(int noOfDays);
 279     void addMonth(int noOfMons);
 280     void subMonth(int noOfMons);
 281     void addYear(int noOfYrs);
 282     void subYear(int noOfYrs);
 283
 284     /** returns the day of the month. Values are 1 to 31
 285     */
 286     int dayOfMonth() const;
 287
 288     int dayOfYear() const;
 289
 290     /** returns the month Values are 1 to 12.
 291     */
 292     int month() const;
 293
 294     /** returns the month name
 295     *   values are "January", "February", "March",     "April",   "May",      "June",
 296     *   "July",    "August",   "September", "October", "November", "December"
 297     */
 298     const char *monthName() const;
 299
 300     /** returns the month name abbreviation
 301     * values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 302     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 303     */
 304     const char *monthAbbr() const;
 305
 306     /** returns the month name
 307     *   values are "January", "February", "March",     "April",   "May",      "June",
 308     *   "July",    "August",   "September", "October", "November", "December"
 309     */
 310     static const char *monthName(int month);
 311
 312
 313     /** returns the month name abbreviation
 314     * values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 315     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 316     */
 317     static const char *monthAbbr(int month);
 318
 319     /** parses the date string passed and stores it
 320     *It should of the format "mm/dd/yyyy"
 321     */
 322     int parseFrom(const char *s);
 323
 324     int getCalDay() { return julianDate;}
 325     static void changeToCsqlFormat(char *src);
 326
 327
 328     Date &operator++() { julianDate++; return *this; }
 329     Date &operator--() { julianDate--; return *this; }
 330
 331     Date &operator+=(int days) { julianDate += days; return *this;}
 332     Date &operator-=(int days) { julianDate -= days; return *this;}
 333
 334     /** returns the year
 335     */
 336     int year() const;
 337
 338     /** checks for the validity of the date
 339     */
 340     static bool isValidDate(int year, int month, int day);
 341
 342     friend Date  operator+(const Date &d1, int days);
 343     friend Date  operator+(int days, const Date &d1);
 344     friend Date  operator-(const Date &d1, int days);
 345     friend int  operator-(const Date &d1, const Date & d2);
 346     friend int  operator<(const Date &d1 ,const Date &d2);
 347     friend int  operator>(const Date &d1 ,const Date &d2);
 348     friend int  operator<=(const Date &d1 ,const Date &d2);
 349     friend int  operator>=(const Date &d1 ,const Date &d2);
 350     friend int  operator==(const Date &d1 ,const Date &d2);
 351     friend int  operator!=(const Date &d1 ,const Date &d2);
 352
 353     /** checks for leap year
 354     */
 355     static bool isLeapYear(int year);
 356
 357     /** returns the number of days in the specified month of the year.
 358     */
 359     static int daysInMonth(int month, int year);
 360
 361     static int YMDToJulian(int year,int mon,int day, JulianRep &julian);
 362     static int julianToYMD(JulianRep julian,int &year,int &month,int &day);
 363
 364     private:
 365     JulianRep julianDate;
 366
 367
 368
 369 };
 370
 371 /**
 372 * @class Time
 373 * Represents Time Data type.
 374 * <br/>
 375 *
 376 */
 377 class Time {  // The class a user would declare to hold time
 378     public:
 379     Time() {timeVal = 0;}
 380
 381     /** Overloaded constructor
 382     *   @param hours hours
 383     *   @param mins mins
 384     *   @param secs secs
 385     *   @param usec usec
 386     */
 387     Time(int hours, int mins, int secs, int usec = 0);
 388     Time(int totalSecs) : timeVal(totalSecs) {;}
 389     Time(const Time &d2) { timeVal = d2.timeVal; }
 390     Time& operator=(const Time& d2) { timeVal=d2.timeVal; return *this; }
 391
 392     /** sets the time with specified hours, mins, secs
 393     *   @param hours hours
 394     *   @param mins mins
 395     *   @param secs secs
 396     *   @param usec usec
 397     */
 398     int set(int hours, int mins, int secs, int usec = 0);
 399
 400     /** retrieves the time using IN parameters
 401     *   @param hours hours
 402     *   @param mins mins
 403     *   @param secs secs
 404     */
 405     int get(int &hours, int &mins, int &secs) const;
 406
 407
 408
 409
 410     int getCalSec(){ return timeVal/1000; }
 411     /** checks for the validity of the time
 412     */
 413     bool isValid() const;
 414
 415     /** resets the time
 416     */
 417     void setNull() { timeVal = -1;}
 418
 419     int secondsSinceMidnight() const { return timeVal/10000;}
 420
 421     /** returns the microsecs
 422     */
 423     int usec() const; // to nearest 100 of usec.
 424
 425     /** returns the millisecs
 426     */
 427     int msec() const;
 428
 429     /** returns the secs
 430     */
 431     int seconds() const;
 432
 433     /** returns the minutes
 434     */
 435     int minutes() const;
 436
 437     /** returns the hours
 438     */
 439     int hours() const;
 440
 441     //
 442     int addSec(int secs);
 443     int subSec(int secs);
 444     int addMin(int mins);
 445     int subMin(int mins);
 446     int addHour(int hours);
 447     int subHour(int hours);
 448
 449     /** sets the millisecs
 450     */
 451     int setMsec(int ms);
 452
 453     /** sets the microsecs
 454     */
 455     int setUsec(int us);
 456
 457     /** parses the time string passed and stores it
 458     *It should of the format "hh:mm::ss"
 459     */
 460     int parseFrom(const char *s);
 461
 462     Time &operator++() { timeVal += 10000; return *this; }
 463     Time &operator--() { timeVal -= 10000; return *this; }
 464
 465     Time &operator+=(int seconds) { timeVal += seconds*10000; return *this; }
 466     Time &operator-=(int seconds) { timeVal -= seconds*10000; return *this; }
 467
 468
 469     /** checks for the validity of the time specified
 470     */
 471     static bool isValidTime(int hours, int mins, int secs);
 472
 473     friend Time operator+(const Time &t1, int seconds);
 474     friend Time operator+(int seconds, const Time &t1);
 475     friend Time operator-(const Time &t1, int seconds);
 476     friend int  operator-(const Time &t1, const Time& t2);
 477     friend int  operator<(const Time &t1 ,const Time &t2 );
 478     friend int  operator>(const Time &t1 ,const Time &t2 );
 479     friend int  operator<=(const Time &t1 ,const Time &t2 );
 480     friend int  operator>=(const Time &t1 ,const Time &t2 );
 481     friend int  operator==(const Time &t1 ,const Time &t2 );
 482     friend int  operator!=(const Time &t1 ,const Time &t2 );
 483
 484
 485     private:
 486     int timeVal;
 487 };
 488
 489 /**
 490 * @class TimeStamp
 491 * Represents TimeStamp Data type.
 492 * <br/>
 493 *
 494 */
 495 class TimeStamp {
 496
 497     public:
 498     TimeStamp() {}
 499
 500     /** Overloaded constructor
 501     *   @param year year
 502     *   @param month month
 503     *   @param day day
 504     *   @param hours hours
 505     *   @param mins mins
 506     *   @param secs secs
 507     *   @param usec usec
 508     */
 509     TimeStamp(int year, int month, int day, int hour, int minute, int sec, int usec = 0) :
 510         date(year, month, day), time(hour, minute, sec, usec) { }
 511
 512     TimeStamp(const TimeStamp &ts)
 513     { date = ts.date; time = ts.time; }
 514     TimeStamp(const Date &d, Time &t) : date(d), time(t) {}
 515
 516
 517     TimeStamp& operator=(const TimeStamp& d2)
 518         { date=d2.date; time = d2.time; return *this; }
 519
 520     /** get year, month, day from the date part of the timestamp
 521     *   @param year year IN
 522     *   @param month month IN
 523     *   @param day day IN
 524     */
 525     int getDate(int &year, int &month, int &day)
 526          { return date.get(year, month, day); }
 527
 528     /** get the date part of the timestamp
 529     *   @param Date date
 530     */
 531    void getDate(Date &newDate) const
 532          { newDate = date; }
 533
 534     /** sets the date with specified year, month, day
 535     *   @param year year
 536     *   @param month month
 537     *   @param day day
 538     */
 539     int setDate(int year, int month, int day)
 540          { return date.set(year, month, day); }
 541
 542     /** set the date part of the timestamp
 543     *   @param Date date
 544     */
 545     void setDate(const Date &newDate)
 546          { date = newDate; }
 547
 548
 549     operator Date() { return date; }
 550     operator Time() { return time; }
 551
 552
 553
 554     /** retrieves the time using IN parameters
 555     *   @param hours hours
 556     *   @param mins mins
 557     *   @param secs secs
 558     */
 559     int getTime(int &hours, int &mins, int &secs) const
 560          { return time.get(hours, mins, secs); }
 561     /** retrieves the time part of the timestamp
 562     *   @param newTime Time
 563     */
 564     void getTime(Time &newTime) const
 565          { newTime = time; }
 566
 567     /** sets the time with specified hours, mins, secs
 568     *   @param hours hours
 569     *   @param mins mins
 570     *   @param secs secs
 571     *   @param usec usec
 572     */
 573     int setTime(int hours, int mins, int secs, int usec = 0)
 574          { return time.set(hours, mins, secs, usec); }
 575
 576     /** set the time part of the timestamp
 577     *   @param newTime Time
 578     */
 579     void setTime(const Time &newTime)
 580          { time = newTime; }
 581
 582     /** checks for the validity of the timestamp
 583     */
 584     bool isValid() const { return date.isValid() && time.isValid(); }
 585
 586     /** resets the date and time */
 587     void setNull() { date.setNull(); time.setNull(); }
 588
 589     /** returns day of the week. Values are 1-7
 590     */
 591     int dayOfWeek() const { return date.dayOfWeek(); }
 592
 593    /** returns day of the week.
 594     * values are "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Satur
 595 day".
 596     */
 597     const char *dayOfWeekName() const { return date.dayOfWeekName(); }
 598
 599     /** returns day of the week abbreviation
 600     * values are "Sun",    "Mon",    "Tue",     "Wed",       "Thu",      "Fri",    "Sat"
 601     */
 602     const char *dayOfWeekAbbr() const { return date.dayOfWeekAbbr(); }
 603
 604     /** returns the day of the month. Values are 1 to 31
 605     */
 606     int dayOfMonth() const { return date.dayOfMonth(); }
 607     int dayOfYear() const { return date.dayOfYear(); }
 608
 609     /** returns the month. Values are 1 to 12.
 610     */
 611
 612     int month() const { return date.month(); }
 613
 614     /** returns the month name
 615     *   values are "January", "February", "March",     "April",   "May",      "June",
 616     *   "July",    "August",   "September", "October", "November", "December"
 617     */
 618     const char *monthName() const { return date.monthName(); }
 619
 620     /** returns the month name abbreviation
 621     * Values are "Jan",     "Feb",      "Mar",      "Apr",     "May",      "Jun",
 622     * "Jul",     "Aug",      "Sep",      "Oct",     "Nov",      "Dec"
 623     */
 624     const char *monthAbbr() const { return date.monthAbbr(); }
 625
 626     /** returns the year
 627     */
 628     int year() const { return date.year(); }
 629
 630     int secondsSinceMidnight() const { return time.secondsSinceMidnight(); }
 631     /** returns the seconds */
 632     int seconds() const { return time.seconds(); }
 633     /** returns the minutes */
 634     int minutes() const { return time.minutes(); }
 635     /** returns the hours */
 636     int hours() const { return time.hours(); }
 637     /** returns the millisecs */
 638     int msec() const { return time.msec(); }
 639     /** returns the microsecs */
 640     int usec() const { return time.usec(); }
 641
 642     /** sets the millisecs */
 643     int setMsec(int ms) { return time.setMsec(ms) ; }
 644     /** sets the microsecs */
 645     int setUsec(int us) { return time.setUsec(us) ; }
 646
 647     /** parses the date string passed and stores it
 648     *It should of the format "mm/dd/yyyy"
 649     */
 650     int parseDateFrom(const char *s) { return date.parseFrom(s); }
 651
 652     /** parses the time string passed and stores it
 653     *It should of the format "hh:mm::ss"
 654     */
 655
 656     int parseTimeFrom(const char *s) { return time.parseFrom(s); }
 657
 658     static void changeToCsqlFormat(char *src);
 659
 660     int parseFrom(const char *s);
 661     friend int  operator<(const TimeStamp &d1, const TimeStamp &d2);
 662     friend int  operator>(const TimeStamp &d1, const TimeStamp &d2);
 663     friend int  operator<=(const TimeStamp &d1, const TimeStamp &d2);
 664     friend int  operator>=(const TimeStamp &d1, const TimeStamp &d2);
 665     friend int  operator==(const TimeStamp &d1, const TimeStamp &d2);
 666     friend int  operator!=(const TimeStamp &d1, const TimeStamp &d2);
 667     void addYear(int noOfYrs ){ date.addYear(noOfYrs);}
 668
 669     void subYear(int noOfYrs ) {   date.subYear(noOfYrs); }
 670
 671     void addMonth(int noOfMons ) { date.addMonth(noOfMons);}
 672
 673     void subMonth(int noOfMons) { date.subMonth(noOfMons);}
 674
 675     void addDay(int noOfDays) { date.addDay(noOfDays);}
 676
 677     void subDay(int noOfDays) { date.subDay(noOfDays); }
 678
 679     void addHour(int hours);
 680
 681     void subHour(int hours);
 682
 683     void addMin(int noOfMins);
 684
 685     void subMin(int noOfMins);
 686
 687     void addSec(int noOfSecs);
 688
 689     void subSec(int noOfSecs);
 690
 691     int secDiff(TimeStamp &ts);
 692     int minDiff(TimeStamp &ts);
 693     int hourDiff(TimeStamp &ts);
 694     int dayDiff(TimeStamp &ts);
 695     int monthDiff(TimeStamp &ts);
 696     int yearDiff(TimeStamp &ts);
 697
 698     private:
 699     Date date;
 700     Time time;
 701 };
 702
 703 #include<DataTypeInline.h>
 704 #endif
 705
 706