(file) Return to CIMDateTime.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMDateTime.cpp between version 1.41 and 1.41.4.1

version 1.41, 2004/07/20 22:09:49 version 1.41.4.1, 2004/11/05 18:15:26
Line 30 
Line 30 
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              Willis White (whiwill@ibm.com) PEP #192
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 67 
Line 68 
 static const char _NULL_INTERVAL_TYPE_STRING[] = "00000000000000.000000:000"; static const char _NULL_INTERVAL_TYPE_STRING[] = "00000000000000.000000:000";
 static const char _NULL_DATE_TYPE_STRING[] = "00000000000000.000000-000"; static const char _NULL_DATE_TYPE_STRING[] = "00000000000000.000000-000";
  
 class CIMDateTimeRep  
   
   
   
   void CIMDateTimeRep::copy(CIMDateTimeRep * cTR)
 { {
 public:          //cout << "Start of Rep::copy" << endl;
     enum { FORMAT_LENGTH = 25 };          microSec = cTR->microSec;
           seconds = cTR->seconds;
           minutes = cTR->minutes;
           hours = cTR->hours;
           days = cTR->days;
           month = cTR->month;
           year = cTR->year;
           utcOffSet = cTR->utcOffSet;
           memcpy(data, cTR->data, sizeof(data));
           //cout << "end of Rep::copy" << endl <<endl;
       }
  
     //  Uint16 CIMDateTimeRep::set_microSec(String & mS)
     // Length of the string required to store only the date and time without  {
     // the UTC sign and UTC offset.      // update _rep->data to reflect change
     // Format is yyyymmddhhmmss.     /* String repData = String(data, FORMAT_LENGTH);
     // Note : The size does not include the null byte.      String begin_data = repData.subString(0, 15);
     //      char mic_buf [7];
     enum { DATE_TIME_LENGTH = 14 };      sprintf(mic_buf,"%06",atol(mS.getCString()));  // this is the only way I can gareentee the length of string
       String mic_str = String(mic_buf);
       String sum_data = begin_data.append(mic_str);
       String fin_data = sum_data.append(mS.subString(21,4));    */
  
     //      //cout << "begining of set_microSec" << endl;
     // Length of the string required to store the  formatted date and time      Uint32 ast_post;
     // Format is yyyy:mm:dd:hh:mm:ss.  
     //      ast_post = mS.find("*");
     enum { FORMATTED_DATE_TIME = 20 };      //cout <<"this is the try block inside set micro this mS " << mS << endl;
       if (ast_post == PEG_NOT_FOUND) {
       //cout << "check to see if it equals PEG_NOT_FOUND in microSecheck" << endl;
           set_data(mS, 15, 6);
           microSec = mS;
           return 2;
       }
   
      // cout << "after find  block" << endl;
       Uint32 sub_len = 6 - ast_post;
       String ast = "******";
       String in_comp = mS.subString(ast_post, sub_len);
       if (!String::compare(in_comp, ast, sub_len)){
           set_data(mS, 15, 6);
           microSec = mS;
           return 0;
       }
       else{
           cout << "error in set_microSec - this is the value " << mS << endl;
           return 1;
       }
   }
   
   void CIMDateTimeRep::set_data(String value, Uint32 index, Uint32 size)
   {
       //cout << "value is " << value << " this is index " << index << " this is size " << size << endl;
       //cout << "this is data " << (String)data << endl;
       for (Uint32 i=0; i < size; i++) {
          // cout << " this i " << i << " element of value " << value[i] << " element of data " << data[index+i] << endl;
           data[index+i] = value[i];
       }
   }
   
   void CIMDateTimeRep::set_seconds(String sec)
   {
       seconds = sec;
   }
   
   void CIMDateTimeRep::set_minutes(String min)
   {
       minutes = min;
   }
   
   void CIMDateTimeRep::set_hours(String ho)
   {
       hours = ho;
   }
   
   void CIMDateTimeRep::set_days(String da)
   {
       days = da;
   }
   
   void CIMDateTimeRep::set_month(String mon)
   {
       month = mon;
   }
   
   void CIMDateTimeRep::set_year(String ye)
   {
       year = ye;
   }
   
   Boolean CIMDateTimeRep::set_utcOffSet(String uOffSet)
   {
       if (uOffSet.size() != 4) {
           cout << "utc offset has the wrong format 1" << endl;
           return false;
       }
   
       char ch_one = (char) uOffSet[0];
       if (ch_one != ':' && ch_one != '+' && ch_one != '-') {
           cout << "utc offset has the wrong format 2" << endl;
           return false;
       }
   
       Uint32 spot = uOffSet.find("*");
       if(spot != PEG_NOT_FOUND){  // the UTC must not have astricks in it
           cout << "utc offset has the wrong format 3" << endl;
           return false;
       }
   
   
       String uOff_num = uOffSet.subString(1,3);
       for (int i=0; i < 3; i++) {
           if (!isdigit(uOff_num[i])) {
               cout << "utc off set contain non digit charichter" << endl;
               cout << "this is off set " << uOff_num << endl;
               return false;
           }
       }
   
       if (ch_one == (char)':' && !String::compare(uOff_num, "OOO")){    // intervals (:) must have 000 utc offset
           cout << "trying to incorrectly set a intervals time zone" << endl;
           return false;
       }
   
     // cout << "In set_uctOffSet the off set is " << uOffSet << endl;
       utcOffSet =  uOffSet;
      // cout << "this is _rep->utcOffSet " << utcOffSet << endl;
      // cout << "this was data " << (String)data << endl;
       set_data(uOffSet, 21, 4);   // change _rep->data to reflect
       //cout << "this is data now " << (String)data << endl;
   
       return true;
   
   
   }
  
     char data[FORMAT_LENGTH + 1];  
 };  
  
  
 CIMDateTime::CIMDateTime() CIMDateTime::CIMDateTime()
Line 101 
Line 224 
     _rep = new CIMDateTimeRep();     _rep = new CIMDateTimeRep();
     if (!_set(str))     if (!_set(str))
     {     {
           //cout << "in throw part of CIMDateTime(const String & str)" << endl;
         delete _rep;         delete _rep;
         throw InvalidDateTimeFormatException();         throw InvalidDateTimeFormatException();
     }     }
       //else _rep->copy;
 } }
  
 CIMDateTime::CIMDateTime(const CIMDateTime& x) CIMDateTime::CIMDateTime(const CIMDateTime& x)
 { {
     _rep = new CIMDateTimeRep();     _rep = new CIMDateTimeRep();
     memcpy(_rep->data, x._rep->data, sizeof(_rep->data));     // memcpy(_rep->data, x._rep->data, sizeof(_rep->data));
       _rep->copy(x._rep);
   }
   
   CIMDateTime::CIMDateTime(const Uint64 microSec, Boolean interval)
   {
       if (microSec >= PEGASUS_UINT64_LITERAL(315601056000000000) && !interval) { //time stamps must be less then number of micro Seconds in 10,000 years
           String mes = "trying to create a CIMDateTime object (time stamp) greater then the year 10,000";
           throw DateTimeOutOfRangeException(mes);
       }
       if (microSec >= PEGASUS_UINT64_LITERAL(8640000000000000000) && interval) { //intervals must be less then the number of microseconds in 100 million days
           String mes1 = "trying to create a CIMDateTime object (interval) greater then the year 100 million days";
            throw DateTimeOutOfRangeException(mes1);
       }
   
   
       //Set of Strings that hold part parts of datetime    100,000,000
       String year, ye_mo, ye_mo_da, ye_mo_da_ho, ye_mo_da_ho_mn, ye_mo_da_ho_mn_se, final;
   
       Uint64 day_sub1 = microSec/PEGASUS_UINT64_LITERAL(86400000000);
       Uint64 days_in400 = 146097;
   
       if (!interval) {
           Uint32 blocks_400 = day_sub1/days_in400;  //calculates the number of 400 year blocks in number
           Uint32 blocks_rem = day_sub1%days_in400;  //clauclates number of day after 400 year blocks are removed
           Uint32 days_rem = blocks_rem;
   
          //cout << "this is the number of 400 year blocks " << blocks_400 << endl;
          //cout << " this is the number of days after 400 blocks taken out " << days_rem << endl;
          // cout << "this is of days total " << day_sub1 << endl;
   
           /*While loop computes number of years form number of day
           taking into accoutn leap years
           */
           Uint32 i = 1;
           Uint32 count = 0;
           Uint32 leap_next = 0;
   
           while (days_rem >= 365) {
               if ((i%4 != 0) || (count%100 == 0)) {
                   days_rem = days_rem - 365;
                   count = count + 1;
                   i = i+1;
                   leap_next = leap_next + 1;
               }
               else{
                   days_rem = days_rem - 366;
                   count = count + 1;
                   i = i + 1;
                   leap_next = 0;
                  // cout << "leap year" << endl;
               }
           }
   
           Uint32 tot_year = (blocks_400 * 400) + count;
   
   
           //converting number of years from Uint32 -> String
           char buffer_year [10];
           sprintf(buffer_year, "%04d", tot_year);
           year = String(buffer_year);
   
        //  cout << " This is after the while loop in consrtutor total years is " << year << endl;
   
   
           /*Switch block is used to calculate the the number of months from the number of days
           left after years are subtracted.
           */
   
           Uint16 lp = 0;
   
           /*lp is 0 for non leap years and 1 for leap years
           */
           if ((leap_next == 3) && ((count != 99)||(count != 199)||(count != 299))) {
               lp = 1;
             //  cout << "months are being calculated for a leap year" << endl;
           }
   
           char bu_day [5];
           sprintf(bu_day, "%02d", days_rem);
          // cout << "this is the days left " << String(bu_day) << endl;
   
   
           if (days_rem < (365+lp) && (days_rem >= (334+lp))) {
               ye_mo = year.append(String("12"));
               days_rem = days_rem - (334+lp);
           }
           else if((days_rem < (334+lp)) && (days_rem >= (304+lp))){
               ye_mo = year.append(String("11"));
               days_rem = days_rem - (304+lp);
           }
           else if((days_rem < (304+lp)) && (days_rem >= (273+lp))){
               ye_mo = year.append(String("10"));
               days_rem = days_rem - (273+lp);
           }
           else if((days_rem < (273+lp)) && (days_rem >= (243+lp))){
               ye_mo = year.append(String("09"));
               days_rem = days_rem - (243+lp);
           }
           else if((days_rem < (243+lp)) && (days_rem >= (212+lp))){
               ye_mo = year.append(String("08"));
               days_rem = days_rem - (212+lp);
           }
           else if((days_rem < (212+lp)) && (days_rem >= (181+lp))){
               ye_mo = year.append(String("07"));
               days_rem = days_rem - (181+lp);
           }
           else if((days_rem < (181+lp)) && (days_rem >= (151+lp))){
               ye_mo = year.append(String("06"));
               days_rem = days_rem - (151+lp);
           }
           else if((days_rem < (151+lp)) && (days_rem >= (120+lp))){
               ye_mo = year.append(String("05"));
               days_rem = days_rem - (120+lp);
           }
           else if((days_rem < (120+lp)) && (days_rem >= (90+lp))){
               ye_mo = year.append(String("04"));
               days_rem = days_rem - (90+lp);
           }
           else if((days_rem < (90+lp)) && (days_rem >= (59+lp))){
               ye_mo = year.append(String("03"));
               days_rem = days_rem - (59+lp);
           }
           else if((days_rem < (59+lp)) && (days_rem >= 31)){
               ye_mo = year.append(String("02"));
               days_rem = days_rem - 31;
           }
           else if((days_rem < 31) && (days_rem >= 00)){
               ye_mo = year.append(String("01"));
         //      cout << "this is one month" << endl;
           }
           else{
               cout << "error in 'if else' bolck for months" << endl;
               cout << "days_rem = " << days_rem << endl;
               throw DateTimeOutOfRangeException("problem calculationg months");
           }
          // cout << "when months are add the string is  " << ye_mo << endl;
   
          char bu_mon [5];
          sprintf(bu_mon, "%02d", days_rem);
         // cout << "this is the days left after months is taken " << String(bu_mon) << endl;
   
                  //converting number of days from from Uint32 -> String
           char buffer_day [5];
           sprintf(buffer_day, "%02d", (days_rem+1));   // day of the month is never 0 (1-31)
           ye_mo_da = ye_mo.append(buffer_day);
   
       }  //end of if(!interval)
       else {
   
         // cout << "number is an interval" << endl;
   
           char buffer_day [20];
           sprintf(buffer_day, "%08d", day_sub1);
           ye_mo_da = String(buffer_day);
       }
   
     // cout << "when days are added the string is  " << ye_mo_da << endl;
   
       //get hours, minutes, seconds and microseconds
   
       Uint64 after_ymd = microSec%PEGASUS_UINT64_LITERAL(86400000000);
   
       Uint32 hour_num = after_ymd/PEGASUS_UINT64_LITERAL(3600000000);
       Uint32 after_ymdh = after_ymd%PEGASUS_UINT64_LITERAL(3600000000);
   
       Uint32 min_num = after_ymdh/60000000;
       Uint32 after_ymdhm = after_ymdh%60000000;
   
       Uint32 sec_num = after_ymdhm/1000000;
   
       Uint32 mic_num = after_ymdhm%1000000;
   
   
   
       //converting hours, minutes, seconds and microseconds from Uint32 -> String
   
       char buffer_hour [10];
       sprintf(buffer_hour, "%02d", hour_num);
       ye_mo_da_ho = ye_mo_da.append(buffer_hour);
           //cout << "when hours are added the string is  " << ye_mo_da_ho << endl;
   
       char buffer_min [10];
       sprintf(buffer_min, "%02d", min_num);
       ye_mo_da_ho_mn = ye_mo_da_ho.append(buffer_min);
         //  cout << "when minutes are added the string is  " << ye_mo_da_ho_mn << endl;
   
   
       char buffer_sec [10];
       sprintf(buffer_sec, "%02d", sec_num);
       ye_mo_da_ho_mn_se = ye_mo_da_ho_mn.append(buffer_sec);
      //cout << "when seconds are adder string is  " << ye_mo_da_ho_mn_se << endl;
   
       char buffer_mic [15];
       if (interval) {     //adding correct UCT off set depending on wether object should be an interval or not
           sprintf(buffer_mic, ".%06d:000", mic_num);
       }
       else{
           sprintf(buffer_mic, ".%06d+000", mic_num);
       }
       final = ye_mo_da_ho_mn_se.append(buffer_mic);
       //cout << "when at the end of constructor that takes Uint64 created string is  " << final  << endl << endl;
   
       _rep = new CIMDateTimeRep();
       if (!_set(final)) {
           delete _rep;
           throw InvalidDateTimeFormatException();
       }
   
 } }
  
 CIMDateTime& CIMDateTime::operator=(const CIMDateTime& x) CIMDateTime& CIMDateTime::operator=(const CIMDateTime& x)
 { {
     if (&x != this)      //cout << "in copy constructor" << cout;
         memcpy(_rep->data, x._rep->data, sizeof(_rep->data));      if (&x != this){
           _rep->copy(x._rep);
       }
   
           //memcpy(_rep->data, x._rep->data, sizeof(_rep->data));
  
     return *this;     return *this;
 } }
Line 132 
Line 469 
  
 void CIMDateTime::clear() void CIMDateTime::clear()
 { {
      //cout << "this is the start of the clear method" << endl;
     strcpy(_rep->data, _NULL_INTERVAL_TYPE_STRING);     strcpy(_rep->data, _NULL_INTERVAL_TYPE_STRING);
       String blank = "";
       String str = String("000000");
       Uint16 dum = _rep->set_microSec(str);
       _rep->set_seconds("00");
       _rep->set_minutes("00");
       _rep->set_hours("00");
       _rep->set_days("00");
       _rep->set_utcOffSet(String(":000"));
      //cout << "end of the clear method" << endl << endl;
   
 } }
  
 Boolean CIMDateTime::_set(const String & dateTimeStr) Boolean CIMDateTime::_set(const String & dateTimeStr)
 { {
     clear();     clear();
      // cout << "at the begining of _set" <<endl;
  
     CString dtStr = dateTimeStr.getCString();     CString dtStr = dateTimeStr.getCString();
     const char* str = dtStr;     const char* str = dtStr;
  
       //cout << "befor first if this is size " << dateTimeStr.size() << endl;
   
     // Be sure the incoming string is the proper length:     // Be sure the incoming string is the proper length:
  
     if (strlen(str) != CIMDateTimeRep::FORMAT_LENGTH)      if (dateTimeStr.size() != CIMDateTimeRep::FORMAT_LENGTH)
         return false;         return false;
  
      //cout << "after first if" << endl;
   
     // Determine the type (date or interval); examine the 21st character;     // Determine the type (date or interval); examine the 21st character;
     // it must be one of ':' (interval), '+' (date), or '-' (date).     // it must be one of ':' (interval), '+' (date), or '-' (date).
  
     const Uint32 SIGN_OFFSET = 21;     const Uint32 SIGN_OFFSET = 21;
     const Uint32 DOT_OFFSET = 14;     const Uint32 DOT_OFFSET = 14;
  
     Boolean isInterval = strcmp(&str[SIGN_OFFSET], ":000") == 0;      const String offS =  dateTimeStr.subString(SIGN_OFFSET,4);
  
     if (!isInterval && str[SIGN_OFFSET] != '+' && str[SIGN_OFFSET] != '-')      Boolean isInterval = String::compare(offS, ":000") == 0;
   
       if (!isInterval && dateTimeStr[SIGN_OFFSET] != '+' && dateTimeStr[SIGN_OFFSET] != '-')
         return false;         return false;
  
      // cout << "after not interval sign check" << endl;
   
     // Check for the decimal place:     // Check for the decimal place:
  
     if (str[DOT_OFFSET] != '.')      if (dateTimeStr[DOT_OFFSET] != '.')
         return false;         return false;
  
     // Check to see if other characters are digits:      //cout << "after decimal point check" << endl;
  
     for (Uint32 i = 0; i < CIMDateTimeRep::FORMAT_LENGTH; i++)       // Check to see if other characters are digits or astrisks (*)
     {  
         if (i != DOT_OFFSET && i != SIGN_OFFSET && !isdigit(str[i]))      for (Uint32 i = 0; i < CIMDateTimeRep::FORMAT_LENGTH; i++){
               if (i != DOT_OFFSET && i != SIGN_OFFSET && !isdigit(dateTimeStr[i]) && (String::compare(dateTimeStr.subString(i,1),"*") != 0)){
               cout << " this is the chariter it failed on " <<  dateTimeStr[i] << endl;
               cout << " this is the string " << dateTimeStr << endl;
               cout << " i = " << i << endl;
             return false;             return false;
     }     }
       }
   
  
     // Check to see if the month and day are in range (date only):     // Check to see if the month and day are in range (date only):
  
     char buffer[16];      String buffer;
       Uint64 ans;
   
  
       //cout << "right before isInterval check" << endl;
     if (!isInterval)     if (!isInterval)
     {     {
         //get year
         /* need to check that the field is valid as far as astrisk (*) are concerned */
         buffer = dateTimeStr.subString(0,4);
         ans = fieldcheck(buffer, _rep->year);
         //cout << "year " << _rep->year << endl;
         if (ans == 1){
          //   cout << "error (1) was returned from getting year" << endl;
             return false;
         }
         else if (ans == 0) {
             if (!restOfFields(4,dateTimeStr)){
           //      cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
         }
   
         // Get the month:         // Get the month:
       // cout << "after getting year" << endl;
  
         sprintf(buffer, "%2.2s", str + 4);          //sprintf(buffer, "%2.2s", str + 4);
         long month = atoi(buffer);          buffer = dateTimeStr.subString(4,2);
           ans = fieldcheck(buffer, _rep->month);
           if (ans == 1) {
              // cout << "one was returned form fieldcheck" << endl << endl;
               return false;           // month field has both wildcards and digits
           }
   
           else if (ans == 2) {          // month field has only digits
               long month = atoi(buffer.getCString());
  
   // Allow for zero month - default value processing   // Allow for zero month - default value processing
         if (month == 0 || month > 12)         if (month == 0 || month > 12)
             return false;             return false;
           }
           else if (ans == 0) {
             if (!restOfFields(6,dateTimeStr)){
               //  cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
           }
  
   
           //cout << "after getting month in _set" << endl;
         // Get the day:         // Get the day:
  
         sprintf(buffer, "%2.2s", str + 6);              //sprintf(buffer, "%2.2s", str + 6);
         long day = atoi(buffer);          buffer = dateTimeStr.subString(6,2);
           ans = fieldcheck(buffer, _rep->days);
           if (ans == 1) {
              // cout << "one was returned form fieldcheck" << endl << endl;
               return false;           // month field has both wildcards and digits
           }
   
           else if (ans == 2) {          // month field has only digits
   
                   long day = atoi(buffer.getCString());
  
   // Allow for zero day - default value processing   // Allow for zero day - default value processing
         if (day == 0 || day > 31)         if (day == 0 || day > 31)
             return false;             return false;
     }     }
           else if (ans == 0) {
             if (!restOfFields(6,dateTimeStr)){
             //    cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
           }
   
         // cout << "after getting days" << endl;
   
   
           //get UTC off set   for a Time Stamp
           buffer = dateTimeStr.subString(21,4);
           _rep->utcOffSet = buffer;
           Uint32 spot = buffer.find("*");
           //cout << "before if" << endl;
           if(spot == PEG_NOT_FOUND){  // the UTC must not have astricks in it
           // cout << "no spat found in UTC offset - this is  _rep->utcOffSet" << _rep->utcOffSet << endl;
           }
           else{
              //cout << "wrong UTC Off set - this value " << _rep->utcOffSet << endl;
               return false;
           }
   
       }
       else{     //Object is an Interval
   
           //get days if object is an interval
           buffer = dateTimeStr.subString(0,8);
           ans = fieldcheck(buffer, _rep->days);
           if (ans == 1) {
              // cout << "Interval days was set wrong" << endl;
               return false;
           }
           else if (ans == 0) {
             if (!restOfFields(8,dateTimeStr)){
                // cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
           }
   
   
           // check to make sure UTC for Intervals it '000'
           buffer = dateTimeStr.subString(21,4);
           _rep->utcOffSet = buffer;
           if ( !String::compare(_rep->utcOffSet, ":OOO")) {
              // cout << "interval UTC offset is worng" << endl;
               return false;
           }
   
   
       }
   
       //cout << "after is interval block" << endl;
  
     // Check the hours and minutes:     // Check the hours and minutes:
       buffer = dateTimeStr.subString(8,2);
       ans = fieldcheck(buffer, _rep->hours);
       if (ans == 1) {
           //cout << "one was returned form fieldcheck" << endl << endl;
           return false;           // hour field has both wildcards and digits
        }
  
     sprintf(buffer, "%2.2s", str + 8);      else if (ans == 2) {          // hour field has only digits
     long hours = atoi(buffer);          //sprintf(buffer, "%2.2s", str + 8);
           long hours = atoi(buffer.getCString());
  
     if (hours > 23)     if (hours > 23)
         return false;         return false;
       }
       else if (ans == 0) {
             if (!restOfFields(10,dateTimeStr)){
                 cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
        }
   
   
      //cout << "this is after getting hours" << endl;
  
     sprintf(buffer, "%2.2s", str + 10);      buffer = dateTimeStr.subString(10,2);
     long minutes = atoi(buffer);      ans = fieldcheck(buffer, _rep->minutes);
       //cout << " this is in _set, minutes = " << _rep->minutes << endl;
       if (ans == 1) {
       //cout << "one was returned form fieldcheck" << endl << endl;
           return false;           // minutes field has both wildcards and digits
       }
   
       else if (ans == 2) {          // minutes field has only digits
       //sprintf(buffer, "%2.2s", str + 10);
           long minutes = atoi(buffer.getCString());
  
     if (minutes > 59)     if (minutes > 59)
         return false;         return false;
       }else if (ans == 0) {
             if (!restOfFields(12,dateTimeStr)){
                 cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
         }
   
  
     sprintf(buffer, "%2.2s", str + 12);  
     long seconds = atoi(buffer);  
       buffer = dateTimeStr.subString(12,2);
       ans = fieldcheck(buffer, _rep->seconds);
       if (ans == 1) {
           //cout << "one was returned form fieldcheck" << endl << endl;
           return false;           // seconds field has both wildcards and digits
       }
   
       else if (ans == 2) {          // minutes field has only digits
       //sprintf(buffer, "%2.2s", str + 12);
           long seconds = atoi(buffer.getCString());
  
     if (seconds > 59)     if (seconds > 59)
         return false;         return false;
       }
       else if (ans == 0) {
             if (!restOfFields(14,dateTimeStr)){
                 cout << "restOfFeilds said that that object has the wrong formatt" << endl;
                 return false;
             }
         }
   
   
       //get micro Seconds
       String buffer_micro = dateTimeStr.subString(15,6);
       //ans = microSecheck(buffer);
       ans = _rep->set_microSec(buffer_micro);
       if (ans == 1) {
           return false;
       }
   
   
  
     memcpy(_rep->data, str, sizeof(_rep->data));     memcpy(_rep->data, str, sizeof(_rep->data));
           //   cout << "this is the end of _set " << endl;
       return true;
   
   }
  
   Uint64 CIMDateTime::microSecheck(String & in_p)
   {
       Uint32 ast_post;
       _rep->microSec = in_p;
   
       ast_post = in_p.find("*");
       //cout <<"this is the try block inside fieldcheck" << endl;
       if (ast_post == PEG_NOT_FOUND) {
       //cout << "check to see if it equals PEG_NOT_FOUND in microSecheck" << endl;
           return 2;
       }
       Uint32 sub_len = 6 - ast_post;
       String ast = "******";
       String in_comp = in_p.subString(ast_post, sub_len);
       if (!String::compare(in_comp, ast, sub_len)){
           return 0;
       }
       else{
           cout << "error in microSe - this is the value " << in_p << endl;
           return 1;
       }
   
   }
   
   
   Boolean CIMDateTime::restOfFields(Uint32 start_position,const String inStr)
   {
      // cout << "begining of rest of fields" << endl;
       String splatCDT = "**************.******";
       Uint32 placeNum = splatCDT.size() - start_position;
   
       String comp = splatCDT.subString(start_position, placeNum);
       String in_comp = inStr.subString(start_position, placeNum);
       if (String::compare(comp, in_comp))
           return false;
       else
     return true;     return true;
 } }
  
Line 227 
Line 790 
         throw InvalidDateTimeFormatException();         throw InvalidDateTimeFormatException();
 } }
  
   Uint64 CIMDateTime::toMicroSeconds()
   {
   
   
       CIMDateTime un_norm;
       un_norm._rep = new CIMDateTimeRep();
       //CIMDateTimeRep& ref_rep = _rep;
       un_norm._rep->copy(_rep);
       CIMDateTime norm = un_norm.normalizer();
       //cout << "after normalizer call this is norm " << norm.toString() << endl;
   
       const Uint64 norm_micSec = norm._toMicroSeconds();
       // cout << "this is what the object holds year - " << norm._rep->year << " months - " << norm._rep->month << " - days  " << norm._rep->days << endl << "hour - " << norm._rep->hours << endl;
   
   
       //cout << "after _toMicroSeconds call in toMicroSecond" << endl;
       return (norm_micSec);
   }
   
   Uint64 CIMDateTime::_toMicroSeconds()
   {
       Uint64 mic = 0;
       Uint64 sec = 0;
       Uint64 min = 0;
       Uint64 hor = 0;
       Uint64 day = 0;
       Uint64 mon = 0;
       Uint64 yea = 0;
       Uint64 date = 0;
   
       Uint32 mic_sp= _rep->microSec.find('*');
       if (mic_sp == PEG_NOT_FOUND) {
           mic = atol(_rep->microSec.getCString());
       }
       else if (mic_sp > 0) {
           String subMic = _rep->microSec.subString(0, mic_sp);
           mic = atol(subMic.getCString()) * pow((double)10,(double)(6-mic_sp));
           //cout << " the multiplier is " << pow(10,(6-mic_sp)) << endl;
           //cout << "mic_sp = " << mic_sp << " and mic = " << mic << endl;
       }
       else{
           mic = 0;
       }
   
       //cout << "millis sec = " << (Uint32)mic << endl;
   
       if (_rep->seconds.find('*') == PEG_NOT_FOUND) {
           sec = atol(_rep->seconds.getCString()) * 1000000;
           //cout << "sec = " << (Uint32)(sec/1000000) << endl;
          //cout << " this is what getCString gives " << atol(_rep->seconds.getCString()) << endl;
   
       }
   
       if (_rep->minutes.find('*') == PEG_NOT_FOUND) {
          // cout << "this is min before is gets set - " << (Uint32)(min/1000000) << endl;
           min = atol(_rep->minutes.getCString()) * PEGASUS_UINT64_LITERAL(60000000);
          // cout << "min = " << (Uint32)(min/1000000) << endl;
         // cout << " this is what getCString gives " << atol(_rep->minutes.getCString()) << endl;
       }
   
       if (_rep->hours.find('*') == PEG_NOT_FOUND) {
           hor = (atol(_rep->hours.getCString())) * PEGASUS_UINT64_LITERAL(3600000000);
           //cout << "hour = " << (Uint32)(hor/1000000) << endl;
         // cout << " this is what getCString gives " << atol(_rep->hours.getCString()) << endl;
   
       }
   
   
    // cout << "after setting values in toMicroSeconds() " << endl;
    //cout << "this is what the object holds year - " << _rep->year << " months - " << _rep->month << " - days  " << _rep->days << endl << "hour - " << _rep->hours << endl;
    //cout << "minute - " << _rep->minutes << endl;
   
   
       if (!isInterval()) {
   
           /* change years into micro Seconds. Taking leap years into accout there are 146,097
            days every 400 years. Remainder years outside of 400 year blocks will be handled by
            a while loop
            */
           Uint64 yea_num = 0;
   
           if (_rep->year.find('*') == PEG_NOT_FOUND) {
               yea_num = atol(_rep->year.getCString());
           }
   
   
           Uint64 yea_400 = yea_num/400;
           Uint64 day_400  = yea_400 * 146097;
   
           Uint64 count_le = 0;
           Uint64 count_r = 0;
           Uint64 yea_rem = yea_num%400;
           Uint32 leap_next = 0;
           Uint32 count = 0;
           Uint16 lp = 0;
   
           //cout << "right before for loop for the leap year stuff" << endl;
   
           for (int i=1; i<=yea_rem; i++) {
               if ((i%4 != 0) || (count%100 == 0)) {
                   count_r = count_r + 1;
                   count = count + 1;
                   leap_next = leap_next + 1;
               }
               else {
                   count_le = count_le + 1;
                   count = count + 1;
                   leap_next = 0;
               }
           }
   
           /*lp is 0 for non leap years and 1 for leap years
           */
           if ((leap_next == 3) && ((count != 99)||(count != 199)||(count != 299))) {
               lp = 1;
             //  cout << "months are being calculated for a leap year" << endl;
           }
           if (_rep->month.find('*') == PEG_NOT_FOUND) {
   
               //get number of days eqivalent to number of months in the object and multipy by number of
               //micro seconds in a day
               switch (atol(_rep->month.getCString())) { //months can't be equal to zero
               case 1:
                   mon = 00;
                   break;
               case 2:
                   mon = 31 * PEGASUS_UINT64_LITERAL(86400000000);
                   break;
               case 3:
                   mon = ((59+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 4:
                   mon = ((90+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 5:
                   mon = ((120+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 6:
                   mon = ((151+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 7:
                   mon = ((181+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 8:
                   mon = ((212+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 9:
                   mon = ((243+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 10:
                   mon = ((273+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 11:
                   mon = ((304+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               case 12:
                   mon = ((334+lp) * PEGASUS_UINT64_LITERAL(86400000000));
                   break;
               default:
                   cout << "error calculating months" << endl;
                   cout << "this is data " << (String)_rep->data << endl;
                   throw InvalidDateTimeFormatException();
               }
           }
   
          // cout << "after switch statment in toMicroSeconds" << endl;
   
   
      /* char buf5 [10];
        sprintf(buf5, "%04d", count);
   
        char buf7 [10];
        sprintf(buf7, "%04d", count_le);
   
        char buf8 [10];
        sprintf(buf8, "%04d", count_r);
   
       cout << "this is the counts - count-" << buf5 << " count_le-" << buf7  << " count_r-" << buf8 << endl;
         */
   
   
           Uint64 day_rem = (count_le * 366) + (count_r * 365);
   
           yea = (day_rem + day_400) * PEGASUS_UINT64_LITERAL(86400000000);
   
           if (_rep->days.find('*') == PEG_NOT_FOUND) {
               day = ((atol(_rep->days.getCString()))-1) * PEGASUS_UINT64_LITERAL(86400000000);   //time stamp "days" go from 1-31 ther is no zero
                   //  cout << "this is day " << ((atol(_rep->days.getCString()))-1) << endl;
           }
       }
       else{
           if (_rep->days.find('*') == PEG_NOT_FOUND) {
               day = (atol(_rep->days.getCString())) * PEGASUS_UINT64_LITERAL(86400000000);
           }
       }
   
   
      /* Uint32 y = yea/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 y_r = yea%PEGASUS_UINT64_LITERAL(1000000000);
   
       Uint32 m = mon/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 m_r = mon%PEGASUS_UINT64_LITERAL(1000000000);
   
       Uint32 d = day/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 d_r = day%PEGASUS_UINT64_LITERAL(1000000000);
   
       Uint32 h = hor/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 h_r = hor%PEGASUS_UINT64_LITERAL(1000000000);
   
       Uint32 mi = min/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 mi_r = min%PEGASUS_UINT64_LITERAL(1000000000);
   
       Uint32 s = sec/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 s_r = sec%PEGASUS_UINT64_LITERAL(1000000000);    */
   
   
   
       date = mic+sec+min+hor+day+mon+yea;
   
       /*if (date > PEGASUS_UINT64_LITERAL(315601056000000000)) {
           cout << "year " << y << " remainder " << y_r << endl;
           cout << "mon " << m << " remain " << m_r << endl;
           cout << "day " << d << " remai  " << d_r << endl;
           cout << "hour " << h << " remain " << h_r << endl;
           cout << "min " << mi << " reain " << mi_r << endl;
           cout << "sec " << s << " remain " << s_r << endl;
           cout << "date  " << (Uint32)(date/PEGASUS_UINT64_LITERAL(1000000000)) << endl;
   
           cout << this->toString() << endl;
       }     */
   
       return date;
   }
   
 Boolean operator==(const CIMDateTime& x, const CIMDateTime& y) Boolean operator==(const CIMDateTime& x, const CIMDateTime& y)
 { {
     return x.equal (y);     return x.equal (y);
 } }
  
   CIMDateTime CIMDateTime::normalizer()
   {
       if (isInterval()) {
           String copy_Str = String((this->_rep)->data);
           CIMDateTime current = CIMDateTime(copy_Str);
           //cout << "this is what comes from the normalizer if it's an interval " << current.toString() << endl;
           return(current);    //no nomalization should not be done on Intervals
       }
       Uint64 normNum = 0;
   
       //cout << "before toMicroSecond call in normakizer " << endl;
       Uint64 un_normNum = this->_toMicroSeconds();
       Uint32 unnor = un_normNum/PEGASUS_UINT64_LITERAL(1000000000);
       Uint32 runnor = un_normNum%PEGASUS_UINT64_LITERAL(1000000000);
      // cout << "this is what comes back from _toMicroSeconds in normalizer div by a billion "<< unnor << endl;
       //cout << "this is reainder " << runnor << endl;
   
       // get UTC offSet and change it in microseconds
       String utcOS = _rep->utcOffSet.subString(1,3);
       Uint32 offSet = atol((utcOS).getCString());
       Uint64 offSet_hor = (offSet/60) * PEGASUS_UINT64_LITERAL(3600000000);
       Uint64 offSet_min = (offSet%60) * 60000000;
       String mesO = "overflow has occured in nomalization";
   
   
       //cout << "UTC offset equals " << offSet << endl;
   
       char                sign;   // Get the sign and UTC offset.
       sign = _rep->data[21];
   
       //if there are no wild cards in the minute postion then the entire utc offSet
       //will effect the CIMDateTime value
   
       if (_rep->minutes.find('*') == PEG_NOT_FOUND) {
           if ( sign == '-' ) {
               if (PEGASUS_UINT64_LITERAL(315601056000000000) < (un_normNum + (offSet_hor + offSet_min)))
                   throw DateTimeOutOfRangeException(mesO);
               normNum = un_normNum + (offSet_hor + offSet_min);
           }
           else{
               if (un_normNum < (offSet_hor + offSet_min)) {
                   String mes3 = "underflow has occured in nomalization";
                   throw DateTimeOutOfRangeException(mes3);
               }
                normNum = un_normNum - (offSet_hor + offSet_min);
           }
       }
       //if the hours section has no wild cards but the minutes section does then only on hour
       //position will be effected by the uct off Set
       else if (_rep->hours.find('*') == PEG_NOT_FOUND) {
          // cout << "in only update hour block and sign is " << sign << endl;
           if ( sign == '-' ) {
               if (PEGASUS_UINT64_LITERAL(315601056000000000) < (un_normNum + (offSet_hor)))
                   throw DateTimeOutOfRangeException(mesO);
   
                normNum = un_normNum + (offSet_hor);
           }
           else{
               if (un_normNum < (offSet_hor)) {
                   String mes3 = "underflow has occured in nomalization";
                   throw DateTimeOutOfRangeException(mes3);
               }
                normNum = un_normNum - (offSet_hor);
               // cout << "in only hour offset" << endl;
           }
       }
       else{ //if this block is executed then the utc offSet has no effect on CIMDateTime value
           normNum = un_normNum;
       }
      Uint32 prnor = normNum/1000000;
      //cout << "this is the sum of the number and the offset " << prnor << endl;
   
     /* if (PEGASUS_UINT64_LITERAL(315601056000000000) < normNum) {
          cout << "here is the problem " << endl;
          cout << "CDT " << this->toString() << endl;
      }  */
   
       //cout << "the sign is " << sign << endl;
   
       CIMDateTime norm_CDT = CIMDateTime(normNum,false);
       //cout << "after constructor call in normalizer" << endl;
   
       return(norm_CDT);
   }
   
 void formatDateTime(char* dateTimeStr, tm* tm) void formatDateTime(char* dateTimeStr, tm* tm)
 { {
     Uint32 index = 0, index1 = 0;     Uint32 index = 0, index1 = 0;
Line 249 
Line 1131 
     tm->tm_wday  = 0;     tm->tm_wday  = 0;
     tm->tm_yday  = 0;     tm->tm_yday  = 0;
  
     // Extract the year.      // Extract the year.
     sprintf(buffer, "%4.4s", dateTimeStr);      sprintf(buffer, "%4.4s", dateTimeStr);
     year   = atoi(buffer);      year   = atoi(buffer);
     year = year - 1900;      year = year - 1900;
     tm->tm_year   = year;      tm->tm_year   = year;
   
       // Extract the Month.
       sprintf(buffer, "%2.2s", dateTimeStr + 4);
       tm->tm_mon   = atoi(buffer);
   
       // Extract the Day.
       sprintf(buffer, "%2.2s", dateTimeStr + 6);
       tm->tm_mday   = atoi(buffer);
   
       // Extract the Hour.
       sprintf(buffer, "%2.2s", dateTimeStr + 8);
       tm->tm_hour   = atoi(buffer);
   
       // Extract the Minutes.
       sprintf(buffer, "%2.2s", dateTimeStr + 10);
       tm->tm_min   = atoi(buffer);
   
       // Extract the Seconds.
       sprintf(buffer, "%2.2s", dateTimeStr + 12);
       tm->tm_sec   = atoi(buffer);
   }
   
   Boolean CIMDateTime::isInterval() const
   {
       const Uint32        SIGN_OFFSET = 21;
   
       Boolean isInterval = strcmp(&_rep->data[SIGN_OFFSET], ":000") == 0 ;
   
       return isInterval;
   }
   
   Boolean CIMDateTime::equal (const CIMDateTime & x) const
   {
       if ((x.isInterval() && !this->isInterval()) || (!x.isInterval() && this->isInterval())) {
           throw TypeMismatchException();
       }
   
       CIMDateTime current = CIMDateTime((String)_rep->data);
       CIMDateTime compare = CIMDateTime((String)x._rep->data);  // not sure why all this is needed but const has somthing to do with it
   
       Uint32 spl_pos = current.getHighestWildCardPosition(compare);
   
       CIMDateTime cur = current.insert_WildCard(spl_pos);
       CIMDateTime comp = compare.insert_WildCard(spl_pos);
   
   
      // Uint32 spot_cur = current.toString().find('*');
       //Uint32 spot_comp = compare.toString().find('*');
       /*char bcur [3];
       char bcom [3];
       sprintf(bcur,"%02d",spot_cur);
       cout << "spot_cur is " << bcur << endl;
       sprintf(bcom,"%02d",spot_comp);
       cout << "spot_comp is " << bcom << endl;*/
   
       /*    take this section out when sub rutiens are intergrated
   
       if (spot_cur == PEG_NOT_FOUND && spot_comp == PEG_NOT_FOUND) {   //start time have more wild cards then finish time
           cur = current;
           comp = compare;
         //  cout << "not splats" << endl;
       }
       else if (spot_cur == PEG_NOT_FOUND) {
           cur = current.insert_WildCard(spot_comp);
           comp = compare;
          // cout << "splats only in comp" << endl;
         //  cout << "cur " << cur.toString() << endl;
         //  cout << "comp " << comp.toString() << endl;
       }
       else if (spot_comp == PEG_NOT_FOUND) {
           comp = compare.insert_WildCard(spot_cur);
           cur = current;
         //   cout << "splats only in cur" << endl;
       }
       else{
           if (spot_comp < spot_cur) {
               cur = current.insert_WildCard(spot_comp);
               comp = compare;
              /*  cout << "comp has more splats" << endl;
                cout << "cur " << cur.toString() << endl;
           cout << "comp " << comp.toString() << endl;
   
           }
           else{
               comp = compare.insert_WildCard(spot_cur);
               cur = current;
         /*     cout << "cut has more splats" << endl;
               cout << "cur " << cur.toString() << endl;
           cout << "comp " << comp.toString() << endl;
           }
       } */
   
   
       if (cur.toMicroSeconds() == comp.toMicroSeconds()) {
           return true;
       }
       else
           return false;
   
   }
   
   Sint64 CIMDateTime::getDifference(const CIMDateTime & startTime, const CIMDateTime & finishTime)
   {
       CIMDateTime sta = startTime;
       CIMDateTime fin = finishTime;
       CIMDateTime startT;
       CIMDateTime finishT;
       CIMDateTime sta_norm;
       CIMDateTime fin_norm;
       Uint64 startT_num;
       Uint64 finishT_num;
       Sint64 diff_num;
   
   
       Uint32 splat_pos = sta.getHighestWildCardPosition(fin);
       startT = sta.insert_WildCard(splat_pos);
       finishT = fin.insert_WildCard(splat_pos);
   
   
      /*
   
       Uint32 spot_s = startTime.toString().find('*');
       Uint32 spot_f = finishTime.toString().find('*');
   
   
       if (spot_s == PEG_NOT_FOUND && spot_f == PEG_NOT_FOUND) {   //start time have more wild cards then finish time
           startT = sta;
           finishT = fin;
          // cout << "not splats" << endl;
       }
       else if (spot_f == PEG_NOT_FOUND) {
           finishT = fin.insert_WildCard(spot_s);
           startT = sta;
          // cout << "splats only in finish" << endl;
       }
       else if (spot_s == PEG_NOT_FOUND) {
           startT = sta.insert_WildCard(spot_f);
           finishT = fin;
            //cout << "splats only in cur" << endl;
       }
       else{
           if (spot_f < spot_s) {
               startT = sta.insert_WildCard(spot_f);
               finishT = fin;
               // cout << "comp has more splats" << endl;
           }
           else{
               finishT = fin.insert_WildCard(spot_s);
               startT = sta;
               //cout << "cut has more splats" << endl;
           }
       }     */
   
     /* this block doesn't seem to be needed
       // normalize objects if they are timestamps
       if (!startT.isInterval()) {
           sta_norm = startT.normalizer();
       }
       if (!finishT.isInterval()) {
           fin_norm = finishT.normalizer();
       }
          */
   
  
     // Extract the Month.     // cout << "this is startT._rep->month " << startT._rep->month << " this is startTime._rep->month " << startTime._rep->month << endl;
     sprintf(buffer, "%2.2s", dateTimeStr + 4);  
     tm->tm_mon   = atoi(buffer);  
  
     // Extract the Day.  
     sprintf(buffer, "%2.2s", dateTimeStr + 6);  
     tm->tm_mday   = atoi(buffer);  
  
     // Extract the Hour.      //cout << "this is statrt norm " << startT_norm.toString() << endl;
     sprintf(buffer, "%2.2s", dateTimeStr + 8);      //cout << "this is finish norm " << finishT_norm.toString() << endl;
     tm->tm_hour   = atoi(buffer);  
  
     // Extract the Minutes.  
     sprintf(buffer, "%2.2s", dateTimeStr + 10);  
     tm->tm_min   = atoi(buffer);  
  
     // Extract the Seconds.      startT_num = startT.toMicroSeconds();
     sprintf(buffer, "%2.2s", dateTimeStr + 12);      //cout << "after first toMicroSec call" << endl;
     tm->tm_sec   = atoi(buffer);      finishT_num = finishT.toMicroSeconds();
 }  
  
 Boolean CIMDateTime::isInterval()      //cout << "this is start in MicroSec divided by a million " << (Uint32)startT_num/1000000 << endl;
 {      //cout << "this is finnish in MicroSec divided by a million " << (Uint32)finishT_num/1000000 << endl;
     const Uint32        SIGN_OFFSET = 21;  
  
     Boolean isInterval = strcmp(&_rep->data[SIGN_OFFSET], ":000") == 0 ;  
  
     return isInterval;  
 }  
  
 Boolean CIMDateTime::equal (const CIMDateTime & x) const      /* the throwing of this expceptoin is only needed becasue this is the way getDifferance worked
 {      before. The operator- does not behave this way.
     return memcmp (this->_rep->data, x._rep->data, sizeof (this->_rep->data))      */
         == 0;      if ((startT.isInterval() && ! finishT.isInterval()) || (! startT.isInterval() &&  finishT.isInterval())) {
           throw InvalidDateTimeFormatException();
 } }
  
 Sint64 CIMDateTime::getDifference(CIMDateTime startTime, CIMDateTime finishTime)      diff_num = finishT_num - startT_num;
 {  
     const char*         startDateTimeCString;      return diff_num;
   
   
   
      /* const char*         startDateTimeCString;
     const char*         finishDateTimeCString;     const char*         finishDateTimeCString;
     char                dateTimeOnly[CIMDateTimeRep::FORMATTED_DATE_TIME];     char                dateTimeOnly[CIMDateTimeRep::FORMATTED_DATE_TIME];
     struct tm           tmvalStart;     struct tm           tmvalStart;
Line 519 
Line 1555 
         differenceInMicroseconds -=         differenceInMicroseconds -=
             (startDateMicroseconds - finishDateMicroseconds);             (startDateMicroseconds - finishDateMicroseconds);
  
     return differenceInMicroseconds;      return differenceInMicroseconds;  */
       Uint64 dif;
       return dif;
   }
   
   Uint64 CIMDateTime::fieldcheck(String & in_p,String & rep_field)
   {
       Uint32 post;
       rep_field = in_p;
   
       post = in_p.find("*");
       //cout <<"this is the try block inside fieldcheck" << endl;
       if (post == PEG_NOT_FOUND) {
       //cout << "check to see if it equals PEG_NOT_FOUND" << endl;
           return 2;
       }
   
       const String ast = "**********";
       String comp = String(ast, in_p.size());   //creates a string of asteriks with the same length as in_p
       if (!String::compare(in_p, comp)) {
          // cout << "this should be good" << endl;
           return 0;                            //fields is all astriks
       }
       else{
           //cout << "this will cause an error" << endl;
          // cout << "this is in_p " << in_p << endl;
           return 1;                            //error - mix of asterisk and numbers  in field
       }
   
   }
   /*
   PEGASUS_UINT64_LITERAL(86400000000);
     PEGASUS_UINT64_LITERAL(3600 000 000);
           60 000 000; */
   
   
   CIMDateTime CIMDateTime::setUctOffSet(Sint32 utc)
   {
       // convert CIMDateTime to microseconds.
       Uint64 cdt_MicroSec = this->toMicroSeconds();
       Uint32 offSet = abs(utc);
       Uint64 offSet_hor = (offSet/60) * PEGASUS_UINT64_LITERAL(3600000000);
       Uint64 offSet_min = (offSet%60) * 60000000;
       Uint64 cdt_MicroSecSum = 0;
       String sgn_offset;
   
       //Uint32 diva = cdt_MicroSec/1000000;
       //cout << "this is cdt_MicroSec divided million " << diva << endl;
   
       //Add (if utc is - ) or subtract (if utc is +) utc to/from DateTime.
       if (utc >= 0) {
           if (cdt_MicroSec < (offSet_hor + offSet_min)) {
               String mes3 = "underflow has occured in nomalization";
               cout << " underflow error" << endl;
               throw DateTimeOutOfRangeException(mes3);
           }
           cdt_MicroSecSum = cdt_MicroSec + (offSet_hor + offSet_min);
           sgn_offset = "+";
         //  cout << "utc was posotive, it is  " << (offSet/60) << " and " << (offSet%60) <<  endl;
       }
       else{
           cdt_MicroSecSum = cdt_MicroSec - (offSet_hor + offSet_min);
           sgn_offset = "-";
          //  cout << "utc was negative it is  " << (offSet/60) << " and " << (offSet%60) << endl;
       }
       //cout << "after if in setUctOffSet" << endl;
   
        //Uint32 div = cdt_MicroSecSum/1000000;
   
        //cout << "this is cdt_MicroSecSum div by million " << div << endl;
   
       //Create new DateTime from sum of old DateTime and UTC and set UCT of new Date time.
       CIMDateTime ans = CIMDateTime(cdt_MicroSecSum, false);
   
     // cout << " after constructor call in setUctOffSet this is it " << ans.toString() << endl;
       char utcBuff [5];
       sprintf(utcBuff, "%03d", offSet);
       String utc_str = sgn_offset.append(String(utcBuff));
      //cout << "in setUctOffSet this is utc offset " << utc_str << endl;
       Boolean res = ans._rep->set_utcOffSet(utc_str);
   
      //cout << "right before retrun in setUctOffSet - this is ans.UTC " << ans._rep->utcOffSet << endl;
       if (res) {
           return ans;   //  set_utcOffSet worked
       }
       else
           throw InvalidDateTimeFormatException();
   
   
   }
   
   Uint32 CIMDateTime::getHighestWildCardPosition(CIMDateTime & cDT_s)
   {
       //char bu [3];
       //sprintf(bu,"%02d",index);
       //cout << "index is " << bu << endl;
   
   
       Uint32 spot_s = cDT_s.toString().find('*'); //since this return a Uint32 and PEG_NOT_FOUND=-1 can't do a
       Uint32 spot_f = this->toString().find('*');  // straight compare
   
   
       if (spot_s == PEG_NOT_FOUND && spot_f == PEG_NOT_FOUND) {   //start time have more wild cards then finish time
          // startT = sta;
          // finishT = fin;
          //cout << "no splats" << endl;
          return PEG_NOT_FOUND;
       }
       else if (spot_f == PEG_NOT_FOUND) {
          // finishT = fin.insert_WildCard(spot_s);
          // startT = sta;
          //  cout << "splats only in second CDT" << endl;
            return spot_s;
       }
       else if (spot_s == PEG_NOT_FOUND) {
           //startT = sta.insert_WildCard(spot_f);
           //finishT = fin;
           // cout << "splats only in first CDT" << endl;
            return spot_f;
       }
       else{
           if (spot_f < spot_s) {
               //startT = sta.insert_WildCard(spot_f);
               //finishT = fin;
               //cout << "comp has more splats" << endl;
               return spot_f;
           }
           else{
               //finishT = fin.insert_WildCard(spot_s);
               //startT = sta;
               //cout << "cut has more splats" << endl;
               return spot_s;
           }
       }
   
    }
   
   
   CIMDateTime CIMDateTime::insert_WildCard(Uint32 ind)
   {
       Uint32 index = ind;
   
       if (ind > 20) {
          index = 21;
       }
   
       Uint32 spot = this->toString().find('*');
       if (spot == index) {
           CIMDateTime cur = CIMDateTime(this->toString());
           return cur;
       }
   
       String splat = String("**************.******");
       String cdtStr = this->toString();
       String final;
       if (index > 0) {
           String str_cdtStr = cdtStr.subString(0, index);
           String sub_splat = splat.subString(index, (21-index));
   
   
           //build result
           String cdt_Splat = str_cdtStr.append(sub_splat);
           //cout << "part of final string " << cdt_Splat << endl;
           final = cdt_Splat.append(this->_rep->utcOffSet);
   
          //cout << "this is the string sent to the built in insert_Wild " << final << endl;
      }
      else{
           final = splat.append(this->_rep->utcOffSet);
           //cout << "this is the string sent to the constructor,  built in insert_Wild " << final << endl;
   
      }
   
      CIMDateTime ans = CIMDateTime(final);
       //cout << "this is the CIMDateTime returned " << res.toString() << endl;
   
       return ans;
   
   }
   
   const CIMDateTime CIMDateTime::operator+(const CIMDateTime & cDT)
   {
       CIMDateTime opt_spl;
       CIMDateTime cur_spl;
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
       CIMDateTime mid_cdt;
       CIMDateTime fin_cdt;
       Sint32 utc;
       Boolean isInt = this->isInterval();
   
       // only interval+interval and timeStamp+interval are allowed. Therefor second operand must be interval
       if (!opt_cDT.isInterval()) {
           throw TypeMismatchException();
       }
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
       //opt_spl = opt_cDT.insert_WildCard(splat_pos);
       //cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
   
       //cout << " before microSecond calls" << endl;
       Uint64 opt_num = opt_cDT.toMicroSeconds();
       //cout << "after first micro sec call in operator+" << endl;
       Uint64 cur_num = cur_cDT.toMicroSeconds();
      // cout << "after seocnd micro sec call in operator+" << endl;
   
   
       Uint64 ans = opt_num + cur_num;
       CIMDateTime ans_cdt = CIMDateTime(ans, isInt);
   
       //cout << "after constructor call in operator+ " << endl;
   
       if (!isInt) {
           //cout << "this is the utc offSet of the answer << _rep->utcoffSet << endl;
           utc = atol((_rep->utcOffSet).getCString());
           mid_cdt = ans_cdt.setUctOffSet(utc);
       }
       else
           mid_cdt = ans_cdt;
   
       fin_cdt = mid_cdt.insert_WildCard(splat_pos);
   
   
   
       return fin_cdt;
   }
   
   
   void CIMDateTime::operator+=(const CIMDateTime & cDT)
   {
       CIMDateTime sum_interval;
       CIMDateTime sum2_cdt;
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
       CIMDateTime sum_cdt = cur_cDT + opt_cDT;
   
   
       /*//cout << " this is opt1 time 2 " << sum_cdt.toString() << endl;
       if (!sum_cdt.isInterval()) {
           sum_interval = CIMDateTime(sum_cdt.toMicroSeconds(), true);
           sum2_cdt = cur_cDT + sum_interval;
       }
       else
       sum2_cdt = cur_cDT + sum_cdt;
   
       //cout << "this is sum2_cdt " << sum2_cdt.toString() << endl;  */
   
       _rep->copy(sum_cdt._rep);
   
       //cout << " this is final value " << this->toString() << endl;
        return;
   }
   
   
   const CIMDateTime CIMDateTime::operator-(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
       CIMDateTime ans_cdt;
       CIMDateTime fin_cdt;
       Sint32 utc;
       Boolean cur_isIn = this->isInterval();
       Boolean opt_isIn = opt_cDT.isInterval();
   
       // only I-I, T-I and T-T are allowed
       if (cur_isIn && !opt_isIn) {
           throw TypeMismatchException();
 } }
  
       Uint64 opt_num = opt_cDT.toMicroSeconds();
       //cout << "after first micro sec call in operator+" << endl;
       Uint64 cur_num = cur_cDT.toMicroSeconds();
   
       if (cur_num < opt_num) {
           DateTimeOutOfRangeException("result of date time subtraction is negative");
       }
   
       Uint64 diff = cur_num - opt_num;
   
       if ((cur_isIn && opt_isIn) || (!cur_isIn && !opt_isIn)) { //don't konw how to do logical xor
           ans_cdt = CIMDateTime(diff, true);
       }
       else{
           ans_cdt = CIMDateTime(diff, false);
           utc = atol((_rep->utcOffSet).getCString());
           ans_cdt = ans_cdt.setUctOffSet(utc);
       }
   
       //cout << "after constructor call in operator+ " << endl;
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
       fin_cdt = ans_cdt.insert_WildCard(splat_pos);
   
        return fin_cdt;
   }
   
   
   void CIMDateTime::operator-=(const CIMDateTime & cDT)
   {
   
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       CIMDateTime dif_cdt = cur_cDT - opt_cDT;
         _rep->copy(dif_cdt._rep);
   
        return;
   }
   
   const CIMDateTime CIMDateTime::operator*(Uint64 num)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
   
   
       if (!this->isInterval()){
           throw TypeMismatchException();
       }
   
       Uint64 cur_num = cur_cDT.toMicroSeconds();
       Uint64 prod = cur_num * num;
       CIMDateTime prod_cdt = CIMDateTime(prod, true);
       CIMDateTime dummy;
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(dummy);
   
       CIMDateTime fin_cdt = prod_cdt.insert_WildCard(splat_pos);
   
   
        return fin_cdt;
   }
   
   
   void CIMDateTime::operator*=(Uint64 num)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
   
       CIMDateTime prod_cdt = cur_cDT * num;
   
       _rep->copy(prod_cdt._rep);
   
        return;
   }
   
   const CIMDateTime CIMDateTime::operator/(Uint64 num)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
   
   
       if (!this->isInterval()){
           throw TypeMismatchException();
       }
   
       Uint64 cur_num = cur_cDT.toMicroSeconds();
       Uint64 prod = cur_num/num;
       CIMDateTime prod_cdt = CIMDateTime(prod, true);
       CIMDateTime dummy;
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(dummy);
       prod_cdt = prod_cdt.insert_WildCard(splat_pos);
   
        return prod_cdt;
   }
   
   
   void CIMDateTime::operator/=(Uint64 num)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
   
       CIMDateTime ans = cur_cDT/num;
       _rep->copy(ans._rep);
   
        return;
   }
   
   
   Uint64 CIMDateTime::operator/(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       if (!cur_cDT.isInterval() || !opt_cDT.isInterval()) {
           throw TypeMismatchException();
       }
   
       Uint64 opt_num = opt_cDT.toMicroSeconds();
       Uint64 cur_num = cur_cDT.toMicroSeconds();
   
       Uint64 ans = cur_num/opt_num;
   
       return ans;
   
   }
   
   
   const Boolean CIMDateTime::operator<(const CIMDateTime & cDT)
   {
   
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       if ((!cur_cDT.isInterval() && opt_cDT.isInterval()) || (cur_cDT.isInterval() && !opt_cDT.isInterval())) {
           throw TypeMismatchException();
       }
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
       CIMDateTime opt_spl = opt_cDT.insert_WildCard(splat_pos);
       CIMDateTime cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
       Uint64 opt_num = opt_spl.toMicroSeconds();
       Uint64 cur_num = cur_spl.toMicroSeconds();
   
       if (cur_num < opt_num) {
           return true;
       }
       else{
           return false;
       }
   }
   
   
   const Boolean CIMDateTime::operator<=(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       if ((!cur_cDT.isInterval() && opt_cDT.isInterval()) || (cur_cDT.isInterval() && !opt_cDT.isInterval())) {
               throw TypeMismatchException();
       }
   
      Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
      CIMDateTime opt_spl = opt_cDT.insert_WildCard(splat_pos);
      CIMDateTime cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
      Uint64 opt_num = opt_spl.toMicroSeconds();
      Uint64 cur_num = cur_spl.toMicroSeconds();
   
      if (cur_num <= opt_num) {
         return true;
      }
      else{
          return false;
           }
    }
   
   
   const Boolean CIMDateTime::operator>(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       if ((!cur_cDT.isInterval() && opt_cDT.isInterval()) || (cur_cDT.isInterval() && !opt_cDT.isInterval())) {
               throw TypeMismatchException();
       }
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
       CIMDateTime opt_spl = opt_cDT.insert_WildCard(splat_pos);
       CIMDateTime cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
       Uint64 opt_num = opt_spl.toMicroSeconds();
       Uint64 cur_num = cur_spl.toMicroSeconds();
   
       if (cur_num > opt_num) {
          return true;
       }
       else{
          return false;
       }
   }
   
   
   const Boolean CIMDateTime::operator>=(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       if ((!cur_cDT.isInterval() && opt_cDT.isInterval()) || (cur_cDT.isInterval() && !opt_cDT.isInterval())) {
               throw TypeMismatchException();
       }
   
      Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
      CIMDateTime opt_spl = opt_cDT.insert_WildCard(splat_pos);
      CIMDateTime cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
      Uint64 opt_num = opt_spl.toMicroSeconds();
      Uint64 cur_num = cur_spl.toMicroSeconds();
   
      if (cur_num >= opt_num) {
         return true;
      }
      else{
         return false;
      }
   }
   
   
   
   const Boolean CIMDateTime::operator!=(const CIMDateTime & cDT)
   {
       CIMDateTime cur_cDT = CIMDateTime((String)(this->_rep->data));
       CIMDateTime opt_cDT = cDT;
   
       Uint32 splat_pos = cur_cDT.getHighestWildCardPosition(opt_cDT);
       CIMDateTime opt_spl = opt_cDT.insert_WildCard(splat_pos);
       CIMDateTime cur_spl = cur_cDT.insert_WildCard(splat_pos);
   
       Uint64 opt_num = opt_spl.toMicroSeconds();
       Uint64 cur_num = cur_spl.toMicroSeconds();
   
       if (cur_num != opt_num) {
           return true;
       }
       else{
           return false;
       }
   }
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.41  
changed lines
  Added in v.1.41.4.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2